From: brian d foy <bdfoy@cpan.org>
Date: Thu, 17 Jun 2010 20:41:05 +0000 (-0700)
Subject: * FAQ sync
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=d12d61cff231dfdae5d1887a5c3905cbc67f0168;p=p5sagit%2Fp5-mst-13.2.git

* FAQ sync

This is commit 37550b8f812e591bcd0dd869d61677dac5bda92c from the
perlfaq repository at git@github.com:briandfoy/perlfaq.git
---

diff --git a/pod/perlfaq1.pod b/pod/perlfaq1.pod
index 288374b..16f5801 100644
--- a/pod/perlfaq1.pod
+++ b/pod/perlfaq1.pod
@@ -10,7 +10,7 @@ about Perl.
 =head2 What is Perl?
 
 Perl is a high-level programming language with an eclectic heritage
-written by Larry Wall and a cast of thousands.  It derives from the
+written by Larry Wall and a cast of thousands. It derives from the
 ubiquitous C programming language and to a lesser extent from sed,
 awk, the Unix shell, and at least a dozen other tools and languages.
 Perl's process, file, and text manipulation facilities make it
@@ -19,39 +19,39 @@ utilities, software tools, system management tasks, database access,
 graphical programming, networking, and world wide web programming.
 These strengths make it especially popular with system administrators
 and CGI script authors, but mathematicians, geneticists, journalists,
-and even managers also use Perl.  Maybe you should, too.
+and even managers also use Perl. Maybe you should, too.
 
-=head2 Who supports Perl?  Who develops it?  Why is it free?
+=head2 Who supports Perl? Who develops it? Why is it free?
 
 The original culture of the pre-populist Internet and the deeply-held
 beliefs of Perl's author, Larry Wall, gave rise to the free and open
-distribution policy of perl.  Perl is supported by its users.  The
+distribution policy of perl. Perl is supported by its users. The
 core, the standard Perl library, the optional modules, and the
-documentation you're reading now were all written by volunteers.  See
+documentation you're reading now were all written by volunteers. See
 the personal note at the end of the README file in the perl source
-distribution for more details.  See L<perlhist> (new as of 5.005)
+distribution for more details. See L<perlhist> (new as of 5.005)
 for Perl's milestone releases.
 
 In particular, the core development team (known as the Perl Porters)
 are a rag-tag band of highly altruistic individuals committed to
 producing better software for free than you could hope to purchase for
-money.  You may snoop on pending developments via the archives at
+money. You may snoop on pending developments via the archives at
 http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/
 and http://archive.develooper.com/perl5-porters@perl.org/
 or the news gateway nntp://nntp.perl.org/perl.perl5.porters or
 its web interface at http://nntp.perl.org/group/perl.perl5.porters ,
 or read the faq at http://dev.perl.org/perl5/docs/p5p-faq.html ,
 or you can subscribe to the mailing list by sending
-perl5-porters-request@perl.org a subscription request
+perl5-porters-subscribe@perl.org a subscription request
 (an empty message with no subject is fine).
 
 While the GNU project includes Perl in its distributions, there's no
-such thing as "GNU Perl".  Perl is not produced nor maintained by the
-Free Software Foundation.  Perl's licensing terms are also more open
+such thing as "GNU Perl". Perl is not produced nor maintained by the
+Free Software Foundation. Perl's licensing terms are also more open
 than GNU software's tend to be.
 
 You can get commercial support of Perl if you wish, although for most
-users the informal support will more than suffice.  See the answer to
+users the informal support will more than suffice. See the answer to
 "Where can I buy a commercial version of perl?" for more information.
 
 =head2 Which version of Perl should I use?
@@ -101,22 +101,22 @@ for a while, although not at the same level as the current releases.
 
 =item *
 
-No one is actively supporting Perl 4.  Five years ago it was a dead
-camel carcass (according to this document).  Now it's barely a skeleton
+No one is actively supporting Perl 4. Five years ago it was a dead
+camel carcass (according to this document). Now it's barely a skeleton
 as its whitewashed bones have fractured or eroded.
 
 =item *
 
 There is no Perl 6 release scheduled, but it will be available when
-it's ready.  Stay tuned, but don't worry that you'll have to change
+it's ready. Stay tuned, but don't worry that you'll have to change
 major versions of Perl; no one is going to take Perl 5 away from you.
 
 =item *
 
 There are really two tracks of perl development: a maintenance version
-and an experimental version.  The maintenance versions are stable, and
+and an experimental version. The maintenance versions are stable, and
 have an even number as the minor release (i.e. perl5.10.x, where 10 is the
-minor release).  The experimental versions may include features that
+minor release). The experimental versions may include features that
 don't make it into the stable versions, and have an odd number as the
 minor release (i.e. perl5.9.x, where 9 is the minor release).
 
@@ -131,21 +131,21 @@ In short, Perl 4 is the past, Perl 5 is the present, and Perl 6 is the
 future.
 
 The number after perl (i.e. the 5 after Perl 5) is the major release
-of the perl interpreter as well as the version of the language.  Each
+of the perl interpreter as well as the version of the language. Each
 major version has significant differences that earlier versions cannot
 support.
 
 The current major release of Perl is Perl 5, and was released in 1994.
 It can run scripts from the previous major release, Perl 4 (March 1991),
 but has significant differences. It introduced the concept of references,
-complex data structures, and modules.  The Perl 5 interpreter was a
+complex data structures, and modules. The Perl 5 interpreter was a
 complete re-write of the previous perl sources.
 
 Perl 6 is the next major version of Perl, but it's still in development
-in both its syntax and design.  The work started in 2002 and is still
-ongoing.  Many of the most interesting features have shown up in the
+in both its syntax and design. The work started in 2002 and is still
+ongoing. Many of the most interesting features have shown up in the
 latest versions of Perl 5, and some Perl 5 modules allow you to use some
-Perl 6 syntax in your programs.  You can learn more about Perl 6 at
+Perl 6 syntax in your programs. You can learn more about Perl 6 at
 http://dev.perl.org/perl6/ .
 
 See L<perlhist> for a history of Perl revisions.
@@ -162,7 +162,7 @@ Perl Foundation. It was abandoned in 2006
 Instead of using the current Perl internals, Ponie aimed to create a
 new one that would provide a translation path from Perl 5 to Perl 6
 (or anything else that targets Parrot, actually). You would have been
-able  to just keep using Perl 5 with Parrot, the virtual machine which
+able to just keep using Perl 5 with Parrot, the virtual machine which
 will compile and run Perl 6 bytecode.
 
 =head2 What is Perl 6?
@@ -187,51 +187,51 @@ you need to do.
 =head2 How stable is Perl?
 
 Production releases, which incorporate bug fixes and new functionality,
-are widely tested before release.  Since the 5.000 release, we have
+are widely tested before release. Since the 5.000 release, we have
 averaged only about one production release per year.
 
 Larry and the Perl development team occasionally make changes to the
 internal core of the language, but all possible efforts are made toward
-backward compatibility.  While not quite all Perl 4 scripts run flawlessly
+backward compatibility. While not quite all Perl 4 scripts run flawlessly
 under Perl 5, an update to perl should nearly never invalidate a program
 written for an earlier version of perl (barring accidental bug fixes
 and the rare new keyword).
 
 =head2 Is Perl difficult to learn?
 
-No, Perl is easy to start learning--and easy to keep learning.  It looks
+No, Perl is easy to start learning--and easy to keep learning. It looks
 like most programming languages you're likely to have experience
 with, so if you've ever written a C program, an awk script, a shell
 script, or even a BASIC program, you're already partway there.
 
-Most tasks only require a small subset of the Perl language.  One of
+Most tasks only require a small subset of the Perl language. One of
 the guiding mottos for Perl development is "there's more than one way
-to do it" (TMTOWTDI, sometimes pronounced "tim toady").  Perl's
+to do it" (TMTOWTDI, sometimes pronounced "tim toady"). Perl's
 learning curve is therefore shallow (easy to learn) and long (there's
 a whole lot you can do if you really want).
 
 Finally, because Perl is frequently (but not always, and certainly not by
 definition) an interpreted language, you can write your programs and test
 them without an intermediate compilation step, allowing you to experiment
-and test/debug quickly and easily.  This ease of experimentation flattens
+and test/debug quickly and easily. This ease of experimentation flattens
 the learning curve even more.
 
 Things that make Perl easier to learn: Unix experience, almost any kind
 of programming experience, an understanding of regular expressions, and
-the ability to understand other people's code.  If there's something you
+the ability to understand other people's code. If there's something you
 need to do, then it's probably already been done, and a working example is
-usually available for free.  Don't forget Perl modules, either.
+usually available for free. Don't forget Perl modules, either.
 They're discussed in Part 3 of this FAQ, along with CPAN, which is
 discussed in Part 2.
 
 =head2 How does Perl compare with other languages like Java, Python, REXX, Scheme, or Tcl?
 
