Perl was created by Larry Wall, who had previously released programs used by every system administrator (patch) or casual Unix user (rn news reader, the closest thing to a web browser in those days). As for the Perl language, we actually don’t know when it was first created. In the perlhist document that ships with Perl, Larry lists the creation data of Perl 0 as “Classified”. However, Perl 1.000 was released to the world on December 18th, 1987, well over 20 years ago. Larry probably didn’t realize the huge impact this language would have. Here’s the beginning of the 11 page manpage (manual) that was originally included with Perl:

NAME
    perl | Practical Extraction and Report Language

SYNOPSIS
    perl [options] filename args

DESCRIPTION
    Perl is a interpreted language optimized for scanning  arbi-
    trary  text  files,  extracting  information from those text
    files, and printing reports based on that information.  It's
    also  a good language for many system management tasks.  The
    language is intended to be practical  (easy  to  use,  effi-
    cient,  complete)  rather  than  beautiful  (tiny,  elegant,
    minimal).  It combines (in  the  author's  opinion,  anyway)
    some  of the best features of C, sed, awk, and sh, so people
    familiar with those languages should have little  difficulty
    with  it.  (Language historians will also note some vestiges
    of csh, Pascal, and  even  BASIC|PLUS.)   Expression  syntax
    corresponds  quite  closely  to C expression syntax.  If you
    have a problem that would ordinarily use sed or awk  or  sh,
    but  it exceeds their capabilities or must run a little fas-
    ter, and you don't want to write the silly thing in C,  then
    perl  may  be  for  you.  There are also translators to turn
    your sed and awk scripts  into  perl  scripts.   OK,  enough
    hype.

... never write "PERL", because perl is not an acronym, apocryphal
 folklore and post-facto expansions notwithstanding.

From that humble beginning, Perl grew rapidly. Version 2.000 was released in June of 1988. Version 3.000 was released in October, 1989. In March of 1991, Perl 4 was released, but that was largely the same as Perl 3 with the version number bumped up to make it clear which version O’Reilly’s “Programming Perl” (a.k.a., “The Camel Book”) was referring to.

By the early 90s, Perl had become extremely popular. Its versatility, power, and ease of use led to widespread adoption. And then in October of 1994, Perl 5 was released just as the dot com explosion was getting under way. When you work with the Web, you know web pages are mostly text being sent back and forth. Perl excels at text processing. Because of this, Perl became known as the “duct tape of the Internet” and in an age where merely having “HTML” on your resume guaranteed a job, having Perl next to it meant you were guaranteed an even better paying job.

For many developers, the best strategy for getting a pay raise was to quit every six months and take a new job. Many people who had never programmed before were picking up the basics of Perl and commanding generous salaries. Many Web designers who knew HTML and started playing with this new thing called JavaScript quickly learned that Perl could let them do things with their Web sites that they had never dreamed possible. The rise of the Internet meant the world would never be the same and Perl was driving much of that change.

Perl, in fact, was becoming so popular that it was working its way into our popular culture. The movie Sphere had a bit of Perl (http://www.foo.be/docs/tpj/issues/vol3_4/tpj0304-0013.html), Neal Stephenson included Perl code in the novel Cryptonomicon and Charles Stross, the excellent and now famous science fiction author, wrote a Lovecraftian paean to Perl in issue 4 of The Perl Journal (http://www.foo.be/docs/tpj/issues/vol1_4/tpj0104-0010.html). Truly Perl is the official programming language of the sunken city of R’Lyeh, where dead Cthulhu lies dreaming.

Perl was king, but naturally, competitors arose. Python, first released in 1991, appealed to many due to its simple, easy to learn syntax. Ruby was first released in 1995, but did not become well-known until the release of Ruby on Rails almost a decade later. PHP, originally written in Perl and released in 1995, became a standalone language and is today one of the most popular languages for Web development.

The rise of competition and the love of The Shiny And New meant that Perl’s popularity fell a bit in the 2000s, but it appears to be stabilizing and job site statistics shows that Perl is still one of the most popular dynamic languages around. There is actually a strong job market for Perl and not enough programmers, putting experienced Perl developers in an enviable employment position.

After Perl 5 was released, there were various releases up to the March 2000 release of Perl 5.6.0, the start of what many think of as the “modern era” for Perl. Amongst other things, it included Unicode and 64-bit support. Table 1-1 summarizes the release dates of many “major” releases of Perl. Note that the format of version numbers changed with the Perl 5.6.0 release.

As of this writing, Jesse Vincent is overseeing the development of Perl 5.16.0. Perl 6, a new language derived from Perl and a rich variety of other sources, is being actively worked on with several interesting implementations, including a Niecza, which runs on Mono/.NET.

Today Perl is widely used throughout the world. As mentioned, it comes standard on every major operating system apart from Windows. It is still extensively used in Web development, driving many Web sites. New startups are choosing Perl as their language of choice for data processing, system administration, Web development, and other uses. A quick search of many job sites shows plenty of opportunities, but there are fewer competent developers competing for these roles. If a career in Perl interests you, you can also check out http://jobs.perl.org/ for a Web site dedicated to listing jobs that have Perl as their major technology as opposed to jobs where Perl is merely used incidentally.

Given the long history of Perl and the state of Perl today, you might wonder which version of Perl this book covers. This book will mostly focus on 5.8.x and 5.10.x versions of Perl, even though support for both of these has officially been discontinued. Why? This was a difficult decision to make, but there were several reasons for this decision. An important consideration is surveys showing that most businesses are still running these versions of Perl. It’s a strange thing for a book author to stand up and say “this book targets an unsupported version of the language”, but you go to war with the Perl you have, not the Perl you want.

Fortunately, this choice isn’t as bad as it might sound. The Perl 5 Porters (known as “P5P”) work very hard to keep new releases of Perl backwards compatible. Perl 5.14.2 ships with almost half a million tests (455,832 to be exact) to ensure that Perl works exactly as intended. Thus, what you learn to write through this book will generally work unmodified on later versions of Perl.

So how do you get Perl? Well, you’re in luck. Almost every major operating system aside from Windows ships with Perl by default. You can test this by opening up a terminal and typing perl -v at the command line. Currently on my MacBook Pro this prints:

$ perl -v
This is perl 5, version 14, subversion 2 (v5.14.2) built for darwin-2level
Copyright 1987-2011, Larry Wall
Perl may be copied only under the terms of either the Artistic License or the
GNU General Public License, which may be found in the Perl 5 source kit.
Complete documentation for Perl, including FAQ lists, should be found on
this system using "man perl" or "perldoc perl". If you have access to the
Internet, point your browser at http://www.perl.org/, the Perl Home Page.

Currently Perl is supported on over 100 platforms (did you even know there were that many?). If you want a different version of Perl than what you already have installed, check out http://www.perl.org/get.html.

If you are not running Windows, check out perlbrew (http://www.perlbrew.pl/). This will allow you to run multiple different installations of Perl. This is important because there’s a good chance that some of your operating system depends on the behavior of the system Perl. Therefore, using perlbrew to install your own versions of Perl not only ensures that you don’t have to worry about breaking your system Perl, you also can play with different versions. That being said, so long as you’re not overwriting any modules that your system Perl uses, it’s fine to use your system Perl for learning Perl. It’s also usually fine to upgrade your system modules, but it’s not recommended. If a core module your system depends on changes in an incompatible way, the results are unpredictable. Windows does not have this problem because it does not depend on Perl.

If your system has both bash and curl installed, you can try to install perlbrew with:

curl -kL http://xrl.us/perlbrewinstall | bash

If that works on your system, it should allow you to easily install multiple versions of Perl without superuser (root) permissions. It’s then easy to switch between those versions. This has many benefits, including the following:

Once installed, you can type perlbrew help to understand how to use it. It’s pretty easy. To install and use Perl version 5.14.2:

perlbrew install perl-5.14.2
perlbrew switch perl-5.14.2

Note that the installation will take a while because perlbrew needs to download and build the version of Perl you’re asking for.

If you want to install an older version of Perl, you can run:

perlbrew install perl-5.8.3

You can run perlbrew list to see which versions of Perl you have installed and can switch to. Here’s your author’s setup as he’s writing this:

$ perlbrew list
  perl-5.10.1
  perl-5.12.3
  perl-5.14.0
* perl-5.14.2
  perl-5.8.3

The asterisk before the version indicates which version of Perl you’re running at the moment.

And finally, to test your code against different versions of Perl:

perlbrew exec myprogram.pl

Your author has been using this extensively while writing this book. This is extremely useful when you want to find out if your code is compatible with different versions of Perl.

As of this writing, these are the Perl versions available to install (using the perlbrew available command):

$ perlbrew available
  perl-5.15.4
i perl-5.14.2
  perl-5.12.4
i perl-5.10.1
  perl-5.8.9
  perl-5.6.2
  perl5.005_04
  perl5.004_05
  perl5.003_07

The leading i indicates which versions of Perl you have installed and the list of available versions will grow over time.

If you can use perlbrew, it will make your programming life much more pleasant.

Windows is one of the few operating systems that does not include Perl by default. This makes things a bit more difficult, but you have a wide variety of options here. Your author recommends Strawberry Perl, but ActivePerl is also an excellent choice. Cygwin is only recommended if you want a Linux emulation layer.

IRC, or “Internet Relay Chat”, has been around since 1988 and it’s often a great way to get questions answered “in real time”. For Windows, mIRC (http://www.mirc.net/) is probably the most popular IRC client, but it’s shareware and you can only use it for 30 days before paying. KVIrc (http://www.kvirc.net/) is a good, free choice for a graphical IRC client and it’s available for most platforms. For OS X, I use Colloquy (http://colloquy.info/), but really, any IRC client you’re comfortable with is fine. If you use the Firefox browser, it has the capable Chatzilla (http://chatzilla.hacksrus.com/) add-on and this should work regardless of which operating system you choose.

You can also access freenode with any browser via http://webchat.freenode.net/.

Once you get on IRC, connect to the irc.freenode.net server and join #perl. The #perl channel generally has plenty of users and you can get many Perl questions answered quickly and easily ... or at least get told where to RTFM (that stands for “Read The Manual”. The “F” is silent).

If you’re not familiar with IRC, hit you favorite search engine and search for “list of IRC commands”. You can also consult the Wikipedia page for IRC (http://en.wikipedia.org/wiki/Irc) for more information, including lists of other IRC clients.

PerlMonks (http://www.perlmonks.org/) is a fantastically useful Perl site that’s been around for over a decade. Your author joined back in 2000, unsurprisingly as “Ovid”, and has been a regular contributor for years.

In the top right hand corner of the site you’ll see many useful links. “Seekers of Perl Wisdom” is probably the most useful when you need an answer to a problem you’re facing. When you first post a question, it will show in “Newest Nodes” and many people follow that to try to help answer the new questions. Fortunately, the regular users at PerlMonks generally don’t suffer as much from “first post” silliness you often find at other sites.

In addition to answering questions, PerlMonks has book reviews, “Meditations” (a section for people who just want to muse about Perl-related things), tutorials, Perl news, site discussion, and a “chatterbox” for those who just want casual conversation or have a quick question.

If you’re serious about learning Perl, PerlMonks is a good place to start. Many of the top minds in Perl hang out there and it’s a good resource with plenty of history to search through. PerlMonks is “all Perl, all the time.” Joe Bob says “check it out.”

For those who like a bit of real-life interaction (and who doesn’t?), there’s also Perl Mongers (http://www.pm.org/). Founded by brian d foy in 1997, Perl Mongers is an organization of Perl hackers in different cities who meet periodically to, well, do whatever they want. Your author ran the Perl Mongers group in Portland, Oregon (Portland.pm) for several years, and has attended Perl Mongers meetings in a number of countries.

The local Perl Mongers user groups are Perl enthusiasts who enjoy hanging out together and talking about stuff. Sometimes that stuff is Perl. The Portland.pm group generally schedules technical talks followed by a “social” at a local pub, often the excellent Lucky Lab in Portland, Oregon. If you ever visit Portland, check out that pub.

There are Perl Mongers groups on every continent except Antarctica, but there was discussion of that when we found out there was a Perl programmer there. If you live near a major city, there’s a good chance there’s a Perl Mongers group close to you. If not, create one!

StackOverflow (http://stackoverflow.com/) was created in 2008 by Joel Spolsky and Jeff Atwood as an “open” site for anyone to ask programming related questions. It has spun off numerous related sites and has become extremely popular as the site to ask just about any technology question that comes to mind. Perl questions are answered quickly with solid information and you can easily see the “rating” of the users who respond to your questions. Because of the nature how questions are tagged, it’s easy to quickly drill down to questions that might be relevant to your situation.

The Perl documentation is written in POD, short for “Plain Old Documentation”. POD is a very easy to learn markup language for documenting Perl. In fact, it’s easy enough to learn (and you will in Chapter 11, Packages and Modules), but flexible enough, that many authors write their books in POD (I almost did, but it’s a long story why not).

When you type perldoc <documentation name>, the program searches through parts of your system where it thinks the documentation may be found, looking for a file with a .pod or .pm extension (the former is preferred, the latter is used if it has embedded POD and the former is not found). It then formats the POD and displays it to you. For earlier versions of perldoc, you could add the -v switch to see where it is looking for your POD:

perldoc -v perldoc

If your version of perldoc supports this, use the -D switch to see where perldoc is looking for the documentation. The -v switch is now used to display the description of Perl’s built-in variables:

perldoc -v '$_'
perldoc -v '@ARGV'

(Or you can just type perldoc perlvar to see all of Perl’s built-in variables).

You can read perldoc perldoc for more information about how to customize its output or to see what other command line switches it supports.

The first thing you want to do is type perldoc perl. This will give you a very brief description of some of what Perl can do and it quickly directs you to:

perldoc perlintro

That’s a gentle introduction to Perl. If you’re really dedicated, you could start there and not buy this or any other Perl book. That approach works if you have lots of time and patience. This book presents what you need to know most, including where to get more.

Note that the perlintro is clear, but very terse. It assumes that you already know how to program and rushes through the basic features of the language. As a result, there are many bits and pieces you should be aware of, but won’t be. So to follow up on the perlintro, you’ll want:

perldoc perltoc

As you might expect, that’s the “Table of Contents” for the Perl documentation. For Perl 5.14.2, that “Table of Contents” is over 20,000 lines long! That’s a huge amount of documentation. It’s longer than many of the chapters in this book and your author hopes his publisher doesn’t notice. In contrast, Perl 5.8.3’s table of contents weighs in at a measly 11,911 lines. However, since we’ll mostly be focusing on 5.8 and 5.10, we won’t really talk (much) about what’s in those newer documents.

Perl comes bundled with many tutorials you can read with perldoc. The tutorials are listed in Table 1-2 are some of the popular tutorials included in Perl version 5.8.3.

You can type perldoc <tutorialname> to read these tutorials.

Since I’m having so much fun cutting and pasting from the documentation and padding my page count, Table 1-3 lists the FAQs (Frequently Asked Questions) that ship with Perl:

These FAQs are extensive. For example, here are some of the questions addressed in perlfaq2:

What’s really nice is that for any of these questions, you can type perldoc -q "something I'm looking for" and perldoc will spit out the sections from any FAQ which match the term you give it (actually, perldoc will match against what’s called a “regular expression”, but we’re not covering those until Chapter 8, Regular Expressions, so pretend you didn’t read that bit).

We also have a full reference manual shipped with the Perl documentation along with extensive information about the internals of Perl (not for the faint of heart), linking Perl to C and C++ programs, platform specific information, and other things we won’t cover in this book.

One of the most useful perldoc commands is perldoc -f, followed by a function name, you can see a complete description of the function in question and quite possibly far more than you will ever need to know. For example, perldoc -f my displays the following:

my EXPR
my TYPE EXPR
my EXPR : ATTRS
my TYPE EXPR : ATTRS
        A "my" declares the listed variables to be local (lexically) to
        the enclosing block, file, or "eval".  If more than one value
        is listed, the list must be placed in parentheses.
        The exact semantics and interface of TYPE and ATTRS are still
        evolving.  TYPE is currently bound to the use of the "fields"
        pragma, and attributes are handled using the "attributes"
        pragma, or starting from Perl 5.8.0 also via the
        "Attribute::Handlers" module.  See "Private Variables via my()"
        in perlsub for details, and fields, attributes, and
        Attribute::Handlers.

It starts with the grammar for the function and then a brief (and sometimes very verbose) explanation of that function. In the example above, the grammar could represent any of the following:

my $dog;
my Dog $spot;
my $dog : HasSpots;
my Dog $spot : HasSpots;

Perl comes from a Unix background and as a result, is often run from a terminal window. Unlike many GUI (Graphical User Interface) systems, terminals allow you to type commands directly into the system rather than clicking an icon on a screen or selecting items from menus. Getting used to the command line will eventually give you all of the power of a GUI system, but also leverage the considerable power of the command line. If you’re not familiar with it, you’ll want to hit your favorite search engine for how to use the command line on your system, but for now, we’ll just concentrate on getting a terminal window open.

This isn’t very hard, but ask a geek friend for help if you get stuck.

Now that you have a terminal window open, you might want to have a clue where you are on your system. To see the current directory you are in, you can type pwd (print working directory) on Linux or OS X, or cd (with no arguments) on Windows. You can type ls on Linux or OS X to see a list of files in the current directory or dir if you’re on Windows.

You’ll want to create a folder named wroxperl and change to it. For all operating systems, you should be able to type this:

mkdir wroxperl
cd wroxperl

You should now be in an empty directory, suitable for creating your sample programs. I recommend that when you create them, you make them in separate directories named chapter1, chapter2, and so on. This will make it easier to organize and refer back to them. So go ahead and create a chapter1 directory now and change to it:

mkdir chapter1
cd chapter1

You won’t need this until we get to our “Hello, World!” program (it’s a law that all programming books have to start with this), but stay in the terminal for now because you’re going to get used to the perldoc command.

sudo apt-get install perl-doc

perl -le 'print join "\n", @INC, map {split /:/} @ENV{qw/PERL5LIB PATH/}'

First, open your terminal and type this:

perl -e 'print "Hello, Wrox!\n"'

Oh, wait. Sorry Windows people. You have to type this:

perl -e "print \"Hello, Wrox!\n\""

Except that it might not work, depending on your version of Windows. See perldoc perlfaq3 and read the section entitled “Why don’t Perl one-liners work on my DOS/Mac/VMS system?” to understand why your life is more difficult. If you have a Mac, the “Mac” section likely will not apply to you as OS X handles Perl and the command line quite well, thank you.

Aside from my blatant brown-nosing of my publisher, the “Hello, Wrox!” snippet shows something very common about Perl: running Perl from the command line. This won’t be covered much this much in the book, but as you get more familiar with Perl, you’ll see people doing things like this:

perl -pi.bak -e 's/version = 13/version = 14/' <list of files>

That will change all strings in <list of files> matching “version = 13” to “version = 14” and create backups of all of those files with a .bak extension. That’s more or less equivalent to this Perl program that is also listed in perldoc perlrun (though we’ve cleaned it up to be “safer”).

#!/usr/bin/perl
my $extension = '.bak';
my $oldargv;
LINE: while (<>) {
    if ($ARGV ne $oldargv) {
        my $backup;
        if ($extension !~ /\*/) {
            $backup = $ARGV . $extension;
        }
        else {
            ($backup = $extension) =~ s/\*/$ARGV/g;
        }
        rename($ARGV, $backup);
        open(ARGVOUT, ">$ARGV");
        select(ARGVOUT);
        $oldargv = $ARGV;
    }
    s/version = 13/version = 14/;
}
continue {
    print;  # this prints to original filename
}
select(STDOUT);

As you can see, using Perl on the command line effectively can give you a lot of power to get things done quickly. You can read perldoc perlrun to understand some of this, but you should search for “perl one-liners” online to see what you can do if you’re interested in this area.

Getting back to “Hello, World!”, the general way you write a Perl program is to save a file with the program code and then type perl <programname>. The first line of the program is often the shebang line, which we’ll explain a more about in a bit. After that is your program text. All you need to do to get a basic Perl program running is to type up your program, save it (usually with a .pl extension), and then type perl programname. Listing 1-1 is a short Perl program that shows how a simple program may look. We will explain the strict, warnings and diagnostics in Chapter 3, Variables.

#!perl
use strict;
use warnings;
use diagnostics;
# this is a comment
print "Hello, World!\n"; # so is this

<STDIN>;

The first line of a Perl program often starts with a shebang line. A shebang line starts with “sharp” (#) and an exclamation point, also known as a “bang” (!), hence the term “shebang”. It is followed by a path telling the shell where to find the interpreter. On a system which understands the chmod command, you can type chmod +x programname to make the program directly executable. If it’s in your path, you can then type programname to run the program. Otherwise, you can type the full or relative path to the program to execute it. For example, if you’re in /Users/ovid/wroxperl/chapter1 and you create a program called runme in that directory, you could run it like this:

$ ./runme
$ /Users/ovid/wroxperl/chapter1/runme

For now, you can just type perl programname to run the programs.

The shebang line might take one of a number of different forms. On a Linux system, this will often look like one of the following:

#!/usr/bin/perl
#!/usr/local/bin/perl
#!/usr/bin/perl -w
#!/usr/bin/env perl

The first two versions point directly to the Perl executable which should run the program. The third version, with the -w switch, tells Perl to run the program with global warnings. The final version tells Perl to use the env program to find out which perl is currently set as the default perl for your system.

Some people just do the following:

#!/perl

And that will generally do what you want.

On Windows you might see the following:

#!C:\Perl\bin\perl.exe
#!C:\strawberry\perl\bin\perl.exe

The first version is often found when running with ActiveState Perl. The second version is found when running with Strawberry Perl.

When perl sees the shebang line, it will attempt to run your program using whatever it finds after the #!. Generally this will not be a problem, but if you find that you want to run the script on more than one machine, even with the same architecture, you could have a problem if someone installs perl in a different location.

Fortunately, there is one simple trick you can follow to ensure you don’t have problems with shebang lines: don’t install modules and scripts by hand. Instead, you package them as proper distributions and install them with the standard Perl toolchain (such as cpan or cpanm). You will learn module installation in Chapter 2 and module writing in Chapter 11, Packages and Modules.