[Phoenix-pm] Re: "Perl 6 Now" chapter 1

[Scott Walters]

The silence is deafening. Can anyone commit to doing this in the next day?
Did I mention I was under a time constraint? (Yes, yes, I did). Where's the love?

-scott

On  0, Scott Walters <scott at illogics.org> wrote:
> Again, but chapter 1, which needs some assurance (hint? suggestion?)
> of technical accuracy. The editor will look at it after this and
> suggest structural and content changes, and the copy editor will fix
> any spelling errors I've introduced since I last spell checked it
> and correct grammar and style - so don't worry about those things.
> 
> This chapter exists to get some of the technical things out of the way
> readers might not be familiar with (building Perl from source, etc),
> and also to serve as a more traditional first chapter by defining
> the terms the book is about. I think it overlaps with the intro too
> much still. Hrm.
> 
> Thanks!
> 
> -scott
> 
> 
> 
> =head1 1. The Programmer's Introduction to the Perl Computer Programming Language
> 
> Perl is a technical creation as well as a social creation, and the license it's distributed under
> tells a good deal about what kind of social creation Perl is.
> 
> Perl 5 borrows heavily from other languages, most of which are procedural or special purpose languages,
> and by far, the most powerful features come from the special purpose languages.
> Perl 6 too borrows heavily but favors features from object oriented languages from industry and from
> functional languages from academia.
> 
> As I write this, the latest, unreleased version of the language is needed to run the examples,
> and this chapter will help you download, patch, and build a development version of Perl from sources.
> This book uses Perl modules heavily to demonstrate Perl 6 concepts, and in the interest of
> easily installing these, I'll show you how to set Perl to fetch CPAN modules automatically on
> demand, which is itself a Perl 6 concept.
> Many of these modules tailor, or let you tailor, Perl's behavior to data types, so a summary
> of Perl 5 data types is presented which doubles as a reader's guide to the standard documention
> on built-in functions.
> 
> Chapters after this one outline in detail the changes and addition to Perl 5 that create
> Perl 6, but this chapter first sets the stage for the kinds of changes I'm going to detail.
> 
> 
> =head2 Hello World
> 
> F<perl> is the program that parses and executes Perl programs:
> 
>   $ perl -e 'print "Hello, world!\n";'
> 
> Run that at the command shell for the familiar greeting.
> 
> 
> =head2 Dual-License
> 
> Perl is a copyrighted work, but the owner of the copyright, Larry Wall,
> makes Perl available under two license agreements, as is the privilege of a copyright holder.
> Generally speaking, licenses grant others certain rights to do things
> with a copyrighted work they otherwise wouldn't have under the terms of copyright law.
> Often these license grant precious few rights, such as:  One person at a time may use this 
> software on one computer; the software may not be moved to another computer or sold
> with the computer; you may not reverse engineer this software to build utilities which
> work with it; the copyright holder may revoke at any time this license for you to use
> this software, even though you paid money for it.
> This is in addition to not allowing you to make or distribute copies.
> 
> Perl's license is far less restrictive than this, but there are certain controls in place.
> You have the choice of two licenses, the I<Artistic License> and the I<GNU General Public License>. 
> Under the terms of either license, you're not limited in how you may use Perl,
> and, provided you abide by the terms of the license, the license is non-revokable.
> 
> The Aritistic License, included with Perl in the file named F<Artistic>, allows
> for creation of commercial versions of Perl provided they don't conflict with,
> and are properly distinguished from, the community maintained Perl.
> This allows Larry Wall creative control over the official Perl while others
> are able to make improved and specialized versions.
> The Artistic License also grants programmers the right to embed Perl in
> commercial creations of their own 
> (provided the primary selling point of that creation isn't that Perl is embedded in it).
> This lets you build a business around Perl and even make user extensibility using Perl a 
> feature of products you create.
> Further more, commercial interest may cause Perl to be ported to new platforms where
> the free software developers don't have the knowledge or inclination.
> 
> Under the terms of the GNU GPL, the software community may modify and enhance Perl, and 
> may redistribute, and even sell, copies of Perl (as long as the license is perpetuated in copies).
> As Perl cannot be taken off the market by any single entity, you'll never 
> find yourself helpless to obtain bug or security fixes
> fixes, as any competent C programmer can, with some work, perform this service for you.
> 
> This is a rough summary; read the file F<Artistic>, included with Perl's source code, and the
> GNU GPL at F<http://www.gnu.org/copyleft/gpl.html> for details.
> 
> 
> =head2 Perl's Influences
> 
> I can't think of a better introduction to the Perl language than listing the features
> it sports, much like an advertising brochure might.
> 
> It's widely known Perls 1 through 4 borrowed from "C, sed, awk, and sh" and
> "language historians will also note some vestiges of csh, Pascal, and even BASIC-PLUS"
> (I'm quoting the F<perldoc perl> manual page here).
> Regular expressions originated in I<ed>, the Unix line mode text editor, of which
> I<sed> is a non-interactive version intended for batch processing text data.
> I<awk> is text scanning and reporting language also possessing a decidedly C influence
> (which is little wonder as awk and C shared creators).
> I<csh> apparently contributed some notions of lists and list processing
> (including the C<$#arr> syntax for counting the number of elements in an array, C<@arr>),
> but the ideas of readily piping data to from other programs and expanding variables
> in strings come from shell scripting languages such as csh and sh.
> (sh is the Bourne shell).
> 
> 
> =head3 Perl 5 Influences
> 
> Perls 1 through 4 took from procedural, special purpose text processing, and scripting
> languages, but Perl 5 branched out into functional and and object oriented languages.
> 
> Perl 5.00, released in 1994, introduced objects, a feature first realized in Simula (1968), where it
> languished in academia for nearly 20 years before it was popularized by C++.
> Perl would add support for overloaded operators soon afterwards, allowing programmers
> to use create objects that behaved as ordinary strings and numbers as far as the operators
> are concerned, or even invent new meanings for operators when used on their objects.
> Perl 5.00 also took the idea of lexically scoped variables from Lisp.
> (I<Lexical> is a functional programming concept where it refers to a system of 
> scope and reference counting where a variables are limited in scope
> to the current block).
> 
> From PL/I (1965), Perl 5.005 took multiple concurrent threads of execution.
> 
> Lisp also introduced a concept of I<code as data>, which would later become known as I<reflection>, that
> allows a running program to inspect itself to learn about such things as functions defined and variables
> defined.
> Perl barrowed this idea as well (though no languages outside of the Lisp family of languages
> have truly completed and generalized this idea because Lisp source code is just lists of data).
> 
> 
> =head3 Perl 6 Influences
> 
> Perl 6 continues in the footsteps of Perl 5, drawing from functional, object oriented,
> and specialized languages.
> 
> Python arguments may be passed into functions using the parameter names rather than position in a list.
> In other words, if a function had a variable named C<fred>, a call to that function
> could supply a value for C<fred> with an expressioin of the form C<function(fred = 10)>.
> (Apologizes if there is prior art here I'm not aware of).
> Perl 6 adopts this feature.
> 
> The Lisp folks have a saying about how all other languages slowly evolve towards Lisp.
> Perhaps this is true, of they don't mean evolve I<exclusively> towards Lisp.
> Lisp macros are defined just as regular function call is, but when called, the 
> call executes immediately, stopping compilation momentarily to do so. 
> The output of the macro may be code that's substituted back in in place of the call
> (which may be nothing more than a constant value or variable reference computed at compile time).
> 
> Also useful for extending the language as is an idea from the ML family of languages:
> allowing programms to extend the language by introducing entirely new operators rather
> than merely overloading existing operators.
> 
> Perl 6 better rounds out Perl's reflection facilities, allowing inspection of the parameter names and types
> expected by subroutines and the ability to inspect lexical variables in other lexical contexts.
> 
> Perl 6 adopts Smalltalk's (early 1970's) concept of making everything an object to generalize
> the language and add flexibility to objectish things people want to do.
> In Perl 6, for example, subroutines are objects, and may be queried for information such as
> the parameters they expect, and operators are a kind of subroutine, and likewise may be
> queried for meta-information.
> 
> Python and C both had a concept of user defined types beyond the character and numeric
> types included with the language, and both languages attempted to check for consistant
> use of these types, as, unlike numeric types, they couldn't automatically be converted between.
> Object oriented languages and functional languages alike ran with the idea of 
> program validation, and Perl 6 optionally, on a variable by variable basis, performs this checking.
> 
> The Icon programming language introduced a combinational behavior, where logic tests
> are performed of sets of data, where each set may be composed of other sets.
> This overloads the meanings of the logic operators.
> For example, C<< (1|2|3) = (0|1) >> is true as C<1> exists in both sets.
> Perl 6 includes this feature.
> 
> Perl 5 mplementations are available for most of the features mentioned here,
> including combinational logic, the idea of making everything an object,
> better type checking, and to a degree, named parameters and reflection.
> Other topics are covered in this book as well.
> 
> 
> =head3 Functional and Object Oriented Languages
> 
> I<Object oriented> languages introduce a sence of multiplicity to programming, where
> instead of merely having one module with its own data and functions, you may have
> multiple independent copies of that module, and rather than having a single implementation
> of that module, multiple versions of it may be swapped out and multiple versions may
> be used concurrently in a single program.
> 
> Functions in I<functional languages> are garunteed to return the same results given the
> same arguments, which implies a lack of global variables and a lack of side-effects from expressions.
> For example, there are no special variables to alter the basic rules of pattern matching
> or built-in functions to change the working directory for the entire program.
> As a result of restricting the design of the language, functional languages developed
> powerful primitives for expressing solutions recursively and in terms of pipelining lists
> of data through series of operations.
> Just as many languages are primarily, but not completely, object oriented, most
> functional languages are primarily, but not entirely, functional.
> Lisp, Scheme, Haskell, and the ML family of languages represent functional languages, with
> the last two being the most pure of these.
> 
> Many functional languages, such as Common Lisp and Ocaml (an ML language), 
> have object systems and are thus hybrid languages.
> As Perl 6 adds more list processing built-in functions, it seems fair to call
> it a hybrid language as well.
> 
> 
> =head2 Get and Build Perl
> 
> Examples for this book require Perl 5.8.4 or later.
> Some features described require  "bleeding edge" (unstable) version 5.9.2.
> One module used heavily throughout this book, F<autobox>, requires patches to the Perl interpreter.
> 
> =head3 Microsoft Windows Users
> 
> ActiveState Perl directly interfaces to the Microsoft Windows operating system and because
> of that is normally the preferred version of Perl for Microsoft Windows machines.
> However, it doesn't come with sources and modules aren't built inside of a full POSIX 2 compliant
> environment, and this hobbles some of the more demanding modules documented in this book.
> You're going to need the Cygwin environment to take advantage of this book.
> Download Cygwin from F<< http://www.cygwin.com >>.
> You'll get a small installer that automates fetching and installing potentially hundreds of optional
> software bundles.
> You're going to need a full compiler build environment including F<make>, F<gcc>, and F<bash>.
> After installing Cygwin and the appropriate bundles, you have a Unix-like system
> running on top of Microsoft Windows.
> Cygwin's command shell is F<bash>, the GNU Bourne Again Shell, which works with the
> command line examples in this book.
> Modules install using the process shown XXX section.
> Code examples in this book require no modification to run on Microsoft Windows (especially under
> Cygwin), but you should consult F<perldoc perlport> for information about potential portability
> problems.
> If you don't have F<perldoc> installed, the same documentation is available online at
> F<http://www.perldoc.com>. 
> Follow the instructions in the next section, "Building Perl", for the next steps in
> building Perl from source.
> 
> 
> =head3 Building Perl
> 
> For POSIX 2 compliant systems with full build environment (such as Cygwin, Linux, FreeBSD, and Apple's MacOS X),
> get the portable version of Perl 5 from the CPAN at F<http://www.cpan.org>.
> Fetch the latest source code from F<< ftp://ftp.cpan.org/pub/CPAN/src >>.
> Here are two of the entries right now:
> 
>   -rw-rw-r--   1 ftp     ftp     11930764 Jul 19 21:57 perl-5.8.5.tar.gz
>   -rw-rw-r--   1 ftp     ftp     11995887 Mar 16  2004 perl-5.9.1.tar.gz
> 
> Odd minor numbered versions are development versions. 
> C<< 5.9.1 >> is development (C<9> is the minor version) and C<< 5.8.5 >> is stable (C<8> is the minor version). 
> If you have the F<bunzip2> utility, get the F<bz2> version instead of the F<gz>
> version to save bandwidth.
> On a Unix-like system, the install process might go something like this, assuming Perl
> version 5.8.3:
> 
>   tar -xzvf perl-5.8.5.tar.gz
>   cd perl-5.8.5
>   ./Configure -de && make && make install
> 
> After moving into the directory containg the sources and before running
> F<Configure>, apply the F<< autobox-0.xx/patch/perl-5.x.x.diff >> patch for your version of
> F<perl> and your version of F<autobox>.
> You'll first need to download and uncompress the F<autobox> module from CPAN.
> Find it using the CPAN search engine at F<http://search.cpan.org>.
> 
>   tar -xzvf autobox-0.12.tar.gz
>   tar -xzvf perl-5.8.5.tar.gz
>   cd perl-5.8.5
>   patch < ../autobox-0.12/patch/perl-5.8.5.diff
>   ./Configure -de && make && make install
>   
> Perl's install process will no longer replace F</usr/bin/perl> by default, so if you have a vendor supplied
> version that you'd like to install over top of, use the C<< --prefix >> argument
> to C<Configure>:
> 
>   ./Configure -de --prefix=/usr && make && make install
> 
> After C<make install>, run F<perl -v> and you should see a message similar to:
> 
>   This is perl, v5.9.4 built for i386-netbsd
>   (with 1 registered patch, see perl -V for more detail)
>   
>   Copyright 1987-2004, 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.com/, the Perl Home Page.
> 
> Your version and host platform will likely differ from mine. 
> If you do remove the version of Perl supplied with your operating system, scripts 
> written in Perl that came with your operating system may fail to function - newer versions 
> of Perl 5 are more aware of syntax errors, deprecated features, and grossly unsafe
> operations than earlier versions of Perl 5. 
> 
> If you elect not to replace the F<perl> that came with the system, the default (for most platforms) is to
> install into F</usr/local>. 
> Use F<< #!/usr/local/bin/perl >> as the she-bang line to use the new version you've installed.
> I like to reference specific versions of Perl in my scripts easy upgrades.
> I can then change each script, one by one, to use the new version of Perl and test it.
> This way, no scripts broke completely and escaped attentioned.
> Specific versions of Perl may be referenced explicitly as long as they aren't uninstalled:
> 
>   #!/usr/local/bin/perl5.9.0
> 
> Modules dependant on a specific version of Perl will need to be installed
> for the new version of Perl.
> The old version of the module will stay installed for the old version of Perl.
> The F<cpan> shell's F<autobundle> command creates an installable bundle of modules installed
> for an existing version of Perl and places the bundle under the F<.cpan> directory of your
> home directory (or whereever F<cpan> was configured to place its data).
> This is useful if you've installed modules for the previous version of Perl and programs depend on those modules.
> After installing a new version of Perl, install this bundle as if it were any other
> Perl module.
> XXX reference CPAN module install instructions
> 
> =begin WARNING RedHat's RPM Package Manager
> 
> It is strongly recommended that RedHat users doing serious development
> install Perl from source and not use F<< rpm >> to install modules or 
> updates. Perl does a lot of work to manage different versions of
> module dependencies and RPM was never designed for this complexity.
> 
> =end
> 
> 
> =head3 Development Versions of Perl
> 
> Development versions include bug fixes as well as new features and usually work well.
> Use the F<rsync> utility to download (and update an already downloaded copy) of
> Perl:
> 
>   mkdir bleedperl
>   rsync -avz rsync://ftp.linux.activestate.com/perl-current/ bleedperl/
> 
> To build a development version of F<perl>, you'll need the F<-Dusedevel>
> command line argument to C<./Configure>:
> 
>   cd bleedperl
>   ./Configure -de -Dusedevel && make && make install
> 
> Module incompatabilities and errors with some expressions are common problems. 
> If you don't mind dealing with and reporting these hiccups, running the development version
> helps the testing process.
> 
> 
> =head2 Perl as the Script Interpeter
> 
> The first line of any Perl program should read:
> 
>   #!/usr/bin/perl
> 
> If you're writing Perl on Win32 with the intention of uploading it to a Unix-like system, turn MS-DOS
> style newlines off in your text editor and use this example first line instead:
> 
>   #!/usr/bin/perl --
> 
> This prevents a common problem where Unix-like systems look for a program named
> F<< /usr/bin/perl^M >> (where F<< ^M >> is the character generated by holding down
> the Control key and pressing the M key) and fail to find it. 
> The F<< -- >> tells F<perl> that no futher arguments follow and to ignore the rest of the command line.
> Alternatively, the single line command C<< perl -pi.bak -e 's/\r$//' program_name.pl >>
> will strip MS-DOS style line feeds. 
> You will need to trade the single quotes for double quotes on MS-DOS based systems.
> 
> Unix-like systems use the first line of a program to specify which interpreter
> should run the program when the first line starts with the magic sequence
> C<< #! >>, pronounced I<shebang>. 
> Even Win32 users should use the shebang line. 
> Environments such as Apache use this and Perl itself looks for command line arguments there on the Win32 platform.
> 
> Perl versions 1 through 5 have been mostly backwards compatiable so the 
> executable name F<< perl >> has been kept. 
> Perl 6 currently installs
> as F<< perl6 >> and will probably continue to do so atleast until an
> automatic translation or emulation mechanism is put in place. 
> 
> To distinguish Perl 6 programs from ones written for Perl 5 and earlier, use this
> she-bang line:
> 
>   #!/usr/bin/perl6
> 
> Give programs their she-bang lines and mark them executable with F<< chmod u+x program.pl >>
> and run them as if they were a binary program.
> Common Gateway Interface programs should end in F<.cgi> as most webservers, even on Unix-like
> systems, look at the file extension. 
> Command-line programs written in Perl don't require F<.pl> on the end of their name.
> (What if you rewrite the program in another language later?)
> 
> 
> =head2 Perl Basics
> 
> Comments start with the C<#> character and may appear on the end of the line.
> Not all C<#> characters start comments - they may appear in quoted strings,
> regular expressions, or as user-selected quote characters.
> 
>   # This is a comment
> 
> The she-bang line is a comment to F<perl>.
> 
> Import modules with the C<use> syntax: C<use module @options;>.
> Pragmatic modules  modify the environment in some way
> rather than providing routines or objects or code libraries. 
> These traditionally go next after the she-bang line:
> 
>   #!/usr/bin/perl
> 
>   use strict;
>   use warnings;
> 
> Some modules, such as F<CGI::Carp>, are considered quasi-pragmatic. 
> 
>   # Make sure headers are sent reguardless of most compile time errors - Perl 5
>   use CGI::Carp 'fatalsToBrowser';
> 
> This intercepts warning messages and fatal errors, queuing up warnings in case of a fatal error, and sending
> HTTP headers, fatal errors, and accumulated warnings to C<< STDOUT >>, formatted for display
> by a web browser. 
> F<< CGI::Carp >> is a must for web development.
> As mentioned in L<StrictureByDefault>, C<< use diagnostics >> is handy too,
> especially for those new to Perl needing explanations of what the errors mean. 
> Alternatively, consult F<perldoc perldiag> to discover the meaning of error messages.
> L<DebuggingPerl> deals with common problems.
> 
> C<use> also requests versions. 
> It can request a minimum version of a module or a minimum version of F<perl> itself.
> 
>   use 5.10.0;   # Require atleast perl version 5.10
>   use 6;        # Require perl 6 to run
> 
> Failure looks something like:
> 
>   Perl v5.10.0 required--this is only v5.9.0, stopped at -e line 1.
> 
> This and the C<class> statement are two days Perl 6 code is distinguinshed
> from Perl 5 code.
> 
> 
> =head2 Installing Modules
> 
> Perl is a user-extensible language. 
> Modules are the means by which the language is extended.
> The most important features are the ones we haven't even thought of yet.
> This book makes heavy use of optional modules to extend Perl 5 into doing Perl 6-like things. 
> 
> Perl 6 will fetch and install modules for you, should you attempt to use a module
> you don't currently have installed. 
> We can do this too with Perl 5 with the F<< Acme::Intraweb >> 
> module and the F<< CPANPLUS >> module. 
> F<< CPANPLUS >> also gives you an easy shell to use to install modules manually, invokable with
> the command F<< cpanp >>. 
> Once in the shell, use the F<< install >> command
> with the exact name of a module, without version number, and the module will
> download and install. 
> F<< Acme::Intraweb >> will likely fail on atleast one
> module in this book, so remember that using F<cpan> or F<< cpanp >> are the traditional methods of
> installing modules.
> Fetch F<CPANPLUS> from F<< http://search.cpan.org/search?q=CPANPLUS >>,
> fetch F<Acme::Intraweb> from F<< http://search.cpan.org/search?q=Acme::Intraweb >>,
> and install them by hand. 
> In the search results, the bolded name takes you to the documentation, 
> and the smaller version with version number takes you to a screen with a download link.
> Click on F<Acme-Intraweb-1.01> in the search results for C<< Acme::Intraweb >>, for example.
> 
>   tar -xzvf CPANPLUS-0.048.tar.gz
>   cd CPANPLUS-0.048
>   perl Makefile.PL
>   make
>   make test
>   make install
> 
> This procedure is standard. 
> Repeat the process for F<< Acme::Intraweb >>.
> 
> 
> =head2 Data Types
> 
> Perl features true X<lexical> variables. 
> Lexicals are rare treat for a language frequently used outside of acedamia to write production code. 
> Lexical variables are valid in any code until the end of the block. 
> Even if a reference to a portion of that code is returned or stored and then 
> executed later, those variables will still have their values.
> The values will be remembered even if the routine has since been called again.
> This feature comes to us by way of Lisp. 
> Declare lexical variables using the C<my> keyword.
> Perl's basic data types are hashes, arrays, and scalars, any of which can be lexicals when
> declared with C<my>:
> 
>   # Lexical variables - Perl 5 and Perl 6
> 
>   my $foo;   # declares a scalar - references are scalars
>   my @foo;   # declares an array
>   my %foo;   # declares a hash
> 
> Scalars may hold references to other things such as regular expressions, objects, and code.
> 
> 
> =begin NOTE Naming Things
> 
> Variables traditionally have lower case names with underscores separating words,
> C<< $like_this >>. 
> Constants traditionally are written in all capital letters
> with or without underscores, C<< $LIKETHIS >>. 
> Class names are written in mixed case with no underscores, C<< SuchAsThis >>.
> 
> =end NOTE
> 
> Typing F<< perldoc perlfunc >> at the shell pulls up documention for the built-in functions. 
> The Perl core is rich in functions that interface to the operating
> system, and work on arrays and hashes.
> F<perldoc perlfunc> uses a sort of short-hand when listing the functions.
> For example, C<chomp> is listed with three forms:
>  
>    chomp VARIABLE
>    chomp( LIST )
>    chomp   
> 
> C<chomp> will work on any variable, a list of terms, or without an argument at all. 
> Built-in functions like C<chomp> may do completely different
> things depending on how you use the result (which context they execute in) and what you pass to them.
> Prossiblities for the kinds of things you pass to built-ins are:
> 
> =over 1
> 
> =item C<VARIABLE> - any variable, such as C<$scalar_var>, C<@array_var>, C<%hash_var>
> 
> =item C<LIST> - one or more values of arbitrary origin, all in a list
> 
> =item C<ARRAY> - an array variable, which looks like C<@foo>
> 
> =item C<HASH> - a hash variable, which looks like C<%foo>
> 
> =item C<EXPR> - sometimes an expression that products a hash value, sometimes an expression that picks a value out of an
> array, other times other things
> 
> =item C<NUMBER> - a number
> 
> =item C<FILENAME> - a string representing the name of a file
> 
> =item C<FILEHANDLE> - the result of opening a file as well as C<STDOUT>, C<STDIN>, and C<STDERR>
> 
> =item C<BLOCK> - a block of code, either right there, or else a reference to a subroutine
> 
> =item Others - other values with less formal meanings are used, too
> 
> =item None - operators on the default variable, C<$_>
> 
> =back
> 
> Operations that require an C<ARRAY> won't accept a C<LIST>. 
> An array can be modified in various ways where a list is read-only. 
> 
> 
> =head2 Chapter Summary
> 
> That's the penny tour. 
> F<perldoc perlintro> is another quick introduction to Perl, complimentary to this chapter,
> that introduces Perl from the perspective of its basic syntax.
> You should have F<perl> installed and built from source
> (though many examples will still work with only a reasonably modern but otherwise unmodified F<perl>).
> You should know how to install modules, know where to go for documentation on
> for modules, for operators, and for built-in functions.
> I've tried to convey how Perl builds on the ideas of other languages, and how
> the individual ideas are more valuable for being combined in a greater-than-the-sum-of-their-parts sort of way.
>