-Favorably in some areas, unfavorably in others.  Precisely which areas
+Favorably in some areas, unfavorably in others. Precisely which areas
 are good and bad is often a personal choice, so asking this question
 on Usenet runs a strong risk of starting an unproductive Holy War.
 
 Probably the best thing to do is try to write equivalent code to do a
-set of tasks.  These languages have their own newsgroups in which you
+set of tasks. These languages have their own newsgroups in which you
 can learn about (but hopefully not argue about) them.
 
 Some comparison documents can be found at http://www.perl.com/doc/FMTEYEWTK/versus/
@@ -243,21 +243,21 @@ Perl is flexible and extensible enough for you to use on virtually any
 task, from one-line file-processing tasks to large, elaborate systems.
 For many people, Perl serves as a great replacement for shell scripting.
 For others, it serves as a convenient, high-level replacement for most of
-what they'd program in low-level languages like C or C++.  It's ultimately
+what they'd program in low-level languages like C or C++. It's ultimately
 up to you (and possibly your management) which tasks you'll use Perl
 for and which you won't.
 
 If you have a library that provides an API, you can make any component
 of it available as just another Perl function or variable using a Perl
 extension written in C or C++ and dynamically linked into your main
-perl interpreter.  You can also go the other direction, and write your
+perl interpreter. You can also go the other direction, and write your
 main program in C or C++, and then link in some Perl code on the fly,
-to create a powerful application.  See L<perlembed>.
+to create a powerful application. See L<perlembed>.
 
 That said, there will always be small, focused, special-purpose
 languages dedicated to a specific problem domain that are simply more
-convenient for certain kinds of problems.  Perl tries to be all things
-to all people, but nothing special to anyone.  Examples of specialized
+convenient for certain kinds of problems. Perl tries to be all things
+to all people, but nothing special to anyone. Examples of specialized
 languages that come to mind include prolog and matlab.
 
 =head2 When shouldn't I program in Perl?
@@ -272,19 +272,19 @@ certain task (e.g. prolog, make).
 For various reasons, Perl is probably not well-suited for real-time
 embedded systems, low-level operating systems development work like
 device drivers or context-switching code, complex multi-threaded
-shared-memory applications, or extremely large applications.  You'll
+shared-memory applications, or extremely large applications. You'll
 notice that perl is not itself written in Perl.
 
 Perl remains fundamentally a dynamically typed language, not
-a statically typed one.  You certainly won't be chastised if you don't
-trust nuclear-plant or brain-surgery monitoring code to it.  And Larry
+a statically typed one. You certainly won't be chastised if you don't
+trust nuclear-plant or brain-surgery monitoring code to it. And Larry
 will sleep easier, too--Wall Street programs not withstanding. :-)
 
 =head2 What's the difference between "perl" and "Perl"?
 
-One bit.  Oh, you weren't talking ASCII? :-) Larry now uses "Perl" to
+One bit. Oh, you weren't talking ASCII? :-) Larry now uses "Perl" to
 signify the language proper and "perl" the implementation of it, i.e.
-the current interpreter.  Hence Tom's quip that "Nothing but perl can
+the current interpreter. Hence Tom's quip that "Nothing but perl can
 parse Perl."
 
 Before the first edition of I<Programming perl>, people commonly
@@ -295,26 +295,26 @@ when typeset. This convention was adopted by the community, and the
 second edition became I<Programming Perl>, using the capitalized
 version of the name to refer to the language.
 
-You may or may not choose to follow this usage.  For example,
+You may or may not choose to follow this usage. For example,
 parallelism means "awk and perl" and "Python and Perl" look good, while
-"awk and Perl" and "Python and perl" do not.  But never write "PERL",
+"awk and Perl" and "Python and perl" do not. But never write "PERL",
 because perl is not an acronym, apocryphal folklore and post-facto
 expansions notwithstanding.
 
 =head2 Is it a Perl program or a Perl script?
 
-Larry doesn't really care.  He says (half in jest) that "a script is
-what you give the actors.  A program is what you give the audience."
+Larry doesn't really care. He says (half in jest) that "a script is
+what you give the actors. A program is what you give the audience."
 
 Originally, a script was a canned sequence of normally interactive
-commands--that is, a chat script.  Something like a UUCP or PPP chat
+commands--that is, a chat script. Something like a UUCP or PPP chat
 script or an expect script fits the bill nicely, as do configuration
 scripts run by a program at its start up, such F<.cshrc> or F<.ircrc>,
-for example.  Chat scripts were just drivers for existing programs,
+for example. Chat scripts were just drivers for existing programs,
 not stand-alone programs in their own right.
 
 A computer scientist will correctly explain that all programs are
-interpreted and that the only question is at what level.  But if you
+interpreted and that the only question is at what level. But if you
 ask this question of someone who isn't a computer scientist, they might
 tell you that a I<program> has been compiled to physical machine code
 once and can then be run multiple times, whereas a I<script> must be
@@ -323,7 +323,7 @@ translated by a program each time it's used.
 Now that "script" and "scripting" are terms that have been seized by
 unscrupulous or unknowing marketeers for their own nefarious purposes,
 they have begun to take on strange and often pejorative meanings,
-like "non serious" or "not real programming".  Consequently, some Perl
+like "non serious" or "not real programming". Consequently, some Perl
 programmers prefer to avoid them altogether.
 
 =head2 What is a JAPH?
@@ -404,7 +404,7 @@ This documentation is free; you can redistribute it and/or modify it
 under the same terms as Perl itself.
 
 Irrespective of its distribution, all code examples here are in the public
-domain.  You are permitted and encouraged to use this code and any
+domain. You are permitted and encouraged to use this code and any
 derivatives thereof in your own programs for fun or for profit as you
-see fit.  A simple comment in the code giving credit to the FAQ would
+see fit. A simple comment in the code giving credit to the FAQ would
 be courteous but is not required.
diff --git a/pod/perlfaq2.pod b/pod/perlfaq2.pod
index 03dc2d3..036df5e 100644
--- a/pod/perlfaq2.pod
+++ b/pod/perlfaq2.pod
@@ -44,7 +44,7 @@ Sunfreeware.com: Solaris 2.5 to Solaris 10 (SPARC and x86)
 Strawberry Perl: Windows, Perl 5.8.8 and 5.10.0
 
 	http://www.strawberryperl.com
-	
+
 IndigoPerl: Windows
 
 	http://indigostar.com/
diff --git a/pod/perlfaq3.pod b/pod/perlfaq3.pod
index e9fb3f3..e2fe116 100644
--- a/pod/perlfaq3.pod
+++ b/pod/perlfaq3.pod
@@ -528,21 +528,20 @@ the standard benchmark file for vi emulators.  The file runs best with nvi,
 the current version of vi out of Berkeley, which incidentally can be built
 with an embedded Perl interpreter--see http://www.cpan.org/src/misc/ .
 
-=head2 Where can I get perl-mode for emacs?
+=head2 Where can I get perl-mode or cperl-mode for emacs?
+X<emacs>
 
 Since Emacs version 19 patchlevel 22 or so, there have been both a
 perl-mode.el and support for the Perl debugger built in.  These should
 come with the standard Emacs 19 distribution.
 
-In the Perl source directory, you'll find a directory called "emacs",
-which contains a cperl-mode that color-codes keywords, provides
-context-sensitive help, and other nifty things.
-
 Note that the perl-mode of emacs will have fits with C<"main'foo">
 (single quote), and mess up the indentation and highlighting.  You
 are probably using C<"main::foo"> in new Perl code anyway, so this
 shouldn't be an issue.
 
+For CPerlMode, see http://www.emacswiki.org/cgi-bin/wiki/CPerlMode
+
 =head2 How can I use curses with Perl?
 
 The Curses module from CPAN provides a dynamically loadable object
diff --git a/pod/perlfaq4.pod b/pod/perlfaq4.pod
index f671b62..45cc9e0 100644
--- a/pod/perlfaq4.pod
+++ b/pod/perlfaq4.pod
@@ -11,6 +11,10 @@ numbers, dates, strings, arrays, hashes, and miscellaneous data issues.
 
 =head2 Why am I getting long decimals (eg, 19.9499999999999) instead of the numbers I should be getting (eg, 19.95)?
 
+For the long explanation, see David Goldberg's "What Every Computer
+Scientist Should Know About Floating-Point Arithmetic"
+(http://docs.sun.com/source/806-3568/ncg_goldberg.html).
+
 Internally, your computer represents floating-point numbers in binary.
 Digital (as in powers of two) computers cannot store all numbers
 exactly.  Some real numbers lose precision in the process.  This is a
@@ -297,8 +301,8 @@ but a string consisting of two null bytes (the result of C<"\020\020"
 
 =head2 How do I multiply matrices?
 
-Use the Math::Matrix or Math::MatrixReal modules (available from CPAN)
-or the PDL extension (also available from CPAN).
+Use the C<Math::Matrix> or C<Math::MatrixReal> modules (available from CPAN)
+or the C<PDL> extension (also available from CPAN).
 
 =head2 How do I perform an operation on a series of integers?
 
@@ -342,7 +346,7 @@ will not create a list of 500,000 integers.
 
 =head2 How can I output Roman numerals?
 
-Get the http://www.cpan.org/modules/by-module/Roman module.
+Get the L<http://www.cpan.org/modules/by-module/Roman> module.
 
 =head2 Why aren't my random numbers random?
 
@@ -358,7 +362,7 @@ rather than more.
 Computers are good at being predictable and bad at being random
 (despite appearances caused by bugs in your programs :-).  see the
 F<random> article in the "Far More Than You Ever Wanted To Know"
-collection in http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz , courtesy
+collection in L<http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz>, courtesy
 of Tom Phoenix, talks more about this.  John von Neumann said, "Anyone
 who attempts to generate random numbers by deterministic means is, of
 course, living in a state of sin."
@@ -368,7 +372,7 @@ provides, you should also check out the C<Math::TrulyRandom> module from
 CPAN.  It uses the imperfections in your system's timer to generate
 random numbers, but this takes quite a while.  If you want a better
 pseudorandom generator than comes with your operating system, look at
-"Numerical Recipes in C" at http://www.nr.com/ .
+"Numerical Recipes in C" at L<http://www.nr.com/>.
 
 =head2 How do I get a random number between X and Y?
 
@@ -401,8 +405,8 @@ integers (inclusive), For example: C<random_int_between(50,120)>.
 
 =head2 How do I find the day or week of the year?
 
-The localtime function returns the day of the year.  Without an
-argument localtime uses the current time.
+The C<localtime> function returns the day of the year.  Without an
+argument C<localtime> uses the current time.
 
 	$day_of_year = (localtime)[7];
 
@@ -414,7 +418,7 @@ week of the year.
 	my $week_of_year = strftime "%W", localtime;
 
 To get the day of year for any date, use C<POSIX>'s C<mktime> to get
-a time in epoch seconds for the argument to localtime.
+a time in epoch seconds for the argument to C<localtime>.
 
 	use POSIX qw/mktime strftime/;
 	my $week_of_year = strftime "%W",
@@ -541,7 +545,7 @@ Perl itself never had a Y2K problem, although that never stopped people
 from creating Y2K problems on their own. See the documentation for
 C<localtime> for its proper use.
 
-Starting with Perl 5.11, C<localtime> and C<gmtime> can handle dates past 
+Starting with Perl 5.11, C<localtime> and C<gmtime> can handle dates past
 03:14:08 January 19, 2038, when a 32-bit based time would overflow. You
 still might get a warning on a 32-bit C<perl>:
 
@@ -978,7 +982,7 @@ Left and right padding with any character, modifying C<$text> directly:
 
 (contributed by brian d foy)
 
-If you know where the columns that contain the data, you can
+If you know the columns that contain the data, you can
 use C<substr> to extract a single column.
 
 	my $column = substr( $line, $start_column, $length );
@@ -1213,7 +1217,7 @@ for list operations, so list operations also work on arrays:
 
 	my @three = grep { length == 3 } qw( dog cat bird );
 	my @three = grep { length == 3 } @animals;
-	
+
 	# supply an argument list
 	wash_animals( qw( dog cat bird ) );
 	wash_animals( @animals );
@@ -1236,15 +1240,15 @@ You can change an array element, but you can't change a list element:
 	foreach ( @animals ) {
 		s/^d/fr/;  # works fine
 		}
-	
+
 	foreach ( qw( dog cat bird ) ) {
 		s/^d/fr/;  # Error! Modification of read only value!
 		}
 
-However, if the list element is itself a variable, it appears that you 
+However, if the list element is itself a variable, it appears that you
 can change a list element. However, the list element is the variable, not
 the data. You're not changing the list element, but something the list
-element refers to. The list element itself doesn't change: it's still 
+element refers to. The list element itself doesn't change: it's still
 the same variable.
 
 You also have to be careful about context. You can assign an array to
@@ -1252,7 +1256,7 @@ a scalar to get the number of elements in the array. This only works
 for arrays, though:
 
 	my $count = @animals;  # only works with arrays
-	
+
 If you try to do the same thing with what you think is a list, you
 get a quite different result. Although it looks like you have a list
 on the righthand side, Perl actually sees a bunch of scalars separated
@@ -1292,8 +1296,8 @@ You can pull out multiple elements simultaneously by specifying
 additional indices as a list, like C<@array[1,4,3,0]>.
 
 Using a slice on the lefthand side of the assignment supplies list
-context to the righthand side. This can lead to unexpected results. 
-For instance, if you want to read a single line from a filehandle, 
+context to the righthand side. This can lead to unexpected results.
+For instance, if you want to read a single line from a filehandle,
 assigning to a scalar value is fine:
 
 	$array[1] = <STDIN>;
@@ -2133,9 +2137,9 @@ You can use the C<keys()> built-in function in scalar context to find out
 have many entries you have in a hash:
 
 	my $key_count = keys %hash; # must be scalar context!
-	
+
 If you want to find out how many entries have a defined value, that's
-a bit different. You have to check each value. A C<grep> is handy: 
+a bit different. You have to check each value. A C<grep> is handy:
 
 	my $defined_value_count = grep { defined } values %hash;
 
@@ -2144,7 +2148,7 @@ you like. If you want the count of the keys with vowels in them,
 you just test for that instead:
 
 	my $vowel_count = grep { /[aeiou]/ } keys %hash;
-	
+
 The C<grep> in scalar context returns the count. If you want the list
 of matching items, just use it in list context instead:
 
diff --git a/pod/perlfaq5.pod b/pod/perlfaq5.pod
index e2a9d98..bd969f4 100644
--- a/pod/perlfaq5.pod
+++ b/pod/perlfaq5.pod
@@ -310,9 +310,9 @@ fastest, even with the extra interprocess overhead. Ensure that you
 have an untainted filename though:
 
 	#!perl -T
-	
+
 	$ENV{PATH} = undef;
-	
+
 	my $lines;
 	if( $filename =~ /^([0-9a-z_.]+)\z/ ) {
 		$lines = `/usr/bin/wc -l $1`
@@ -324,37 +324,37 @@ X<lines> X<file>
 
 (contributed by brian d foy)
 
-The easiest conceptual solution is to count the lines in the 
+The easiest conceptual solution is to count the lines in the
 file then start at the beginning and print the number of lines
 (minus the last N) to a new file.
 
-Most often, the real question is how you can delete the last N
-lines without making more than one pass over the file, or how to 
-do it with a lot of copying. The easy concept is the hard reality when
+Most often, the real question is how you can delete the last N lines
+without making more than one pass over the file, or how to do it
+without a lot of copying. The easy concept is the hard reality when
 you might have millions of lines in your file.
 
-One trick is to use C<File::ReadBackwards>, which starts at the end of 
+One trick is to use C<File::ReadBackwards>, which starts at the end of
 the file. That module provides an object that wraps the real filehandle
-to make it easy for you to move around the file. Once you get to the 
+to make it easy for you to move around the file. Once you get to the
 spot you need, you can get the actual filehandle and work with it as
 normal. In this case, you get the file position at the end of the last
 line you want to keep and truncate the file to that point:
 
 	use File::ReadBackwards;
-	
+
 	my $filename = 'test.txt';
 	my $Lines_to_truncate = 2;
 
-	my $bw = File::ReadBackwards->new( $filename ) 
+	my $bw = File::ReadBackwards->new( $filename )
 		or die "Could not read backwards in [$filename]: $!";
-	
+
 	my $lines_from_end = 0;
-	until( $bw->eof or $lines_from_end == $Lines_to_truncate ) 
+	until( $bw->eof or $lines_from_end == $Lines_to_truncate )
 		{
 		print "Got: ", $bw->readline;
 		$lines_from_end++;
 		}
-	
+
 	truncate( $filename, $bw->tell );
 
 The C<File::ReadBackwards> module also has the advantage of setting
@@ -362,16 +362,16 @@ the input record separator to a regular expression.
 
 You can also use the C<Tie::File> module which lets you access
 the lines through a tied array. You can use normal array operations
-to modify your file, including setting the last index and using 
+to modify your file, including setting the last index and using
 C<splice>.
 
 =head2 How can I use Perl's C<-i> option from within a program?
 X<-i> X<in-place>
 
 C<-i> sets the value of Perl's C<$^I> variable, which in turn affects
-the behavior of C<< <> >>; see L<perlrun> for more details.  By
+the behavior of C<< <> >>; see L<perlrun> for more details. By
 modifying the appropriate variables directly, you can get the same
-behavior within a larger program.  For example:
+behavior within a larger program. For example:
 
 	# ...
 	{
@@ -413,7 +413,7 @@ remember to copy the permissions, owner, and group to the new file.
 X<file, temporary>
 
 If you don't need to know the name of the file, you can use C<open()>
-with C<undef> in place of the file name.  In Perl 5.8 or later, the
+with C<undef> in place of the file name. In Perl 5.8 or later, the
 C<open()> function creates an anonymous temporary file:
 
 	open my $tmp, '+>', undef or die $!;
@@ -422,24 +422,24 @@ Otherwise, you can use the File::Temp module.
 
 	use File::Temp qw/ tempfile tempdir /;
 
-	$dir = tempdir( CLEANUP => 1 );
+	my $dir = tempdir( CLEANUP => 1 );
 	($fh, $filename) = tempfile( DIR => $dir );
 
 	# or if you don't need to know the filename
 
-	$fh = tempfile( DIR => $dir );
+	my $fh = tempfile( DIR => $dir );
 
-The File::Temp has been a standard module since Perl 5.6.1.  If you
+The File::Temp has been a standard module since Perl 5.6.1. If you
 don't have a modern enough Perl installed, use the C<new_tmpfile>
 class method from the IO::File module to get a filehandle opened for
-reading and writing.  Use it if you don't need to know the file's name:
+reading and writing. Use it if you don't need to know the file's name:
 
 	use IO::File;
-	$fh = IO::File->new_tmpfile()
-	or die "Unable to make new temporary file: $!";
+	my $fh = IO::File->new_tmpfile()
+		or die "Unable to make new temporary file: $!";
 
 If you're committed to creating a temporary file by hand, use the
-process ID and/or the current time-value.  If you need to have many
+process ID and/or the current time-value. If you need to have many
 temporary files in one process, use a counter:
 
 	BEGIN {
@@ -453,11 +453,11 @@ temporary files in one process, use a counter:
 		until( defined(fileno(FH)) || $count++ > 100 ) {
 			$base_name =~ s/-(\d+)$/"-" . (1 + $1)/e;
 			# O_EXCL is required for security reasons.
-			sysopen FH, $base_name, O_WRONLY|O_EXCL|O_CREAT;
+			sysopen my($fh), $base_name, O_WRONLY|O_EXCL|O_CREAT;
 			}
 
-		if( defined fileno(FH) ) {
-			return (*FH, $base_name);
+		if( defined fileno($fh) ) {
+			return ($fh, $base_name);
 			}
 		else {
 			return ();
@@ -470,8 +470,8 @@ temporary files in one process, use a counter:
 X<fixed-length> X<file, fixed-length records>
 
 The most efficient way is using L<pack()|perlfunc/"pack"> and
-L<unpack()|perlfunc/"unpack">.  This is faster than using
-L<substr()|perlfunc/"substr"> when taking many, many strings.  It is
+L<unpack()|perlfunc/"unpack">. This is faster than using
+L<substr()|perlfunc/"substr"> when taking many, many strings. It is
 slower for just a few.
 
 Here is a sample chunk of code to break up and put back together again
@@ -543,7 +543,7 @@ check out the Symbol or IO::Handle modules.
 X<filehandle, indirect>
 
 An indirect filehandle is using something other than a symbol
-in a place that a filehandle is expected.  Here are ways
+in a place that a filehandle is expected. Here are ways
 to get indirect filehandles:
 
 	$fh =   SOME_FH;       # bareword is strict-subs hostile
@@ -557,18 +557,18 @@ create an anonymous filehandle, store that in a scalar variable,
 and use it as though it were a normal filehandle.
 
 	use IO::Handle;                     # 5.004 or higher
-	$fh = IO::Handle->new();
+	my $fh = IO::Handle->new();
 
-Then use any of those as you would a normal filehandle.  Anywhere that
+Then use any of those as you would a normal filehandle. Anywhere that
 Perl is expecting a filehandle, an indirect filehandle may be used
 instead. An indirect filehandle is just a scalar variable that contains
-a filehandle.  Functions like C<print>, C<open>, C<seek>, or
+a filehandle. Functions like C<print>, C<open>, C<seek>, or
 the C<< <FH> >> diamond operator will accept either a named filehandle
 or a scalar variable containing one:
 
 	($ifh, $ofh, $efh) = (*STDIN, *STDOUT, *STDERR);
 	print $ofh "Type it: ";
-	$got = <$ifh>
+	my $got = <$ifh>
 	print $efh "What was that: $got";
 
 If you're passing a filehandle to a function, you can write
@@ -594,15 +594,15 @@ is risky.)
 	accept_fh($handle);
 
 In the examples above, we assigned the filehandle to a scalar variable
-before using it.  That is because only simple scalar variables, not
+before using it. That is because only simple scalar variables, not
 expressions or subscripts of hashes or arrays, can be used with
-built-ins like C<print>, C<printf>, or the diamond operator.  Using
+built-ins like C<print>, C<printf>, or the diamond operator. Using
 something other than a simple scalar variable as a filehandle is
 illegal and won't even compile:
 
-	@fd = (*STDIN, *STDOUT, *STDERR);
+	my @fd = (*STDIN, *STDOUT, *STDERR);
 	print $fd[1] "Type it: ";                           # WRONG
-	$got = <$fd[0]>                                     # WRONG
+	my $got = <$fd[0]>                                  # WRONG
 	print $fd[2] "What was that: $got";                 # WRONG
 
 With C<print> and C<printf>, you get around this by using a block and
@@ -613,26 +613,26 @@ an expression where you would place the filehandle:
 	# Pity the poor deadbeef.
 
 That block is a proper block like any other, so you can put more
-complicated code there.  This sends the message out to one of two places:
+complicated code there. This sends the message out to one of two places:
 
-	$ok = -x "/bin/cat";
+	my $ok = -x "/bin/cat";
 	print { $ok ? $fd[1] : $fd[2] } "cat stat $ok\n";
 	print { $fd[ 1+ ($ok || 0) ]  } "cat stat $ok\n";
 
 This approach of treating C<print> and C<printf> like object methods
-calls doesn't work for the diamond operator.  That's because it's a
-real operator, not just a function with a comma-less argument.  Assuming
+calls doesn't work for the diamond operator. That's because it's a
+real operator, not just a function with a comma-less argument. Assuming
 you've been storing typeglobs in your structure as we did above, you
 can use the built-in function named C<readline> to read a record just
-as C<< <> >> does.  Given the initialization shown above for @fd, this
-would work, but only because readline() requires a typeglob.  It doesn't
+as C<< <> >> does. Given the initialization shown above for @fd, this
+would work, but only because readline() requires a typeglob. It doesn't
 work with objects or strings, which might be a bug we haven't fixed yet.
 
 	$got = readline($fd[0]);
 
 Let it be noted that the flakiness of indirect filehandles is not
 related to whether they're strings, typeglobs, objects, or anything else.
-It's the syntax of the fundamental operators.  Playing the object
+It's the syntax of the fundamental operators. Playing the object
 game doesn't help you at all here.
 
 =head2 How can I set up a footer format to be used with write()?
@@ -706,7 +706,7 @@ X<tilde> X<tilde expansion>
 
 Use the E<lt>E<gt> (C<glob()>) operator, documented in L<perlfunc>.
 Versions of Perl older than 5.6 require that you have a shell
-installed that groks tildes.  Later versions of Perl have this feature
+installed that groks tildes. Later versions of Perl have this feature
 built in. The C<File::KGlob> module (available from CPAN) gives more
 portable glob functionality.
 
@@ -730,73 +730,73 @@ X<clobber> X<read-write> X<clobbering> X<truncate> X<truncating>
 Because you're using something like this, which truncates the file and
 I<then> gives you read-write access:
 
-	open(FH, "+> /path/name");		# WRONG (almost always)
+	open my $fh, '+>', '/path/name'; # WRONG (almost always)
 
-Whoops.  You should instead use this, which will fail if the file
+Whoops. You should instead use this, which will fail if the file
 doesn't exist.
 
-	open(FH, "+< /path/name");  	# open for update
+	open my $fh, '+<', '/path/name'; # open for update
 
-Using ">" always clobbers or creates.  Using "<" never does
-either.  The "+" doesn't change this.
+Using ">" always clobbers or creates. Using "<" never does
+either. The "+" doesn't change this.
 
-Here are examples of many kinds of file opens.  Those using sysopen()
+Here are examples of many kinds of file opens. Those using sysopen()
 all assume
 
 	use Fcntl;
 
 To open file for reading:
 
-	open(FH, "< $path")                                 || die $!;
-	sysopen(FH, $path, O_RDONLY)                        || die $!;
+	open my $fh, '<', $path                                 or die $!;
+	sysopen my $fh, $path, O_RDONLY                         or die $!;
 
 To open file for writing, create new file if needed or else truncate old file:
 
-	open(FH, "> $path") || die $!;
-	sysopen(FH, $path, O_WRONLY|O_TRUNC|O_CREAT)        || die $!;
-	sysopen(FH, $path, O_WRONLY|O_TRUNC|O_CREAT, 0666)  || die $!;
+	open my $fh, '>', $path                                 or die $!;
+	sysopen my $fh, $path, O_WRONLY|O_TRUNC|O_CREAT         or die $!;
+	sysopen my $fh, $path, O_WRONLY|O_TRUNC|O_CREAT, 0666   or die $!;
 
 To open file for writing, create new file, file must not exist:
 
-	sysopen(FH, $path, O_WRONLY|O_EXCL|O_CREAT)         || die $!;
-	sysopen(FH, $path, O_WRONLY|O_EXCL|O_CREAT, 0666)   || die $!;
+	sysopen my $fh, $path, O_WRONLY|O_EXCL|O_CREAT          or die $!;
+	sysopen my $fh, $path, O_WRONLY|O_EXCL|O_CREAT, 0666    or die $!;
 
 To open file for appending, create if necessary:
 
-	open(FH, ">> $path") || die $!;
-	sysopen(FH, $path, O_WRONLY|O_APPEND|O_CREAT)       || die $!;
-	sysopen(FH, $path, O_WRONLY|O_APPEND|O_CREAT, 0666) || die $!;
+	open my $fh, '>>' $path                                 or die $!;
+	sysopen my $fh, $path, O_WRONLY|O_APPEND|O_CREAT        or die $!;
+	sysopen my $fh, $path, O_WRONLY|O_APPEND|O_CREAT, 0666  or die $!;
 
 To open file for appending, file must exist:
 
-	sysopen(FH, $path, O_WRONLY|O_APPEND)               || die $!;
+	sysopen my $fh, $path, O_WRONLY|O_APPEND                or die $!;
 
 To open file for update, file must exist:
 
-	open(FH, "+< $path")                                || die $!;
-	sysopen(FH, $path, O_RDWR)                          || die $!;
+	open my $fh, '+<', $path                                or die $!;
+	sysopen my $fh, $path, O_RDWR                           or die $!;
 
 To open file for update, create file if necessary:
 
-	sysopen(FH, $path, O_RDWR|O_CREAT)                  || die $!;
-	sysopen(FH, $path, O_RDWR|O_CREAT, 0666)            || die $!;
+	sysopen my $fh, $path, O_RDWR|O_CREAT                   or die $!;
+	sysopen my $fh, $path, O_RDWR|O_CREAT, 0666             or die $!;
 
 To open file for update, file must not exist:
 
-	sysopen(FH, $path, O_RDWR|O_EXCL|O_CREAT)           || die $!;
-	sysopen(FH, $path, O_RDWR|O_EXCL|O_CREAT, 0666)     || die $!;
+	sysopen my $fh, $path, O_RDWR|O_EXCL|O_CREAT            or die $!;
+	sysopen my $fh, $path, O_RDWR|O_EXCL|O_CREAT, 0666      or die $!;
 
 To open a file without blocking, creating if necessary:
 
-	sysopen(FH, "/foo/somefile", O_WRONLY|O_NDELAY|O_CREAT)
+	sysopen my $fh, '/foo/somefile', O_WRONLY|O_NDELAY|O_CREAT
 	    or die "can't open /foo/somefile: $!":
 
 Be warned that neither creation nor deletion of files is guaranteed to
-be an atomic operation over NFS.  That is, two processes might both
-successfully create or unlink the same file!  Therefore O_EXCL
+be an atomic operation over NFS. That is, two processes might both
+successfully create or unlink the same file! Therefore O_EXCL
 isn't as exclusive as you might wish.
 
-See also the new L<perlopentut> if you have it (new for 5.6).
+See also the new L<perlopentut>.
 
 =head2 Why do I sometimes get an "Argument list too long" when I use E<lt>*E<gt>?
 X<argument list too long>
@@ -805,7 +805,7 @@ The C<< <> >> operator performs a globbing operation (see above).
 In Perl versions earlier than v5.6.0, the internal glob() operator forks
 csh(1) to do the actual glob expansion, but
 csh can't handle more than 127 items and so gives the error message
-C<Argument list too long>.  People who installed tcsh as csh won't
+C<Argument list too long>. People who installed tcsh as csh won't
 have this problem, but their users may be surprised by it.
 
 To get around this, either upgrade to Perl v5.6.0 or later, do the glob
@@ -818,7 +818,7 @@ X<glob>
 (contributed by brian d foy)
 
 Starting with Perl 5.6.0, C<glob> is implemented internally rather
-than relying on an external resource. As such, memory issues with 
+than relying on an external resource. As such, memory issues with
 C<glob> aren't a problem in modern perls.
 
 =head2 How can I open a file with a leading ">" or trailing blanks?
@@ -835,8 +835,8 @@ Unless you have a particular reason to use the two argument form you
 should use the three argument form of open() which does not treat any
 characters in the filename as special.
 
-	open FILE, "<", "  file  ";  # filename is "   file   "
-	open FILE, ">", ">file";     # filename is ">file"
+	open my $fh, "<", "  file  ";  # filename is "   file   "
+	open my $fh, ">", ">file";     # filename is ">file"
 
 =head2 How can I reliably rename a file?
 X<rename> X<mv> X<move> X<file, rename>
@@ -848,7 +848,7 @@ functional equivalent, this works:
 
 It may be more portable to use the C<File::Copy> module instead.
 You just copy to the new file to the new name (checking return
-values), then delete the old one.  This isn't really the same
+values), then delete the old one. This isn't really the same
 semantically as a C<rename()>, which preserves meta-information like
 permissions, timestamps, inode info, etc.
 
@@ -877,18 +877,18 @@ filehandle be open for writing (or appending, or read/writing).
 
 Some versions of flock() can't lock files over a network (e.g. on NFS file
 systems), so you'd need to force the use of fcntl(2) when you build Perl.
-But even this is dubious at best.  See the flock entry of L<perlfunc>
+But even this is dubious at best. See the flock entry of L<perlfunc>
 and the F<INSTALL> file in the source distribution for information on
 building Perl to do this.
 
 Two potentially non-obvious but traditional flock semantics are that
 it waits indefinitely until the lock is granted, and that its locks are
-I<merely advisory>.  Such discretionary locks are more flexible, but
-offer fewer guarantees.  This means that files locked with flock() may
-be modified by programs that do not also use flock().  Cars that stop
+I<merely advisory>. Such discretionary locks are more flexible, but
+offer fewer guarantees. This means that files locked with flock() may
+be modified by programs that do not also use flock(). Cars that stop
 for red lights get on well with each other, but not with cars that don't
-stop for red lights.  See the perlport manpage, your port's specific
-documentation, or your system-specific local manpages for details.  It's
+stop for red lights. See the perlport manpage, your port's specific
+documentation, or your system-specific local manpages for details. It's
 best to assume traditional behavior if you're writing portable programs.
 (If you're not, you should as always feel perfectly free to write
 for your own system's idiosyncrasies (sometimes called "features").
@@ -905,14 +905,14 @@ X<lock, lockfile race condition>
 
 A common bit of code B<NOT TO USE> is this:
 
-	sleep(3) while -e "file.lock";	# PLEASE DO NOT USE
-	open(LCK, "> file.lock");		# THIS BROKEN CODE
+	sleep(3) while -e 'file.lock';	# PLEASE DO NOT USE
+	open my $lock, '>', 'file.lock'; # THIS BROKEN CODE
 
 This is a classic race condition: you take two steps to do something
-which must be done in one.  That's why computer hardware provides an
-atomic test-and-set instruction.   In theory, this "ought" to work:
+which must be done in one. That's why computer hardware provides an
+atomic test-and-set instruction. In theory, this "ought" to work:
 
-	sysopen(FH, "file.lock", O_WRONLY|O_EXCL|O_CREAT)
+	sysopen my $fh, "file.lock", O_WRONLY|O_EXCL|O_CREAT
 		or die "can't open  file.lock: $!";
 
 except that lamentably, file creation (and deletion) is not atomic
@@ -920,32 +920,32 @@ over NFS, so this won't work (at least, not every time) over the net.
 Various schemes involving link() have been suggested, but
 these tend to involve busy-wait, which is also less than desirable.
 
-=head2 I still don't get locking.  I just want to increment the number in the file.  How can I do this?
+=head2 I still don't get locking. I just want to increment the number in the file. How can I do this?
 X<counter> X<file, counter>
 
 Didn't anyone ever tell you web-page hit counters were useless?
 They don't count number of hits, they're a waste of time, and they serve
-only to stroke the writer's vanity.  It's better to pick a random number;
+only to stroke the writer's vanity. It's better to pick a random number;
 they're more realistic.
 
 Anyway, this is what you can do if you can't help yourself.
 
 	use Fcntl qw(:DEFAULT :flock);
-	sysopen(FH, "numfile", O_RDWR|O_CREAT) 	 or die "can't open numfile: $!";
-	flock(FH, LOCK_EX) 				 or die "can't flock numfile: $!";
-	$num = <FH> || 0;
-	seek(FH, 0, 0) 				 or die "can't rewind numfile: $!";
-	truncate(FH, 0) 				 or die "can't truncate numfile: $!";
-	(print FH $num+1, "\n")			 or die "can't write numfile: $!";
-	close FH 					 or die "can't close numfile: $!";
+	sysopen my $fh, "numfile", O_RDWR|O_CREAT or die "can't open numfile: $!";
+	flock $fh, LOCK_EX                        or die "can't flock numfile: $!";
+	my $num = <$fh> || 0;
+	seek $fh, 0, 0                            or die "can't rewind numfile: $!";
+	truncate $fh, 0                           or die "can't truncate numfile: $!";
+	(print $fh $num+1, "\n")                  or die "can't write numfile: $!";
+	close $fh                                 or die "can't close numfile: $!";
 
 Here's a much better web-page hit counter:
 
 	$hits = int( (time() - 850_000_000) / rand(1_000) );
 
-If the count doesn't impress your friends, then the code might.  :-)
+If the count doesn't impress your friends, then the code might. :-)
 
-=head2 All I want to do is append a small amount of text to the end of a file.  Do I still have to use locking?
+=head2 All I want to do is append a small amount of text to the end of a file. Do I still have to use locking?
 X<append> X<file, append>
 
 If you are on a system that correctly implements C<flock> and you use
@@ -989,13 +989,13 @@ like this:
 
 	$RECSIZE = 220; # size of record, in bytes
 	$recno   = 37;  # which record to update
-	open(FH, "+<somewhere") || die "can't update somewhere: $!";
-	seek(FH, $recno * $RECSIZE, 0);
-	read(FH, $record, $RECSIZE) == $RECSIZE || die "can't read record $recno: $!";
+	open my $fh, '+<', 'somewhere' or die "can't update somewhere: $!";
+	seek $fh, $recno * $RECSIZE, 0;
+	read $fh, $record, $RECSIZE == $RECSIZE or die "can't read record $recno: $!";
 	# munge the record
-	seek(FH, -$RECSIZE, 1);
-	print FH $record;
-	close FH;
+	seek $fh, -$RECSIZE, 1;
+	print $fh $record;
+	close $fh;
 
 Locking and error checking are left as an exercise for the reader.
 Don't forget them or you'll be quite sorry.
@@ -1008,14 +1008,14 @@ written, or had its meta-data (owner, etc) changed, you use the B<-A>,
 B<-M>, or B<-C> file test operations as documented in L<perlfunc>.
 These retrieve the age of the file (measured against the start-time of
 your program) in days as a floating point number. Some platforms may
-not have all of these times.  See L<perlport> for details. To retrieve
+not have all of these times. See L<perlport> for details. To retrieve
 the "raw" time in seconds since the epoch, you would call the stat
 function, then use C<localtime()>, C<gmtime()>, or
 C<POSIX::strftime()> to convert this into human-readable form.
 
 Here's an example:
 
-	$write_secs = (stat($file))[9];
+	my $write_secs = (stat($file))[9];
 	printf "file %s updated at %s\n", $file,
 	scalar localtime($write_secs);
 
@@ -1025,11 +1025,11 @@ If you prefer something more legible, use the File::stat module
 	# error checking left as an exercise for reader.
 	use File::stat;
 	use Time::localtime;
-	$date_string = ctime(stat($file)->mtime);
+	my $date_string = ctime(stat($file)->mtime);
 	print "file $file updated at $date_string\n";
 
 The POSIX::strftime() approach has the benefit of being,
-in theory, independent of the current locale.  See L<perllocale>
+in theory, independent of the current locale. See L<perllocale>
 for details.
 
 =head2 How do I set a file's timestamp in perl?
@@ -1043,8 +1043,8 @@ of them.
 	if (@ARGV < 2) {
 		die "usage: cptimes timestamp_file other_files ...\n";
 		}
-	$timestamp = shift;
-	($atime, $mtime) = (stat($timestamp))[8,9];
+	my $timestamp = shift;
+	my($atime, $mtime) = (stat($timestamp))[8,9];
 	utime $atime, $mtime, @ARGV;
 
 Error checking is, as usual, left as an exercise for the reader.
@@ -1053,9 +1053,9 @@ The perldoc for utime also has an example that has the same
 effect as touch(1) on files that I<already exist>.
 
 Certain file systems have a limited ability to store the times
-on a file at the expected level of precision.  For example, the
+on a file at the expected level of precision. For example, the
 FAT and HPFS filesystem are unable to create dates on files with
-a finer granularity than two seconds.  This is a limitation of
+a finer granularity than two seconds. This is a limitation of
 the filesystems, not of utime().
 
 =head2 How do I print to more than one file at once?
@@ -1067,37 +1067,50 @@ you can use the IO::Tee or Tie::FileHandle::Multiplex modules.
 If you only have to do this once, you can print individually
 to each filehandle.
 
-	for $fh (FH1, FH2, FH3) { print $fh "whatever\n" }
+	for my $fh (FH1, FH2, FH3) { print $fh "whatever\n" }
 
 =head2 How can I read in an entire file all at once?
 X<slurp> X<file, slurping>
 
-You can use the File::Slurp module to do it in one step.
+Are you sure you want to read the entire file and store it in memory?
+If you mmap the file, you can virtually load the entire file into a
+string without actually storing it in memory:
+
+	use File::Map qw(map_file);
+
+	map_file my $string, $filename;
+
+Once mapped, you can treat C<$string> as you would any other string.
+Since you don't actually load the data, mmap-ing is very fast and does
+not increase your memory footprint.
+
+If you really want to load the entire file, you can use the
+C<File::Slurp> module to do it in one step.
 
 	use File::Slurp;
 
-	$all_of_it = read_file($filename); # entire file in scalar
-	@all_lines = read_file($filename); # one line per element
+	my $all_of_it = read_file($filename); # entire file in scalar
+	my @all_lines = read_file($filename); # one line per element
 
 The customary Perl approach for processing all the lines in a file is to
 do so one line at a time:
 
-	open (INPUT, $file) 	|| die "can't open $file: $!";
-	while (<INPUT>) {
+	open my $input, '<', $file or die "can't open $file: $!";
+	while (<$input>) {
 		chomp;
 		# do something with $_
 		}
-	close(INPUT)	    	|| die "can't close $file: $!";
+	close $input or die "can't close $file: $!";
 
 This is tremendously more efficient than reading the entire file into
 memory as an array of lines and then processing it one element at a time,
-which is often--if not almost always--the wrong approach.  Whenever
+which is often--if not almost always--the wrong approach. Whenever
 you see someone do this:
 
-	@lines = <INPUT>;
+	my @lines = <INPUT>;
 
-you should think long and hard about why you need everything loaded at
-once.  It's just not a scalable solution.  You might also find it more
+You should think long and hard about why you need everything loaded at
+once. It's just not a scalable solution. You might also find it more
 fun to use the standard Tie::File module, or the DB_File module's
 $DB_RECNO bindings, which allow you to tie an array to a file so that
 accessing an element the array actually accesses the corresponding
@@ -1106,19 +1119,19 @@ line in the file.
 You can read the entire filehandle contents into a scalar.
 
 	{
-	local(*INPUT, $/);
-	open (INPUT, $file) 	|| die "can't open $file: $!";
-	$var = <INPUT>;
+	local $/;
+	open my $fh, '<', $file or die "can't open $file: $!";
+	$var = <$fh>;
 	}
 
 That temporarily undefs your record separator, and will automatically
-close the file at block exit.  If the file is already open, just use this:
+close the file at block exit. If the file is already open, just use this:
 
-	$var = do { local $/; <INPUT> };
+	$var = do { local $/; <$fh> };
 
 For ordinary files you can also use the read function.
 
-	read( INPUT, $var, -s INPUT );
+	read( $fh, $var, -s $fh );
 
 The third argument tests the byte size of the data on the INPUT filehandle
 and reads that many bytes into the buffer $var.
@@ -1126,19 +1139,19 @@ and reads that many bytes into the buffer $var.
 =head2 How can I read in a file by paragraphs?
 X<file, reading by paragraphs>
 
-Use the C<$/> variable (see L<perlvar> for details).  You can either
+Use the C<$/> variable (see L<perlvar> for details). You can either
 set it to C<""> to eliminate empty paragraphs (C<"abc\n\n\n\ndef">,
 for instance, gets treated as two paragraphs and not three), or
 C<"\n\n"> to accept empty paragraphs.
 
-Note that a blank line must have no blanks in it.  Thus
+Note that a blank line must have no blanks in it. Thus
 S<C<"fred\n \nstuff\n\n">> is one paragraph, but C<"fred\n\nstuff\n\n"> is two.
 
 =head2 How can I read a single character from a file?  From the keyboard?
 X<getc> X<file, reading one character at a time>
 
 You can use the builtin C<getc()> function for most filehandles, but
-it won't (easily) work on a terminal device.  For STDIN, either use
+it won't (easily) work on a terminal device. For STDIN, either use
 the Term::ReadKey module from CPAN or use the sample code in
 L<perlfunc/getc>.
 
@@ -1150,9 +1163,8 @@ turns off echo processing as well.
 	use strict;
 	$| = 1;
 	for (1..4) {
-		my $got;
 		print "gimme: ";
-		$got = getone();
+		my $got = getone();
 		print "--> $got\n";
 		}
     exit;
@@ -1162,7 +1174,7 @@ turns off echo processing as well.
 
 	my ($term, $oterm, $echo, $noecho, $fd_stdin);
 
-	$fd_stdin = fileno(STDIN);
+	my $fd_stdin = fileno(STDIN);
 
 	$term     = POSIX::Termios->new();
 	$term->getattr($fd_stdin);
@@ -1195,14 +1207,14 @@ turns off echo processing as well.
 
 	END { cooked() }
 
-The Term::ReadKey module from CPAN may be easier to use.  Recent versions
+The Term::ReadKey module from CPAN may be easier to use. Recent versions
 include also support for non-portable systems as well.
 
 	use Term::ReadKey;
-	open(TTY, "</dev/tty");
+	open my $tty, '<', '/dev/tty';
 	print "Gimme a char: ";
 	ReadMode "raw";
-	$key = ReadKey 0, *TTY;
+	my $key = ReadKey 0, $tty;
 	ReadMode "normal";
 	printf "\nYou said %s, char number %03d\n",
 		$key, ord $key;
@@ -1210,13 +1222,13 @@ include also support for non-portable systems as well.
 =head2 How can I tell whether there's a character waiting on a filehandle?
 
 The very first thing you should do is look into getting the Term::ReadKey
-extension from CPAN.  As we mentioned earlier, it now even has limited
+extension from CPAN. As we mentioned earlier, it now even has limited
 support for non-portable (read: not open systems, closed, proprietary,
 not POSIX, not Unix, etc.) systems.
 
 You should also check out the Frequently Asked Questions list in
 comp.unix.* for things like this: the answer is essentially the same.
-It's very system dependent.  Here's one solution that works on BSD
+It's very system dependent. Here's one solution that works on BSD
 systems:
 
 	sub key_ready {
@@ -1226,9 +1238,9 @@ systems:
 		}
 
 If you want to find out how many characters are waiting, there's
-also the FIONREAD ioctl call to be looked at.  The I<h2ph> tool that
+also the FIONREAD ioctl call to be looked at. The I<h2ph> tool that
 comes with Perl tries to convert C include files to Perl code, which
-can be C<require>d.  FIONREAD ends up defined as a function in the
+can be C<require>d. FIONREAD ends up defined as a function in the
 I<sys/ioctl.ph> file:
 
 	require 'sys/ioctl.ph';
@@ -1298,19 +1310,19 @@ There's also a C<File::Tail> module from CPAN.
 X<dup>
 
 If you check L<perlfunc/open>, you'll see that several of the ways
-to call open() should do the trick.  For example:
+to call open() should do the trick. For example:
 
-	open(LOG, ">>/foo/logfile");
-	open(STDERR, ">&LOG");
+	open my $log, '>>', '/foo/logfile';
+	open STDERR, '>&LOG';
 
 Or even with a literal numeric descriptor:
 
-   $fd = $ENV{MHCONTEXTFD};
-   open(MHCONTEXT, "<&=$fd");	# like fdopen(3S)
+	my $fd = $ENV{MHCONTEXTFD};
+	open $mhcontext, "<&=$fd";  # like fdopen(3S)
 
 Note that "<&STDIN" makes a copy, but "<&=STDIN" make
-an alias.  That means if you close an aliased handle, all
-aliases become inaccessible.  This is not true with
+an alias. That means if you close an aliased handle, all
+aliases become inaccessible. This is not true with
 a copied one.
 
 Error checking, as always, has been left as an exercise for the reader.
@@ -1328,11 +1340,11 @@ C<close()> function from the C<POSIX> module:
 
 This should rarely be necessary, as the Perl C<close()> function is to be
 used for things that Perl opened itself, even if it was a dup of a
-numeric descriptor as with C<MHCONTEXT> above.  But if you really have
+numeric descriptor as with C<MHCONTEXT> above. But if you really have
 to, you may be able to do this:
 
 	require 'sys/syscall.ph';
-	$rc = syscall(&SYS_close, $fd + 0);  # must force numeric
+	my $rc = syscall(&SYS_close, $fd + 0);  # must force numeric
 	die "can't sysclose $fd: $!" unless $rc == -1;
 
 Or, just use the fdopen(3S) feature of C<open()>:
@@ -1347,8 +1359,8 @@ X<filename, DOS issues>
 
 Whoops!  You just put a tab and a formfeed into that filename!
 Remember that within double quoted strings ("like\this"), the
-backslash is an escape character.  The full list of these is in
-L<perlop/Quote and Quote-like Operators>.  Unsurprisingly, you don't
+backslash is an escape character. The full list of these is in
+L<perlop/Quote and Quote-like Operators>. Unsurprisingly, you don't
 have a file called "c:(tab)emp(formfeed)oo" or
 "c:(tab)emp(formfeed)oo.exe" on your legacy DOS filesystem.
 
@@ -1356,16 +1368,16 @@ Either single-quote your strings, or (preferably) use forward slashes.
 Since all DOS and Windows versions since something like MS-DOS 2.0 or so
 have treated C</> and C<\> the same in a path, you might as well use the
 one that doesn't clash with Perl--or the POSIX shell, ANSI C and C++,
-awk, Tcl, Java, or Python, just to mention a few.  POSIX paths
+awk, Tcl, Java, or Python, just to mention a few. POSIX paths
 are more portable, too.
 
 =head2 Why doesn't glob("*.*") get all the files?
 X<glob>
 
 Because even on non-Unix ports, Perl's glob function follows standard
-Unix globbing semantics.  You'll need C<glob("*")> to get all (non-hidden)
-files.  This makes glob() portable even to legacy systems.  Your
-port may include proprietary globbing functions as well.  Check its
+Unix globbing semantics. You'll need C<glob("*")> to get all (non-hidden)
+files. This makes glob() portable even to legacy systems. Your
+port may include proprietary globbing functions as well. Check its
 documentation for details.
 
 =head2 Why does Perl let me delete read-only files?  Why does C<-i> clobber protected files?  Isn't this a bug in Perl?
@@ -1374,12 +1386,12 @@ This is elaborately and painstakingly described in the
 F<file-dir-perms> article in the "Far More Than You Ever Wanted To
 Know" collection in http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz .
 
-The executive summary: learn how your filesystem works.  The
+The executive summary: learn how your filesystem works. The
 permissions on a file say what can happen to the data in that file.
 The permissions on a directory say what can happen to the list of
-files in that directory.  If you delete a file, you're removing its
+files in that directory. If you delete a file, you're removing its
 name from the directory (so the operation depends on the permissions
-of the directory, not of the file).  If you try to write to the file,
+of the directory, not of the file). If you try to write to the file,
 the permissions of the file govern whether you're allowed to.
 
 =head2 How do I select a random line from a file?
@@ -1394,7 +1406,7 @@ Here's a reservoir-sampling algorithm from the Camel Book:
 	rand($.) < 1 && ($line = $_) while <>;
 
 This has a significant advantage in space over reading the whole file
-in.  You can find a proof of this method in I<The Art of Computer
+in. You can find a proof of this method in I<The Art of Computer
 Programming>, Volume 2, Section 3.4.2, by Donald E. Knuth.
 
 You can use the C<File::Random> module which provides a function
@@ -1404,7 +1416,7 @@ for that algorithm:
 	my $line = random_line($filename);
 
 Another way is to use the C<Tie::File> module, which treats the entire
-file as an array.  Simply access a random array element.
+file as an array. Simply access a random array element.
 
 =head2 Why do I get weird spaces when I print an array of lines?
 
@@ -1527,7 +1539,7 @@ This documentation is free; you can redistribute it and/or modify it
 under the same terms as Perl itself.
 
 Irrespective of its distribution, all code examples here are in the public
-domain.  You are permitted and encouraged to use this code and any
+domain. You are permitted and encouraged to use this code and any
 derivatives thereof in your own programs for fun or for profit as you
-see fit.  A simple comment in the code giving credit to the FAQ would
+see fit. A simple comment in the code giving credit to the FAQ would
 be courteous but is not required.
diff --git a/pod/perlfaq7.pod b/pod/perlfaq7.pod
index 1bfab25..3782351 100644
--- a/pod/perlfaq7.pod
+++ b/pod/perlfaq7.pod
@@ -375,12 +375,9 @@ The expected output is:
 
 =head2 How can I pass/return a {Function, FileHandle, Array, Hash, Method, Regex}?
 
-With the exception of regexes, you need to pass references to these
-objects.  See L<perlsub/"Pass by Reference"> for this particular
-question, and L<perlref> for information on references.
-
-See "Passing Regexes", later in L<perlfaq7>, for information on
-passing regular expressions.
+You need to pass references to these objects.  See L<perlsub/"Pass by
+Reference"> for this particular question, and L<perlref> for
+information on references.
 
 =over 4
 
@@ -420,12 +417,9 @@ and especially L<perlsub/"Pass by Reference"> for more information.
 
 =item Passing Regexes
 
-To pass regexes around, you'll need to be using a release of Perl
-sufficiently recent as to support the C<qr//> construct, pass around
-strings and use an exception-trapping eval, or else be very, very clever.
-
-Here's an example of how to pass in a string to be regex compared
-using C<qr//>:
+Here's an example of how to pass in a string and a regular expression
+for it to match against. You construct the pattern with the C<qr//>
+operator:
 
 	sub compare($$) {
 		my ($val1, $regex) = @_;
@@ -827,18 +821,6 @@ into strings like you can with variables:
 	my $current_package = __PACKAGE__;
 	print "I am in package $current_package\n";
 
-This is different from finding out the package an object is blessed
-into, which might not be the current package. For that, use C<blessed>
-from C<Scalar::Util>, part of the Standard Library since Perl 5.8:
-
-	use Scalar::Util qw(blessed);
-	my $object_package = blessed( $object );
-
-Most of the time, you shouldn't care what package an object is blessed
-into, however, as long as it claims to inherit from that class:
-
-	my $is_right_class = eval { $object->isa( $package ) }; # true or false
-
 If you want to find the package calling your code, perhaps to give better
 diagnostics as C<Carp> does, use the C<caller> built-in:
 
@@ -854,6 +836,26 @@ always be in some package unless someone uses the C<package> built-in
 with no namespace. See the C<package> entry in L<perlfunc> for the
 details of empty packages.
 
+This is different from finding out the package an object is blessed
+into, which might not be the current package. For that, use C<blessed>
+from C<Scalar::Util>, part of the Standard Library since Perl 5.8:
+
+	use Scalar::Util qw(blessed);
+	my $object_package = blessed( $object );
+
+Most of the time, you shouldn't care what package an object is blessed
+into, however, as long as it claims to inherit from that class:
+
+	my $is_right_class = eval { $object->isa( $package ) }; # true or false
+
+And, with Perl 5.10 and later, you don't have to check for an
+inheritance to see if the object can handle a role. For that, you can
+use C<DOES>, which comes from C<UNIVERSAL>:
+
+	my $class_does_it = eval { $object->DOES( $role ) }; # true or false
+
+You can safely replace C<isa> with C<DOES> (although the converse is not true).
+
 =head2 How can I comment out a large block of Perl code?
 
 (contributed by brian d foy)
@@ -874,10 +876,10 @@ comments). You end the comment with C<=cut>, ending the Pod section:
 
 	=cut
 
-The quick-and-dirty method only works well when you don't plan to 
+The quick-and-dirty method only works well when you don't plan to
 leave the commented code in the source. If a Pod parser comes along,
 you're multiline comment is going to show up in the Pod translation.
-A better way hides it from Pod parsers as well. 
+A better way hides it from Pod parsers as well.
 
 The C<=begin> directive can mark a section for a particular purpose.
 If the Pod parser doesn't want to handle it, it just ignores it. Label
diff --git a/pod/perlfaq8.pod b/pod/perlfaq8.pod
index 9917398..08a5b03 100644
--- a/pod/perlfaq8.pod
+++ b/pod/perlfaq8.pod
@@ -523,12 +523,12 @@ L<perlfunc/syscall>.
 
 =head2 How can I do an atexit() or setjmp()/longjmp()? (Exception handling)
 
-Release 5 of Perl added the END block, which can be used to simulate
-C<atexit()>.  Each package's END block is called when the program or
-thread ends (see L<perlmod> manpage for more details).
+You can use the C<END> block to simulate C<atexit()>. Each package's
+C<END> block is called when the program or thread ends See L<perlmod>
+manpage for more details about C<END> blocks.
 
-For example, you can use this to make sure your filter program
-managed to finish its output without filling up the disk:
+For example, you can use this to make sure your filter program managed
+to finish its output without filling up the disk:
 
 	END {
 		close(STDOUT) || die "stdout close failed: $!";
@@ -540,16 +540,16 @@ though, so if you use C<END> blocks you should also use
 	use sigtrap qw(die normal-signals);
 
 Perl's exception-handling mechanism is its C<eval()> operator.  You
-can use C<eval()> as C<setjmp> and C<die()> as C<longjmp>.  For
+can use C<eval()> as C<setjmp> and C<die()> as C<longjmp>. For
 details of this, see the section on signals, especially the time-out
 handler for a blocking C<flock()> in L<perlipc/"Signals"> or the
-section on "Signals" in the Camel Book.
+section on "Signals" in I<Programming Perl>.
 
-If exception handling is all you're interested in, try the
-C<exceptions.pl> library (part of the standard perl distribution).
+If exception handling is all you're interested in, use one of the 
+many CPAN modules that handle exceptions, such as C<Try::Tiny>.
 
-If you want the atexit() syntax (and an rmexit() as well), try the
-AtExit module available from CPAN.
+If you want the C<atexit()> syntax (and an C<rmexit()> as well), try the
+C<AtExit> module available from CPAN.
 
 =head2 Why doesn't my sockets program work under System V (Solaris)?  What does the error message "Protocol not supported" mean?
 
@@ -909,7 +909,7 @@ causes many inefficiencies.
 =head2 Can I use perl to run a telnet or ftp session?
 
 Try the C<Net::FTP>, C<TCP::Client>, and C<Net::Telnet> modules
-(available from CPAN). 
+(available from CPAN).
 http://www.cpan.org/scripts/netstuff/telnet.emul.shar will also help
 for emulating the telnet protocol, but C<Net::Telnet> is quite
 probably easier to use.
@@ -1014,8 +1014,8 @@ perform these actions for you.
 
 (contributed by brian d foy)
 
-This is a difficult question to answer, and the best answer is 
-only a guess. 
+This is a difficult question to answer, and the best answer is
+only a guess.
 
 What do you really want to know? If you merely want to know if one of
 your filehandles is connected to a terminal, you can try the C<-t>
@@ -1024,7 +1024,7 @@ file test:
 	if( -t STDOUT ) {
 		print "I'm connected to a terminal!\n";
 		}
-		
+
 However, you might be out of luck if you expect that means there is a
 real person on the other side. With the C<Expect> module, another
 program can pretend to be a person. The program might even come close
@@ -1037,7 +1037,7 @@ session is interactive. Otherwise, the filehandle is a null handle
 that simply discards the output:
 
 	use IO::Interactive;
-	
+
 	print { is_interactive } "I might go to standard output!\n";
 
 This still doesn't guarantee that a real person is answering your
@@ -1200,7 +1200,7 @@ to install:
 If you prefer C<CPANPLUS>, it's just as easy:
 
 	$ cpanp i IO::Interactive Getopt::Whatever
-	
+
 If you want to install a distribution from the current directory, you can
 tell C<CPAN.pm> to install C<.> (the full stop):
 
@@ -1217,7 +1217,7 @@ For distributions that use I<Makefile.PL>:
 
 	$ perl Makefile.PL
 	$ make test install
-	
+
 For distributions that use I<Build.PL>:
 
 	$ perl Build.PL
@@ -1263,7 +1263,15 @@ See the entry for C<use> in L<perlfunc> for more details.
 
 =head2 How do I keep my own module/library directory?
 
-When you build modules, tell Perl where to install the modules.
+When you build modules, tell Perl where to install the modules. 
+
+If you want to install modules for your own use, the easiest way might
+be C<local::lib>, which you can download from CPAN. It sets various
+installation settings for you, and uses those same settings within
+your programs.
+
+If you want more flexibility, you need to configure your CPAN client
+for your particular situation.
 
 For C<Makefile.PL>-based distributions, use the INSTALL_BASE option
 when generating Makefiles:
@@ -1341,6 +1349,14 @@ directory of the currently running script and puts it in C<$Bin>, which
 you can then use to construct the right library path:
 
 	use FindBin qw($Bin);
+	
+You can also use C<local::lib> to do much of the same thing. Install
+modules using C<local::lib>'s settings then use the module in your 
+program:
+
+	 use local::lib; # sets up a local lib at ~/perl5
+
+See the C<local::lib> documentation for more details.
 
 =head2 How do I add a directory to my include path (@INC) at runtime?
 
@@ -1349,24 +1365,30 @@ environment variables, run-time switches, and in-code statements:
 
 =over 4
 
-=item the PERLLIB environment variable
+=item the C<PERLLIB> environment variable
 
 	$ export PERLLIB=/path/to/my/dir
 	$ perl program.pl
 
-=item the PERL5LIB environment variable
+=item the C<PERL5LIB> environment variable
 
 	$ export PERL5LIB=/path/to/my/dir
 	$ perl program.pl
 
-=item the perl -Idir command line flag
+=item the C<perl -Idir> command line flag
 
 	$ perl -I/path/to/my/dir program.pl
 
-=item the use lib pragma:
+=item the C<lib> pragma:
 
 	use lib "$ENV{HOME}/myown_perllib";
 
+=item the C<local::lib> module:
+
+	use local::lib;
+	
+	use local::lib "~/myown_perllib";
+	
 =back
 
 The last is particularly useful because it knows about machine