Shlomi Fish avatar Shlomi Fish committed f3145d4

Got all pages to validate.

In the process fixed the broken links in the "modern-perl" book.

Comments (0)

Files changed (17)

src/learn/who-is-using/index.html.wml

 <br />
 -- <a href="http://blogs.perl.org/users/acme/2011/01/how-i-read.html">Léon Brocard</a>
 </p>
+</li>
+
 </ul>
 
 <h2 id="companies-and-projects">Companies and Projects</h2>

src/topics/cpan/life-with-cpan/index.html

-<?xml version="1.0" encoding='utf-8' ?> <html lang="en-US"><head
-        xmlns:xlink="http://www.w3.org/1999/xlink"> <meta
-        http-equiv="content-type" content="text/html;
-        charset=UTF-8"><title>Life with CPAN</title><link rel="stylesheet"
-        type="text/css" href="default.css"><meta
-        name="MSSmartTagsPreventParsing" content="TRUE"></head><body
-        xmlns:xlink="http://www.w3.org/1999/xlink"><div class="header"><div
+<?xml version="1.0" encoding='utf-8' ?>
+<!DOCTYPE
+    html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
+    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xml:lang="en-US"><head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
+        <title>Life with CPAN</title><link rel="stylesheet"
+        type="text/css" href="default.css" /><meta
+        name="MSSmartTagsPreventParsing" content="TRUE" /></head><body>
+        <div class="header"><div
                 class="navlinks"><a
                     href="http://web.archive.org/web/20080822232114/http://sial.org/howto/perl/">Parent
-                    Page</a></div><h1><a name="s">Life with
-                    CPAN</a></h1></div><div class="subsection"><a
+                    Page</a></div><h1 id="s">Life with
+                    CPAN</h1></div><div class="subsection"><a
                 href="#s2"><tt
                     class="cmd">perl</tt> Upgrade Bug</a> | <a
                 href="#s3">Active
      href="http://use.perl.org/article.pl?sid=06/11/08/1256207">submit
      module test results</a>. Try <a
      href="http://use.perl.org/%7EShlomi+Fish/journal/32367">SmokeAuto
-     for automated module testing</a>.</p><h3><a
-         name="s1.1">Alternatives</a></h3><p class="info">Other means of
+     for automated module testing</a>.</p><h3 id="s1.1">
+         Alternatives</h3><p class="info">Other means of
  installing <tt class="cmd">perl</tt> modules from <acronym
      title="Comprehensive Perl Archive Network">CPAN</acronym> include the
  following, which are not discussed in detail here.</p><ul class="list"><li><a
          title="Documentation on the CPAN Perl module"><tt
              class="perl-module">CPAN</tt></a> module. In  addition to fixing
      some long-standing problems, <tt class="code">CPAN++</tt> includes new
-     features, such as module uninstall.”<br>&nbsp;</li><li>PAR - <a
+     features, such as module uninstall.”<br />&nbsp;</li><li>PAR - <a
          href="http://par.perl.org/">Cross-Platform
-         Packaging and Deployment tool</a>.<br>&nbsp;</li><li><a
+         Packaging and Deployment tool</a>.<br />&nbsp;</li><li><a
          href="http://aspn.activestate.com/ASPN/Downloads/ActivePerl/PPM/">Perl
          Package Manager (PPM)</a> - Included with <a
          href="http://aspn.activestate.com/ASPN/Downloads/ActivePerl/">ActiveState
-         Perl</a>.<br>&nbsp;</li><li>Other. Some vendors make <tt
+         Perl</a>.<br />&nbsp;</li><li><p>Other. Some vendors make <tt
          class="cmd">perl</tt> modules available via other methods, such as
      ActiveState’s <a
          href="http://aspn.activestate.com/ASPN/Downloads/ActivePerl/PPM/"><acronym
          OS X, install XCode</a>, or use on of the various package systems
      available. These offer tight integration with the system in question, but
      may include outdated modules or use different naming conventions and
-     filesystem layouts.</li><p class="note">For example, <tt
+     filesystem layouts.</p><p class="note">For example, <tt
          class="code">p5-libwww</tt> is the FreeBSD port
 of the module distribution <tt class="code">libwww-perl</tt> on <acronym
     title="Comprehensive Perl Archive Network">CPAN</acronym>, and <a
     href="http://search.cpan.org/perldoc/CPAN"
     title="Documentation on the CPAN Perl module"><tt
         class="perl-module">CPAN</tt></a>.</p><p class="data-shell">#
-<kbd>portinstall p5-libwww</kbd><br># <kbd>yum -y install
-    perl-libwww-perl</kbd><br># <kbd>cpan -i LWP::UserAgent</kbd></p><p
+<kbd>portinstall p5-libwww</kbd><br /># <kbd>yum -y install
+    perl-libwww-perl</kbd><br /># <kbd>cpan -i LWP::UserAgent</kbd></p><p
 class="info">To lookup the documentation for a module, use <tt
     class="code">http://search.cpan.org/perldoc/<kbd
         class="input">Module::Name</kbd></tt>. The documentation should also
     href="http://search.cpan.org/perldoc/CPAN"
     title="Documentation on the CPAN Perl module"><tt
         class="perl-module">CPAN</tt></a> shell search
-features.</p><li>Conversion scripts. <a
+features.</p></li><li>Conversion scripts. <a
     href="http://perl.arix.com/cpan2rpm/"><tt
         class="cmd">cpan2rpm</tt></a> helps <a
     href="http://web.archive.org/howto/rpm/perl/">convert
     href="http://web.archive.org/howto/yum/">local
     Yellowdog Updater, Modified (YUM) server</a>. On Debian, try <tt
     class="cmd">dh-make-perl --install --cpan
-    Module::Name</tt>.</li></ul><h2><a name="s2"><tt class="cmd">perl</tt>
-    Upgrade Bug</a></h2><p class="info">The first time <a
+    Module::Name</tt>.</li></ul><h2 id="s2"><tt class="cmd">perl</tt>
+    Upgrade Bug</h2><p class="info">The first time <a
 href="http://search.cpan.org/perldoc/CPAN"
 title="Documentation on the CPAN Perl module"><tt
     class="perl-module">CPAN</tt></a> is invoked, it will run through a set of
  versions of <a
      href="http://search.cpan.org/perldoc/CPAN"
      title="Documentation on the CPAN Perl module"><tt
-         class="perl-module">CPAN</tt></a>.</p><h2><a name="s3">Active FTP
-         versus Firewalls</a></h2><p class="info">Network problems may prevent
+         class="perl-module">CPAN</tt></a>.</p><h2 id="s3">Active FTP
+         versus Firewalls</h2><p class="info">Network problems may prevent
  access to <acronym title="Comprehensive Perl Archive Network">CPAN</acronym>
  mirror sites. The chief problem will be utilities set to use active <acronym
      title="File Transfer Protocol">FTP</acronym>, which most firewalls block.
      class="cmd">cpan</tt>.</p><p class="data-shell"># <kbd>env FTP_PASSIVE=1
      cpan -i Net::FTP</kbd></p><p class="info">During the install of the <tt
      class="code">libnet</tt> distribution, enable passive <acronym title="File
-     Transfer Protocol">FTP</acronym>.</p><p class="data">…<br>Ah, I see you
- already have installed libnet before.<br><br>Do you want to modify/update your
- configuration (y|n) ? [no] <kbd class="input">y</kbd><br>…<br>Should all FTP
+     Transfer Protocol">FTP</acronym>.</p><p class="data">…<br />Ah, I see you
+ already have installed libnet before.<br /><br />Do you want to modify/update your
+ configuration (y|n) ? [no] <kbd class="input">y</kbd><br />…<br />Should all FTP
  connections be passive (y|n) ? [no] <kbd class="input">y</kbd></p><p
  class="info">If <a
      href="http://search.cpan.org/perldoc/Net::FTP"
  <tt class="file">libnet.cfg</tt> configuration file to use passive <acronym
      title="File Transfer Protocol">FTP</acronym>.</p><p class="data-shell">$
  <kbd>perl -le 'for (@INC) { $_ .= "/".$ARGV[0]; print if -f }'
-     Net/libnet.cfg</kbd><br>/usr/local/lib/perl5/5.8.1/Net/libnet.cfg<br>$
- <kbd>grep passive /usr/local/lib/perl5/5.8.1/Net/libnet.cfg</kbd><br>
+     Net/libnet.cfg</kbd><br />/usr/local/lib/perl5/5.8.1/Net/libnet.cfg<br />$
+ <kbd>grep passive /usr/local/lib/perl5/5.8.1/Net/libnet.cfg</kbd><br />
  'ftp_int_passive' =&gt; 1,</p><p class="info">If <a
      href="http://search.cpan.org/perldoc/Net::FTP"
      title="Documentation on the Net::FTP Perl module"><tt
          class="perl-module">Net::FTP</tt></a> does not work, or certain
  utilities take too long to time out, consider the following options.</p><ul
-     class="list"><li>Disable <a
+     class="list"><li><p>Disable <a
          href="http://search.cpan.org/perldoc/Net::FTP"
          title="Documentation on the Net::FTP Perl module"><tt
-             class="perl-module">Net::FTP</tt></a>.</li><p class="info">If <a
+             class="perl-module">Net::FTP</tt></a>.</p><p class="info">If <a
          href="http://search.cpan.org/perldoc/Net::FTP"
          title="Documentation on the Net::FTP Perl module"><tt
              class="perl-module">Net::FTP</tt></a> does not work, try adding
          href="http://search.cpan.org/perldoc/Net::FTP"
          title="Documentation on the Net::FTP Perl module"><tt
              class="perl-module">Net::FTP</tt></a>.</p><p
-     class="data">'dontload_hash' =&gt; { 'Net::FTP' =&gt; 1 },</p><li>Disable
-     utilities that do not work</li><p class="info">To reconfigure <a
+     class="data">'dontload_hash' =&gt; { 'Net::FTP' =&gt; 1 },</p></li><li><p>Disable
+     utilities that do not work</p><p class="info">To reconfigure <a
          href="http://search.cpan.org/perldoc/CPAN"
          title="Documentation on the CPAN Perl module"><tt
              class="perl-module">CPAN</tt></a> to not call certain utilities,
      replace the path to the utility with a single space.</p><p
-     class="data-shell">$ <kbd>grep ncftp ~/.cpan/CPAN/MyConfig.pm</kbd><br>
-     'ncftp' =&gt; q[ ],<br>  'ncftpget' =&gt; q[ ],</p></ul><h2><a
-         name="s4">Preferences Questions</a></h2><p class="info"><a
+     class="data-shell">$ <kbd>grep ncftp ~/.cpan/CPAN/MyConfig.pm</kbd><br />
+     'ncftp' =&gt; q[ ],<br />  'ncftpget' =&gt; q[ ],</p></li></ul><h2 id="s4">
+         Preferences Questions</h2><p class="info"><a
      href="http://search.cpan.org/perldoc/CPAN"
      title="Documentation on the CPAN Perl module"><tt
          class="perl-module">CPAN</tt></a> will ask for preferences settings
  any time the <tt class="file">Config.pm</tt> preferences file does not exist
  or is out of date. The default choice should be acceptable for most.</p><ul
-     class="list"><li>CPAN build and cache directory? [<tt
-         class="file">/root/.cpan</tt>]</li><p class="info">I use <tt
+     class="list"><li><p>CPAN build and cache directory? [<tt
+         class="file">/root/.cpan</tt>]</p><p class="info">I use <tt
          class="file">/var/spool/cpan</tt>, as the root filesystem tends to be
      small on my systems, and the spool area makes more sense to
-     me.</p><li>Policy on building prerequisites (follow, ask or ignore)?
-     [ask]</li><p class="info">Leave this setting set to <kbd
+     me.</p></li><li><p>Policy on building prerequisites (follow, ask or ignore)?
+     [ask]</p><p class="info">Leave this setting set to <kbd
          class="input">ask</kbd> when upgrading <a
          href="http://search.cpan.org/perldoc/CPAN"
          title="Documentation on the CPAN Perl module"><tt
      of <a
          href="http://search.cpan.org/perldoc/CPAN"
          title="Documentation on the CPAN Perl module"><tt
-             class="perl-module">CPAN</tt></a> is installed.</p><li>Where is
+             class="perl-module">CPAN</tt></a> is installed.</p></li><li><p>Where is
      your <tt class="file-glob">*</tt> program? [<tt
-         class="file-glob">*</tt>]</li><p class="info">This series of questions
+         class="file-glob">*</tt>]</p><p class="info">This series of questions
      lets one configure (or disable) paths to various utilities <a
          href="http://search.cpan.org/perldoc/CPAN"
          title="Documentation on the CPAN Perl module"><tt
              class="perl-module">CPAN</tt></a> is left with at least one
      working program that can download modules and another to expand
      them.</p><p class="info">To disable a particular utility, use a single
-     space instead of a file path.</p><li>Parameters for the '<tt
-         class="cmd">make install</tt>' command?</li><p class="info">Set this
+     space instead of a file path.</p></li><li><p>Parameters for the '<tt
+         class="cmd">make install</tt>' command?</p><p class="info">Set this
      option to include <tt class="code">UNINST=1</tt> if installing as root.
      This properly cleans out files from older versions of a module being
      installed.  For user-specific setup, I never set the <tt
          class="code">UNINST</tt> option, to avoid remove warnings of
-     unremovable system files.</p><li>Now we need to know where your favorite
-     CPAN sites are located.</li><p class="info">Choose several <acronym
+     unremovable system files.</p></li><li><p>Now we need to know where your favorite
+     CPAN sites are located.</p><p class="info">Choose several <acronym
          title="Comprehensive Perl Archive Network">CPAN</acronym> mirror
      sites.  Use <tt class="cmd">traceroute</tt> or bandwidth testing tools to
      determine which mirrors are best for your system. Or, <a
     href="http://search.cpan.org/perldoc/CPAN"
     title="Documentation on the CPAN Perl module"><tt
         class="perl-module">CPAN</tt></a> fails though the mirror
-list.</p></ul><h2><a name="s5">Reconfiguring CPAN</a></h2><p class="info">To
+list.</p></li></ul><h2 id="s5">Reconfiguring CPAN</h2><p class="info">To
 alter the <a
     href="http://search.cpan.org/perldoc/CPAN"
     title="Documentation on the CPAN Perl module"><tt
 configuration option runs through all the configuration questions, which may be
 time consuming.  For example, other <tt class="cmd">o conf</tt> commands can be
 used to list, remove, and add mirror sites, and then to save the changes to
-disk.</p><p class="data-shell">cpan&gt; <kbd>o conf urllist</kbd><br>
-urllist<br>ftp://ftp.kernel.org/pub/CPAN/<br>Type 'o conf' to view
-configuration edit options<br><br><br>cpan&gt; <kbd>o conf urllist
-    shift</kbd><br><br>cpan&gt; <kbd>o conf urllist push
-    ftp://ftp-mirror.internap.com/pub/CPAN/</kbd><br><br>cpan&gt; <kbd>o conf
-    urllist</kbd><br>    urllist<br>
+disk.</p><p class="data-shell">cpan&gt; <kbd>o conf urllist</kbd><br />
+urllist<br />ftp://ftp.kernel.org/pub/CPAN/<br />Type 'o conf' to view
+configuration edit options<br /><br /><br />cpan&gt; <kbd>o conf urllist
+    shift</kbd><br /><br />cpan&gt; <kbd>o conf urllist push
+    ftp://ftp-mirror.internap.com/pub/CPAN/</kbd><br /><br />cpan&gt; <kbd>o conf
+    urllist</kbd><br />    urllist<br />
 
    <!-- base
    href="http://sial.org.wstub.archive.org/howto/perl/life-with-cpan/" -->
 
 ftp://ftp-mirror.internap.com/pub/CPAN/
-        <br>Type 'o conf' to view configuration edit
-        options<br><br><br>cpan&gt; <kbd>o conf commit</kbd><br>commit: wrote
-        /usr/local/lib/perl5/5.6.1/CPAN/Config.pm<br></p><p class="info">To
+        <br />Type 'o conf' to view configuration edit
+        options<br /><br /><br />cpan&gt; <kbd>o conf commit</kbd><br />commit: wrote
+        /usr/local/lib/perl5/5.6.1/CPAN/Config.pm<br /></p><p class="info">To
         manually edit the existing configuration file, either open the
         user-specific <tt class="file">~/.cpan/CPAN/MyConfig.pm</tt> directly,
         or locate the system-wide configuration file (stored somewhere under
         the <tt class="cmd">perl</tt> <tt class="code">@INC</tt> path list) to
         edit with the following command.</p><p class="data-shell">$ <kbd>perl
             -le 'for (@INC) { $_ .= $ARGV[0]; print if -f }'
-            /CPAN/Config.pm</kbd><br>/System/Library/Perl/CPAN/Config.pm</p><h2><a
-                name="s6">Usage Tips</a></h2><div class="subsection"><a
+            /CPAN/Config.pm</kbd><br />/System/Library/Perl/CPAN/Config.pm</p>
+            <h2 id="s6">Usage Tips</h2><div class="subsection"><a
                 href="#s6.1">Invocation</a>
             | <a
                 href="#s6.2"><tt
             title="Documentation on the CPAN Perl module"><tt
                 class="perl-module">CPAN</tt></a> shell, run <tt
             class="cmd">reload cpan</tt> first.</p><p
-        class="data-shell">cpan&gt; <kbd>reload cpan</kbd><br>…<br>cpan&gt;
+        class="data-shell">cpan&gt; <kbd>reload cpan</kbd><br />…<br />cpan&gt;
         <kbd>install Bundle::CPAN</kbd></p><p class="info">The following
         sections outline various uses and caveats with <a
             href="http://search.cpan.org/perldoc/CPAN"
             title="Documentation on the CPAN Perl module"><tt
-                class="perl-module">CPAN</tt></a>.</p><h3><a
-                name="s6.1">Invocation</a></h3><p class="info">The latest
+                class="perl-module">CPAN</tt></a>.</p>
+                <h3 id="s6.1">Invocation</h3><p class="info">The latest
         version of <a
             href="http://search.cpan.org/perldoc/CPAN"
             title="Documentation on the CPAN Perl module"><tt
         commands are equivalent.  Hereafter, the shorter <tt
             class="cmd">cpan</tt> method will be used.</p><p
         class="data-shell"><span class="comment"># enter the CPAN
-            shell</span><br># <kbd>perl -MCPAN -e shell</kbd><br>#
-        <kbd>cpan</kbd><br><br><span class="comment"># install the Acme::Bleach
-            module</span><br># <kbd>perl -MCPAN -e install
-            Acme::Bleach</kbd><br># <kbd>cpan -i Acme::Bleach</kbd></p><p
+            shell</span><br /># <kbd>perl -MCPAN -e shell</kbd><br />#
+        <kbd>cpan</kbd><br /><br /><span class="comment"># install the Acme::Bleach
+            module</span><br /># <kbd>perl -MCPAN -e install
+            Acme::Bleach</kbd><br /># <kbd>cpan -i Acme::Bleach</kbd></p><p
         class="note">Depending on the shell in question, one may need to issue
         the <tt class="cmd">hash -r</tt> or <tt class="cmd">rehash</tt> command
         to make the new <tt class="cmd">cpan</tt> command appear in the search
             title="Documentation on the CPAN Perl module"><tt
                 class="perl-module">CPAN</tt></a> is installed.  Consult your
         shell’s documentation for more information on whether this is
-        required.</p><h3><a name="s6.2"><tt
-                    class="code">autobundle</tt></a></h3><p class="info">The <a
+        required.</p><h3 id="s6.2"><tt
+                    class="code">autobundle</tt></h3><p class="info">The <a
             href="http://search.cpan.org/perldoc/CPAN"
             title="Documentation on the CPAN Perl module"><tt
                 class="perl-module">CPAN</tt></a> <tt
         containing all the installed modules of the current version of <tt
             class="cmd">perl</tt>.  This bundle can then be installed once the
         new version of <tt class="cmd">perl</tt> is installed.</p><p
-        class="data-shell">cpan&gt; <kbd>autobundle</kbd><br>…<br><br>Wrote
-        bundle file<br>
-        /var/spool/cpan/Bundle/Snapshot_2003_10_01_00.pm<br><br><br>cpan&gt;
-        <kbd>quit</kbd><br><br><span class="comment"># upgrade perl here
-            …</span><br><br># <kbd>cpan</kbd><br>cpan&gt; <kbd>install
+        class="data-shell">cpan&gt; <kbd>autobundle</kbd><br />…<br /><br />Wrote
+        bundle file<br />
+        /var/spool/cpan/Bundle/Snapshot_2003_10_01_00.pm<br /><br /><br />cpan&gt;
+        <kbd>quit</kbd><br /><br /><span class="comment"># upgrade perl here
+            …</span><br /><br /># <kbd>cpan</kbd><br />cpan&gt; <kbd>install
             Bundle::Snapshot_2003_10_01_00</kbd></p><p class="info">Autobundle
         appears to install the modules in alphabetical order; setting the <tt
             class="code">prerequisites_policy</tt> policy to <tt
         to much recursion on the part of <a
             href="http://search.cpan.org/perldoc/CPAN"
             title="Documentation on the CPAN Perl module"><tt
-                class="perl-module">CPAN</tt></a>.</p><h3><a name="s6.3">Old
-                Modules</a></h3><p class="info">Some modules found by <a
+                class="perl-module">CPAN</tt></a>.</p><h3 id="s6.3">Old
+                Modules</h3><p class="info">Some modules found by <a
             href="http://search.cpan.org/perldoc/CPAN"
             title="Documentation on the CPAN Perl module"><tt
                 class="perl-module">CPAN</tt></a> are out of date, and will not
                 href="http://search.cpan.org/perldoc/Mail::Cclient"
                 title="Documentation on the Mail::Cclient Perl module"><tt
                     class="perl-module">Mail::Cclient</tt></a>
-            <br>&nbsp;</li><li> <a
+            <br />&nbsp;</li><li> <a
                 href="http://search.cpan.org/perldoc/OpenGL"
                 title="Documentation on the OpenGL Perl module"><tt
-                    class="perl-module">OpenGL</tt></a> </li></ul><h3><a
-                name="s6.4">Mac OS X</a></h3><p class="info"><a
+                    class="perl-module">OpenGL</tt></a> </li></ul>
+                    <h3 id="s6.4">Mac OS X</h3><p class="info"><a
             href="macosx/">Problems
             with <acronym title="Comprehensive Perl Archive
-                Network">CPAN</acronym> on Mac OS X</a>.</p><h3><a
-              name="s6.5">Manual Build</a></h3><p class="info">On occasion one
+                Network">CPAN</acronym> on Mac OS X</a>.</p>
+                <h3 id="s6.5">Manual Build</h3><p class="info">On occasion one
       may need to manually build or test a module, or consult the module
       directory to read the documentation on any special needs the module may
       have.  This can be done with the <a
     title="Documentation on the CPAN Perl module"><tt
         class="perl-module">CPAN</tt></a> shell <tt class="cmd">look</tt>
 command.</p><p class="data-shell">cpan&gt; <kbd>look
-    Net::SSLeay</kbd><br>…<br>Working directory is
-/var/spool/cpan/build/Net_SSLeay.pm-1.25<br># <kbd>exit</kbd><br>cpan&gt;
-<kbd>&nbsp;</kbd></p><h3><a name="s6.6"><tt class="cmd">sudo</tt></a></h3><p
+    Net::SSLeay</kbd><br />…<br />Working directory is
+/var/spool/cpan/build/Net_SSLeay.pm-1.25<br /># <kbd>exit</kbd><br />cpan&gt;
+<kbd>&nbsp;</kbd></p><h3 id="s6.6"><tt class="cmd">sudo</tt></h3><p
 class="info">If <a
     href="http://search.cpan.org/perldoc/CPAN"
     title="Documentation on the CPAN Perl module"><tt
     href="http://search.cpan.org/perldoc/CPAN"
     title="Documentation on the CPAN Perl module"><tt
         class="perl-module">CPAN</tt></a>.</p><p class="data-shell">$ <kbd>sudo
-    -H cpan</kbd></p><h3><a name="s6.7">Uninstalling</a></h3><p class="info"><a
+    -H cpan</kbd></p><h3 id="s6.7">Uninstalling</h3><p class="info"><a
     href="http://search.cpan.org/perldoc/CPAN"
     title="Documentation on the CPAN Perl module"><tt
         class="perl-module">CPAN</tt></a> itself offers no uninstall method.
     class="file">.packlist</tt> file for use by <a
     href="http://search.cpan.org/perldoc/ExtUtils::Packlist"
     title="Documentation on the ExtUtils::Packlist Perl module"><tt
-        class="perl-module">ExtUtils::Packlist</tt></a>.</p><h3><a
-        name="s6.8">Upgrading</a></h3><p class="info">How to upgrade all the
+        class="perl-module">ExtUtils::Packlist</tt></a>.</p><h3 id="s6.9">
+    Upgrading</h3><p class="info">How to upgrade all the
 modules on the system like <tt class="cmd">apt-get</tt> is actually documented
 in the <a
     href="http://search.cpan.org/perldoc/CPAN"
         class="perl-module">CPAN</tt></a> manual; however, the question comes
 up often enough that I answer it here as well.</p><p class="data-shell"><span
     class="comment"># install everything that is outdated on my
-    disk:</span><br># <kbd>perl -MCPAN -e
+    disk:</span><br /># <kbd>perl -MCPAN -e
     'CPAN::Shell-&gt;install(CPAN::Shell-&gt;r)'</kbd></p><p
 class="info">Problems with this include new versions of modules that may break
 old module behavior, or various modules that cannot be upgraded due to build
 failures or system incompatibilities. Best to subject a test system to this
 sort of mass module
- upgrade before attempting it on a production system.</p><h2><a
-         name="s7">Debugging Module Build Problems</a></h2><p class="info">See
+ upgrade before attempting it on a production system.</p><h2 id="s7">
+         Debugging Module Build Problems</h2><p class="info">See
  the <a
      href="debug/">Debugging
-     CPAN Build Problems</a> guide for more information.</p><h2><a
-         name="s8">Using CPAN with a non-root account</a></h2><p
+     CPAN Build Problems</a> guide for more information.</p><h2 id="s8">
+         Using CPAN with a non-root account</h2><p
  class="info"><a
      href="non-root/">Notes
      on using CPAN with a non-root account</a>, or installing Perl modules to
      href="http://search.cpan.org/perldoc/local::lib"
      title="Documentation on the local::lib Perl module"><tt
          class="perl-module">local::lib</tt></a> to bootsrap custom Perl module
- installation directories.</p><div class="footer"><a
-         href="http://web.archive.org/"><img
-         style="float: right; margin-top: 1em; margin-right: 1em;
-         margin-bottom: 5em;" src="Life%20with%20CPAN_files/sial.html"
-         width="64" height="64"></a><p><a
+ installation directories.</p><div class="footer">
+    <p><a
          href="http://web.archive.org/contact/">Questions
          or comments about this page?</a> Current ruminations available on <a
          href="http://web.archive.org/blog/">my

src/topics/cpan/life-with-cpan/non-root/index.html

 <?xml version="1.0" encoding="utf-8" ?> 
-<html lang="en-US"> 
-<head xmlns:xlink="http://www.w3.org/1999/xlink">
+<!DOCTYPE
+    html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
+    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xml:lang="en-US"> 
+<head>
 <meta http-equiv="content-type"
-content="text/html; charset=UTF-8"><title>Using CPAN with a non-root
-account</title><link rel="stylesheet" type="text/css" href="default.css"><meta
-name="MSSmartTagsPreventParsing" content="TRUE"></head><body
-xmlns:xlink="http://www.w3.org/1999/xlink"><div class="header"><div
+content="text/html; charset=UTF-8" /><title>Using CPAN with a non-root
+account</title><link rel="stylesheet" type="text/css" href="default.css" /><meta
+name="MSSmartTagsPreventParsing" content="TRUE" /></head><body>
+<div class="header"><div
 class="navlinks"><a
 href="/../">Parent
-Page</a></div><h1><a name="s">Using CPAN with a non-root
-account</a></h1></div><div class="subsection"><a
+Page</a></div><h1 id="s">Using CPAN with a non-root
+account</h1></div><div class="subsection"><a
 href="#s2">Configuration</a>
 | <a
 href="#s3">Customize
  href="http://search.cpan.org/perldoc/local::lib"
  title="Documentation on the local::lib Perl module"><tt
  class="perl-module">local::lib</tt></a> to bootsrap custom Perl module
- installation directories.</p><h2><a name="s2">Configuration</a></h2><ol
- class="enum"><li>Download the sample <a
+ installation directories.</p><h2 id="s2">Configuration</h2><ol
+ class="enum"><li><p>Download the sample <a
  href="/../MyConfig.pm"><tt
  class="file">MyConfig.pm</tt></a>, and move it to <tt
- class="file">~/.cpan/CPAN/MyConfig.pm</tt>.</li><p class="data-shell">$
- <kbd>mkdir -p ~/.cpan/CPAN</kbd><br>$ <kbd>mv MyConfig.pm
- ~/.cpan/CPAN</kbd></p><li>Customize the <a
+ class="file">~/.cpan/CPAN/MyConfig.pm</tt>.</p><p class="data-shell">$
+ <kbd>mkdir -p ~/.cpan/CPAN</kbd><br />$ <kbd>mv MyConfig.pm
+     ~/.cpan/CPAN</kbd></p></li><li><p>Customize the <a
  href="/../MyConfig.pm"><tt
- class="file">MyConfig.pm</tt></a> file.<br>&nbsp;</li><ol
- class="enum"><li>Change all occurences of <tt class="code">HOMEDIRFIX</tt> to
+ class="file">MyConfig.pm</tt></a> file.<br />&nbsp;</p><ol class="enum">
+ <li>Change all occurences of <tt class="code">HOMEDIRFIX</tt> to
  your home directory, for example <tt
- class="file">/home/username</tt>.<br>&nbsp;</li><li>Review the <tt
+ class="file">/home/username</tt>.<br />&nbsp;</li><li>Review the <tt
  class="code">makepl_arg</tt> arguments. For more information on the arguments,
  see <a
  href="http://search.cpan.org/perldoc/ExtUtils::MakeMaker"
  title="Documentation on the ExtUtils::MakeMaker Perl module"><tt
- class="perl-module">ExtUtils::MakeMaker</tt></a>.<br>&nbsp;</li><li>Check the
+ class="perl-module">ExtUtils::MakeMaker</tt></a>.<br />&nbsp;</li><li><p>Check the
  paths to various commands (e.g. <tt class="cmd">wget</tt>), proxy settings for
- your environment, the <tt class="code">urllist</tt>, and the shell.</li><p
+ your environment, the <tt class="code">urllist</tt>, and the shell.</p><p
  class="note">Be sure to remove the <tt class="code">UNINST=1</tt> option on
  <tt class="code">make_install_arg</tt> for any non-system-wide configuration
  as otherwise <a
  title="Documentation on the CPAN Perl module"><tt
  class="perl-module">CPAN</tt></a> will attempt to remove “shadowing” versions
  of the module installed for the site <tt class="cmd">perl</tt>, leading to
- error messages involving <tt class="code">forceunlink</tt>.</p><li>Test <a
+ error messages involving <tt class="code">forceunlink</tt>.</p></li><li><p>Test <a
  href="/../MyConfig.pm"><tt
- class="file">MyConfig.pm</tt></a> for problems.</li><p class="data-shell">$
- <kbd>perl -c MyConfig.pm</kbd><br>MyConfig.pm syntax OK</p></ol><li>See below
+ class="file">MyConfig.pm</tt></a> for problems.</p><p class="data-shell">$
+ <kbd>perl -c MyConfig.pm</kbd><br />MyConfig.pm syntax OK</p></li></ol></li><li>See below
  for the required <tt class="code">PERL5LIB</tt> settings to customize <tt
  class="code">@INC</tt>, if installing modules that depend on previously
  installed modules. Be sure to load the changes into your shell environment
  before running <tt class="cmd">cpan</tt>, or to close and reopen your
- shell.<br>&nbsp;</li><li>Test the new configuration.</li><p class="info">To
+ shell.<br />&nbsp;</li><li><p>Test the new configuration.</p><p class="info">To
  ensure <tt class="file">Makefile</tt> are being generated with the proper
  paths, <tt class="cmd">make</tt> a module from the <a
  href="http://search.cpan.org/perldoc/CPAN"
  title="Documentation on the CPAN Perl module"><tt
  class="perl-module">CPAN</tt></a> shell, then review at the paths set in the
  resulting <tt class="file">Makefile</tt>.</p><p class="data-shell">cpan&gt;
- <kbd>make Text::Autoformat</kbd><br>…<br>cpan&gt; <kbd>look
- Text::Autoformat</kbd><br>…<br>$ <kbd>less Makefile</kbd><br>$ <kbd>grep
- /home/username Makefile</kbd><br>SITELIBEXP =
- /home/username/lib/perl5<br>PREFIX = /home/username/<br>INSTALLPRIVLIB =
- /home/username/lib/perl5<br>INSTALLSITELIB =
- /home/username/lib/perl5<br>INSTALLVENDORLIB =
- /home/username/lib/perl5<br>INSTALLARCHLIB =
- /home/username/lib/perl5/darwin-thread-multi-2level<br>INSTALLSITEARCH =
- /home/username/lib/perl5/darwin-thread-multi-2level<br>INSTALLVENDORARCH =
- /home/username/lib/perl5/darwin-thread-multi-2level<br>INSTALLMAN1DIR =
- /home/username/share/man/man1<br>INSTALLSITEMAN1DIR =
- /home/username/share/man/man1<br>INSTALLMAN3DIR =
- /home/username/share/man/man3<br>INSTALLSITEMAN3DIR =
- /home/username/share/man/man3<br>$ <kbd>exit</kbd></p><p class="info">If the
+ <kbd>make Text::Autoformat</kbd><br />…<br />cpan&gt; <kbd>look
+ Text::Autoformat</kbd><br />…<br />$ <kbd>less Makefile</kbd><br />$ <kbd>grep
+ /home/username Makefile</kbd><br />SITELIBEXP =
+ /home/username/lib/perl5<br />PREFIX = /home/username/<br />INSTALLPRIVLIB =
+ /home/username/lib/perl5<br />INSTALLSITELIB =
+ /home/username/lib/perl5<br />INSTALLVENDORLIB =
+ /home/username/lib/perl5<br />INSTALLARCHLIB =
+ /home/username/lib/perl5/darwin-thread-multi-2level<br />INSTALLSITEARCH =
+ /home/username/lib/perl5/darwin-thread-multi-2level<br />INSTALLVENDORARCH =
+ /home/username/lib/perl5/darwin-thread-multi-2level<br />INSTALLMAN1DIR =
+ /home/username/share/man/man1<br />INSTALLSITEMAN1DIR =
+ /home/username/share/man/man1<br />INSTALLMAN3DIR =
+ /home/username/share/man/man3<br />INSTALLSITEMAN3DIR =
+ /home/username/share/man/man3<br />$ <kbd>exit</kbd></p><p class="info">If the
  <tt class="file">Makefile</tt> has the wrong path set for any variables,
  update the <tt class="code">makepl_arg</tt> arguments in <tt
  class="file">MyConfig.pm</tt> to set these variables to install to the proper
- custom location.</p></ol><h2><a name="s3">Customize <tt
- class="code">@INC</tt></a></h2><p class="info">Perl must be made aware of the
+ custom location.</p></li></ol><h2 id="s3">Customize <tt
+ class="code">@INC</tt></h2><p class="info">Perl must be made aware of the
  custom <tt class="file">/home/username/lib/perl5</tt> library directory. Perl
  uses the <tt class="code">@INC</tt> variable to hold library directories,
  though this varible must not be edited directly. For more information on <tt
  class="perl-module">lib</tt></a> (<tt class="code">use lib</tt> pragma). Under
  a Bourne shell (such as <tt class="cmd">zsh</tt>), use the following to set
  <tt class="code">PERL5LIB</tt> and <tt class="code">MANPATH</tt> environment
- variables.</p><p class="data">if [ -d $HOME/lib/perl5 ]; then<br>
- PERL5LIB=${PERL5LIB:+$PERL5LIB:}$HOME/lib/perl5<br>fi<br>MANPATH=${MANPATH:+$MANPATH:}$HOME/share/man<br>export
+ variables.</p><p class="data">if [ -d $HOME/lib/perl5 ]; then<br />
+ PERL5LIB=${PERL5LIB:+$PERL5LIB:}$HOME/lib/perl5<br />fi<br />MANPATH=${MANPATH:+$MANPATH:}$HOME/share/man<br />export
  MANPATH PERL5LIB</p><p class="info">Code running under Taint mode may require
  the <a
  href="http://perldoc.perl.org/lib.html"><tt
  class="code">SetEnv</tt> under <a
  href="http://web.archive.org/howto/apache/">Apache</a>:</p><p
  class="data">SetEnv PERL5LIB /home/username/lib/perl5:/sw/lib/perl5</p><div
- class="footer"><a
- href="http://web.archive.org/"><img
- style="float: right; margin-top: 1em; margin-right: 1em; margin-bottom: 5em;"
- src="Using%20CPAN%20with%20a%20non-root%20account_files/sial.html" width="64"
- height="64"></a><p>The author disclaims all copyrights and releases this
+ class="footer"><p>The author disclaims all copyrights and releases this
  document into the public domain.</p><p><a
  href="http://web.archive.org/contact/">Questions
  or comments about this page?</a> Current ruminations available on <a
       </p><p><tt>$Id: index.xml,v 1.6 2007/12/11 03:05:00 jmates Exp
       $</tt></p></div></div>
 
-
-
-
-
-
-<script language="Javascript">
-<!--
-
-// FILE ARCHIVED ON 20080621084008 AND RETRIEVED FROM THE // INTERNET ARCHIVE
-ON 20101121191648.  // JAVASCRIPT APPENDED BY WAYBACK MACHINE, COPYRIGHT
-INTERNET ARCHIVE.  // ALL OTHER CONTENT MAY ALSO BE PROTECTED BY COPYRIGHT (17
-U.S.C.  // SECTION 108(a)(3)).
-
-   var sWayBackCGI = "http://web.archive.org/web/20080621084008/";
-
-   function xResolveUrl(url) { var image = new Image(); image.src = url; return
-   image.src; } function xLateUrl(aCollection, sProp) { var i = 0; for(i = 0; i
-   < aCollection.length; i++) { var url = aCollection[i][sProp];         if
-   (typeof(url) == "string") { if (url.indexOf("mailto:") == -1 &&
-   url.indexOf("javascript:") == -1 && url.length > 0) { if(url.indexOf("http")
-   != 0) { url = xResolveUrl(url); } url =
-   url.replace('.wstub.archive.org',''); aCollection[i][sProp] = sWayBackCGI +
-   url; } } } }
-
-   xLateUrl(document.getElementsByTagName("IMG"),"src");
-   xLateUrl(document.getElementsByTagName("A"),"href");
-   xLateUrl(document.getElementsByTagName("AREA"),"href");
-   xLateUrl(document.getElementsByTagName("OBJECT"),"codebase");
-   xLateUrl(document.getElementsByTagName("OBJECT"),"data");
-   xLateUrl(document.getElementsByTagName("APPLET"),"codebase");
-   xLateUrl(document.getElementsByTagName("APPLET"),"archive");
-   xLateUrl(document.getElementsByTagName("EMBED"),"src");
-   xLateUrl(document.getElementsByTagName("BODY"),"background");
-   xLateUrl(document.getElementsByTagName("TD"),"background");
-   xLateUrl(document.getElementsByTagName("INPUT"),"src"); var forms =
-   document.getElementsByTagName("FORM"); if (forms) { var j = 0; for (j = 0; j
-   < forms.length; j++) { f = forms[j]; if (typeof(f.action)  == "string") {
-   if(typeof(f.method)  == "string") { if(typeof(f.method) != "post") {
-   f.action = sWayBackCGI + f.action; } } } } }
-
-
-//--> </script>
-
 </body><!-- SOME META URL'S ON THIS PAGE HAVE BEEN REWRITTEN BY THE WAYBACK
 MACHINE OF THE INTERNET ARCHIVE IN ORDER TO PRESERVE THE TEMPORAL INTEGRITY OF
 THE SESSION. --><!-- SOME LINK HREF'S ON THIS PAGE HAVE BEEN REWRITTEN BY THE

src/tutorials/modern-perl/xhtml/chapter_00.html

     # example code here
     ...</code>
 </pre></div>
-<p>Other code snippets use testing functions such as <code>ok()</code>, <code>like()</code>, and <code>is()</code> (<a href="chapter_09.xhtml#testing">Testing</a>(testing)). That skeleton program is:</p>
+<p>Other code snippets use testing functions such as <code>ok()</code>, <code>like()</code>, and <code>is()</code> (<a href="chapter_09.html#testing">Testing</a>(testing)). That skeleton program is:</p>
 <div class="programlisting">
 <pre>
 <code>    #!/usr/bin/perl

src/tutorials/modern-perl/xhtml/chapter_01.html

     $ <b>perldoc perltoc</b>
     $ <b>perldoc Moose::Manual</b></code>
 </pre>
-<p>The first example extracts documentation written for the <code>List::Util</code> module and displays it in a form appropriate for your screen. Community standards for CPAN modules (<a href="chapter_02.xhtml#cpan">The CPAN</a>(cpan)) suggest that additional libraries use the same documentation format and form as core modules, so there's no distinction between reading the documentation for a core library such as <code>Data::Dumper</code> or one installed from the CPAN. The standard documentation template includes a description of the module, demonstrates sample uses, and then contains a detailed explanation of the module and its interface. While the amount of documentation varies by author, the form of the documentation is remarkably consistent.</p>
+<p>The first example extracts documentation written for the <code>List::Util</code> module and displays it in a form appropriate for your screen. Community standards for CPAN modules (<a href="chapter_02.html#cpan">The CPAN</a>(cpan)) suggest that additional libraries use the same documentation format and form as core modules, so there's no distinction between reading the documentation for a core library such as <code>Data::Dumper</code> or one installed from the CPAN. The standard documentation template includes a description of the module, demonstrates sample uses, and then contains a detailed explanation of the module and its interface. While the amount of documentation varies by author, the form of the documentation is remarkably consistent.</p>
 <p>The second example displays a pure documentation file, in this case the table of contents of the core documentation itself. This file describes each individual piece of the core documentation; browse it for a good understanding of Perl's breadth.</p>
-<p>The third example resembles the second; <code>Moose::Manual</code> is part of the Moose CPAN distribution (<a href="chapter_07.xhtml#moose">Moose</a>(moose)). It is also purely documentation; it contains no code.</p>
+<p>The third example resembles the second; <code>Moose::Manual</code> is part of the Moose CPAN distribution (<a href="chapter_07.html#moose">Moose</a>(moose)). It is also purely documentation; it contains no code.</p>
 <div class="sidebar">
 <p>Similarly, <code>perldoc perlfaq</code> will display the table of contents for Frequently Asked Questions about Perl 5. Skimming these questions is invaluable.</p>
 </div>
 <p>Perl hackers have a slogan for this: <i>TIMTOWTDI</i>, pronounced "Tim Toady", or "There's more than one way to do it!"</p>
 <p>Where this expressivity can provide a large palette with which master craftsman can create amazing and powerful edifices, unwise conglomerations of various techniques can impede maintainability and comprehensibility. You can write good code or you can make a mess. The choice is yours <span class="footnote">(footnote: ... but be kind to other people, if you must make a mess.)</span>.</p>
 <p>Where other languages might suggest that one enforced way to perform any operation is the right solution, Perl allows you to optimize for your most important criteria. Within the realm of your own problems, you can choose from several good approaches--but be mindful of readability and future maintainability.</p>
-<p>As a novice to Perl, you may find certain constructs difficult to understand. The greater Perl community has discovered and promoted several idioms (<a href="chapter_10.xhtml#idioms">Idioms</a>(idioms)) which offer great power. Don't expect to understand them immediately. Some of Perl's features interact in subtle ways.</p>
+<p>As a novice to Perl, you may find certain constructs difficult to understand. The greater Perl community has discovered and promoted several idioms (<a href="chapter_10.html#idioms">Idioms</a>(idioms)) which offer great power. Don't expect to understand them immediately. Some of Perl's features interact in subtle ways.</p>
 <div class="sidebar">
 <p>Learning Perl is like learning a second or third spoken language. You'll learn a few words, then string together some sentences, and eventually will be able to have small, simple conversations. Mastery comes with practice, both reading and writing. You don't have to understand all of the details of this chapter immediately to be productive with Perl. Keep the principles as you read the rest of this book.</p>
 </div>
-<p>Another design goal of Perl is to surprise experienced (Perl) programmers very little. For example, adding two scalars together with a numeric operator (<code>$first_num + $second_num</code>) is obviously a numeric operation; the operator must treat both scalars as numeric values to produce a numeric result. No matter what the contents of <code>$first_num</code> and <code>$second_num</code>, Perl will coerce them to numeric values (<a href="chapter_03.xhtml#numeric_coercion">Numeric Coercion</a>(numeric_coercion)) without requiring the user or programmer to perform this conversion manually. You've expressed your intent to treat them as numbers by choosing a numeric operator (<a href="chapter_04.xhtml#numeric_operators">Numeric Operators</a>(numeric_operators)), so Perl happily handles the rest.</p>
+<p>Another design goal of Perl is to surprise experienced (Perl) programmers very little. For example, adding two scalars together with a numeric operator (<code>$first_num + $second_num</code>) is obviously a numeric operation; the operator must treat both scalars as numeric values to produce a numeric result. No matter what the contents of <code>$first_num</code> and <code>$second_num</code>, Perl will coerce them to numeric values (<a href="chapter_03.html#numeric_coercion">Numeric Coercion</a>(numeric_coercion)) without requiring the user or programmer to perform this conversion manually. You've expressed your intent to treat them as numbers by choosing a numeric operator (<a href="chapter_04.html#numeric_operators">Numeric Operators</a>(numeric_operators)), so Perl happily handles the rest.</p>
 <div id="iDWIM_0"></div>
 <div id="iprinciple_of_least_astonishment_0"></div>
-<p>In general, Perl programmers can expect Perl to do what you mean; this is the notion of <i>DWIM</i>--<i>do what I mean</i>. You may also see this mentioned as the <i>principle of least astonishment</i>. Given a cursory understanding of Perl (especially its <a href="chapter_01.xhtml#context_philosophy">Context</a>(context_philosophy)), it should be possible to read a single unfamiliar Perl expression and understand its intent.</p>
+<p>In general, Perl programmers can expect Perl to do what you mean; this is the notion of <i>DWIM</i>--<i>do what I mean</i>. You may also see this mentioned as the <i>principle of least astonishment</i>. Given a cursory understanding of Perl (especially its <a href="chapter_01.html#context_philosophy">Context</a>(context_philosophy)), it should be possible to read a single unfamiliar Perl expression and understand its intent.</p>
 <div id="ibaby_Perl_0"></div>
 <p>If you're new to Perl, you will develop this skill over time. The flip side of Perl's expressivity is that Perl novices can write useful programs before they learn all of Perl's powerful features. The Perl community often refers to this as <i>baby Perl</i>. Though it may sound dismissive, please don't take offense; everyone was a novice once. Take the opportunity to learn from more experienced programmers and ask for explanations of idioms and constructs you don't yet understand.</p>
 <div class="sidebar">
 <p>One of the aspects of context governs <i>how many</i> items you expect. This is <i>amount context</i>. Compare this context to subject-verb number agreement in English. Even if you haven't learned the formal description of the rule, you probably understand the error in the sentence "Perl are a fun language". The rule in Perl is that the number of items you request determines how many you get.</p>
 <div id="ivoid_context_0"></div>
 <div id="icontext__ivoid_0"></div>
-<p>Suppose you have a function (<a href="chapter_05.xhtml#functions">Functions</a>(functions)) called <code>some_expensive_operation()</code> which performs an expensive calculation and can produce many, many results. If you call the function on its own and never use its return value, you've called the function in <i>void context</i>:</p>
+<p>Suppose you have a function (<a href="chapter_05.html#functions">Functions</a>(functions)) called <code>some_expensive_operation()</code> which performs an expensive calculation and can produce many, many results. If you call the function on its own and never use its return value, you've called the function in <i>void context</i>:</p>
 <div class="programlisting">
 <pre>
 <code>    some_expensive_operation();</code>
 <code>    my $single_result = some_expensive_operation();</code>
 </pre></div>
 <div id="ilist_context_0"></div>
-<p>Assigning the results of calling the function to an array (<a href="chapter_03.xhtml#arrays">Arrays</a>(arrays)) or a list, or using it in a list evaluates the function in <i>list context</i>:</p>
+<p>Assigning the results of calling the function to an array (<a href="chapter_03.html#arrays">Arrays</a>(arrays)) or a list, or using it in a list evaluates the function in <i>list context</i>:</p>
 <div class="programlisting">
 <pre>
 <code>    my @all_results        = some_expensive_operation();
 <div id="iboolean_context_0"></div>
 <div id="icontext__iboolean_0"></div>
 <p><i>Boolean context</i> occurs when you use a value in a conditional statement. In the previous examples, the <code>if</code> statement evaluated the results of the <code>eq</code> and <code>==</code> operators in boolean context.</p>
-<p>Perl will do its best to coerce values to the proper type (<a href="chapter_03.xhtml#coercion">Coercion</a>(coercion)), depending on the operators you use. Be sure to use the proper operator for the type of context you want.</p>
+<p>Perl will do its best to coerce values to the proper type (<a href="chapter_03.html#coercion">Coercion</a>(coercion)), depending on the operators you use. Be sure to use the proper operator for the type of context you want.</p>
 <p>In rare circumstances, you may need to force an explicit context where no appropriately typed operator exists. To force a numeric context, add zero to a variable. To force a string context, concatenate a variable with the empty string. To force a boolean context, double the negation operator:</p>
 <div class="programlisting">
 <pre>
     my $stringy_x = '' . $x;  # forces string  context
     my $boolean_x =    !!$x;  # forces boolean context</code>
 </pre></div>
-<p>In general, type contexts are less difficult to understand and see than the amount contexts. Once you understand that they exist and know which operators provide which contexts (<a href="chapter_04.xhtml#operator_types">Operator Types</a>(operator_types)), you'll rarely make mistakes with them.</p>
+<p>In general, type contexts are less difficult to understand and see than the amount contexts. Once you understand that they exist and know which operators provide which contexts (<a href="chapter_04.html#operator_types">Operator Types</a>(operator_types)), you'll rarely make mistakes with them.</p>
 <h4 id="heading_id_8">Implicit Ideas</h4>
 <div id="implicit_ideas"></div>
 <p>Like many spoken languages, Perl provides linguistic shortcuts. Context is one such feature. Both the compiler and a programmer reading the code can understand the expected number of results or the type of an operation from existing information without adding additional explicit information to disambiguate. Others also exist.</p>
     say;    # prints $_ to the currently selected filehandle
             # with a trailing newline</code>
 </pre></div>
-<p>Perl's regular expression facilities (<a href="chapter_06.xhtml#regular_expressions">Regular Expressions</a>(regular_expressions)) can also operate on <code>$_</code>, performing matches, substitutions, and transliterations:</p>
+<p>Perl's regular expression facilities (<a href="chapter_06.html#regular_expressions">Regular Expressions</a>(regular_expressions)) can also operate on <code>$_</code>, performing matches, substitutions, and transliterations:</p>
 <div class="programlisting">
 <pre>
 <code>    $_ = 'My name is Paquito';
 <p>Check how many other string functions this includes?</p>
 </div>
 <p>Many of Perl's scalar operators work on the default scalar variable if you do not provide an alternative.</p>
-<p>Perl's looping directives (<a href="chapter_03.xhtml#looping_directives">Looping Directives</a>(looping_directives)) also set <code>$_</code>, such as <code>for</code> iterating over a list:</p>
+<p>Perl's looping directives (<a href="chapter_03.html#looping_directives">Looping Directives</a>(looping_directives)) also set <code>$_</code>, such as <code>for</code> iterating over a list:</p>
 <div class="programlisting">
 <pre>
 <code>    say "#<b>$_</b>" for 1 .. 10;
 <div id="idefault_array_variables_0"></div>
 <div id="ivariables__i64__0"></div>
 <div id="i64__0"></div>
-<p>While Perl has a single implicit scalar variable, it has two implicit array variables. Perl passes arguments to functions in an array named <code>@_</code>. Array manipulation operations (<a href="chapter_03.xhtml#arrays">Arrays</a>(arrays)) performed inside functions affect this array by default. Thus, these two snippets of code are equivalent:</p>
+<p>While Perl has a single implicit scalar variable, it has two implicit array variables. Perl passes arguments to functions in an array named <code>@_</code>. Array manipulation operations (<a href="chapter_03.html#arrays">Arrays</a>(arrays)) performed inside functions affect this array by default. Thus, these two snippets of code are equivalent:</p>
 <div class="programlisting">
 <pre>
 <code>    sub foo

src/tutorials/modern-perl/xhtml/chapter_02.html

 <p>Perl.com publishes several articles and tutorials about Perl programming every month. Its archives reach back into the 20th century. See <span class="url">http://www.perl.com/</span>.</p>
 <div id="icpan46org_0"></div>
 <div id="iwebsites__icpan46org_0"></div>
-<p>The CPAN's (<a href="chapter_02.xhtml#cpan">The CPAN</a>(cpan)) central location is <span class="url">http://www.cpan.org/</span>, though experienced users spend more time on <span class="url">http://search.cpan.org/</span>. This central software distribution hub of reusable, free Perl code is an essential part of the Perl community.</p>
+<p>The CPAN's (<a href="chapter_02.html#cpan">The CPAN</a>(cpan)) central location is <span class="url">http://www.cpan.org/</span>, though experienced users spend more time on <span class="url">http://search.cpan.org/</span>. This central software distribution hub of reusable, free Perl code is an essential part of the Perl community.</p>
 <div id="iPerlMonks_0"></div>
 <p>PerlMonks, at <span class="url">http://perlmonks.org/</span>, is a venerable community site devoted to questions and answers and other discussions about Perl programming. It celebrated its tenth anniversary in December 2009, making it one of the longest lasting web communities dedicated to any programming language.</p>
 <div id="iuse_Perl59_0"></div>

src/tutorials/modern-perl/xhtml/chapter_03.html

 <div id="names"></div>
 <div id="inames_0"></div>
 <div id="iidentifiers_0"></div>
-<p><i>Names</i> (or <i>identifiers</i>) are everywhere in Perl programs: variables, functions, packages, classes, and even filehandles have names. These names all start with a letter or an underscore. They may optionally include any combination of letters, numbers, and underscores. When the <code>utf8</code> pragma (<a href="chapter_09.xhtml#pragmas">Pragmas</a>(pragmas), <a href="chapter_03.xhtml#unicode">Unicode and Strings</a>(unicode)) is in effect, you may use any valid UTF-8 characters in identifiers. These are all valid Perl identifiers:</p>
+<p><i>Names</i> (or <i>identifiers</i>) are everywhere in Perl programs: variables, functions, packages, classes, and even filehandles have names. These names all start with a letter or an underscore. They may optionally include any combination of letters, numbers, and underscores. When the <code>utf8</code> pragma (<a href="chapter_09.html#pragmas">Pragmas</a>(pragmas), <a href="chapter_03.html#unicode">Unicode and Strings</a>(unicode)) is in effect, you may use any valid UTF-8 characters in identifiers. These are all valid Perl identifiers:</p>
 <div class="programlisting">
 <pre>
 <code>    my $name;
 </pre></div>
 <div id="isymbolic_lookups_0"></div>
 <p>These rules only apply to names which appear in literal form in source code; that is, if you've typed it directly like <code>sub fetch_pie</code> or <code>my $wafflemaker</code>.</p>
-<p>Perl's dynamic nature makes it possible to refer to entities with names generated at runtime or provided as input to a program. These are <i>symbolic lookups</i>. You get more flexibility this way at the expense of some safety. In particular, invoking functions or methods indirectly or looking up namespaced symbols lets you bypass Perl's parser, which is the only part of Perl that enforces these grammatic rules. Be aware that doing so can produce confusing code; a hash (<a href="chapter_03.xhtml#hashes">Hashes</a>(hashes)) or nested data structure (<a href="chapter_03.xhtml#nested_data_structures">Nested Data Structures</a>(nested_data_structures)) is often clearer.</p>
+<p>Perl's dynamic nature makes it possible to refer to entities with names generated at runtime or provided as input to a program. These are <i>symbolic lookups</i>. You get more flexibility this way at the expense of some safety. In particular, invoking functions or methods indirectly or looking up namespaced symbols lets you bypass Perl's parser, which is the only part of Perl that enforces these grammatic rules. Be aware that doing so can produce confusing code; a hash (<a href="chapter_03.html#hashes">Hashes</a>(hashes)) or nested data structure (<a href="chapter_03.html#nested_data_structures">Nested Data Structures</a>(nested_data_structures)) is often clearer.</p>
 <h4 id="heading_id_4">Variable Names and Sigils</h4>
 <div id="ivariables__inames_0"></div>
 <div id="iscalar_variables_0"></div>
 <div id="ivariables__iarrays_0"></div>
 <div id="ihash_variables_0"></div>
 <div id="ivariables__ihashes_0"></div>
-<p><i>Variable names</i> always have a leading sigil which indicates the type of the variable's value. <i>Scalar variables</i> (<a href="chapter_03.xhtml#scalars">Scalars</a>(scalars)) have a leading dollar sign (<code>$</code>) character. <i>Array variables</i> (<a href="chapter_03.xhtml#arrays">Arrays</a>(arrays)) have a leading at sign (<code>@</code>) character. <i>Hash variables</i> (<a href="chapter_03.xhtml#hashes">Hashes</a>(hashes)) have a leading percent sign (<code>%</code>) character:</p>
+<p><i>Variable names</i> always have a leading sigil which indicates the type of the variable's value. <i>Scalar variables</i> (<a href="chapter_03.html#scalars">Scalars</a>(scalars)) have a leading dollar sign (<code>$</code>) character. <i>Array variables</i> (<a href="chapter_03.html#arrays">Arrays</a>(arrays)) have a leading at sign (<code>@</code>) character. <i>Hash variables</i> (<a href="chapter_03.html#hashes">Hashes</a>(hashes)) have a leading percent sign (<code>%</code>) character:</p>
 <div class="programlisting">
 <pre>
 <code>    my $scalar;
 </pre></div>
 <div id="ilvalue_0"></div>
 <div id="irvalue_0"></div>
-<p>In the latter two lines, using a scalar element of an aggregate as an <i>lvalue</i> (the target of an assignment, on the left side of the <code>=</code> character) imposes scalar context (<a href="chapter_01.xhtml#context_philosophy">Context</a>(context_philosophy)) on the <i>rvalue</i> (the value assigned, on the right side of the <code>=</code> character).</p>
+<p>In the latter two lines, using a scalar element of an aggregate as an <i>lvalue</i> (the target of an assignment, on the left side of the <code>=</code> character) imposes scalar context (<a href="chapter_01.html#context_philosophy">Context</a>(context_philosophy)) on the <i>rvalue</i> (the value assigned, on the right side of the <code>=</code> character).</p>
 <div id="islicing_0"></div>
 <p>Similarly, accessing multiple elements of a hash or an array--an operation known as <i>slicing</i>--uses the at symbol (<code>@</code>) as the leading sigil and enforces list context when used as an lvalue:</p>
 <div class="programlisting">
 <h4 id="heading_id_5">Package-Qualified Names</h4>
 <div id="ifully45qualified_name_0"></div>
 <p>Occasionally you may need to refer to functions or variables in a separate namespace. Often you will need to refer to a class by its <i>fully-qualified name</i>. These names are collections of package names joined by double colons (<code>::</code>). That is, <code>My::Fine::Package</code> refers to a logical collection of variables and functions.</p>
-<p>While the standard naming rules apply to package names, by convention user-defined packages all start with uppercase letters. The Perl core reserves lowercase package names for built-in pragmas (<a href="chapter_09.xhtml#pragmas">Pragmas</a>(pragmas)), such as <code>strict</code> and <code>warnings</code>. This is a policy enforced by community guidelines, rather than technical mechanisms.</p>
+<p>While the standard naming rules apply to package names, by convention user-defined packages all start with uppercase letters. The Perl core reserves lowercase package names for built-in pragmas (<a href="chapter_09.html#pragmas">Pragmas</a>(pragmas)), such as <code>strict</code> and <code>warnings</code>. This is a policy enforced by community guidelines, rather than technical mechanisms.</p>
 <p>Namespaces do not nest in Perl 5. The relationship between between <code>Some::Package</code> and <code>Some::Package::Refinement</code> is only a storage mechanism, with no further implications on the relationships between parent and child or sibling packages. When Perl looks up a symbol in <code>Some::Package::Refinement</code>, it looks in the <code>main::</code> symbol table for a symbol representing the <code>Some::</code> namespace, then in there for the <code>Package::</code> namespace, and so on. It's your responsibility to make any <i>logical</i> relationships between entities obvious when you choose names and organize your code.</p>
 <h3 id="heading_id_6">Variables</h3>
 <div id="variables"></div>
 <div id="ivariable_0"></div>
-<p>A <i>variable</i> in Perl is a storage location for a value (<a href="chapter_03.xhtml#values">Values</a>(values)). You can work with values directly, but all but the most trivial code works with variables. A variable is a level of indirection; it's easier to explain the Pythagorean theorem in terms of the variables <code>a</code>, <code>b</code>, and <code>c</code> than with the side lengths of every right triangle you can imagine. This may seem basic and obvious, but to write robust, well-designed, testable, and composable programs, you must identify and exploit points of genericity wherever possible.</p>
+<p>A <i>variable</i> in Perl is a storage location for a value (<a href="chapter_03.html#values">Values</a>(values)). You can work with values directly, but all but the most trivial code works with variables. A variable is a level of indirection; it's easier to explain the Pythagorean theorem in terms of the variables <code>a</code>, <code>b</code>, and <code>c</code> than with the side lengths of every right triangle you can imagine. This may seem basic and obvious, but to write robust, well-designed, testable, and composable programs, you must identify and exploit points of genericity wherever possible.</p>
 <h4 id="heading_id_7">Variable Naming</h4>
 <div id="ivariables__inames_1"></div>
-<p>Not all variables require names, but most of the variables you will encounter in your programs will have names. Variables in Perl 5 must conform to the standard rules of identifier naming (<a href="chapter_03.xhtml#names">Names</a>(names)). Variables also have leading sigils.</p>
+<p>Not all variables require names, but most of the variables you will encounter in your programs will have names. Variables in Perl 5 must conform to the standard rules of identifier naming (<a href="chapter_03.html#names">Names</a>(names)). Variables also have leading sigils.</p>
 <div class="author">
 <p>the Variable Naming section seems quite redundant with the Variable Names and Sigils section from names.pod, which gets inserted directly above this section in chapter 3</p>
 </div>
 <div id="variable_scopes"></div>
 <div id="ivariables__iscope_0"></div>
 <div id="iscope_0"></div>
-<p>Variables also have visibility, depending on their scope (<a href="chapter_05.xhtml#scope">Scope</a>(scope)). Most of the variables you will encounter have lexical scope <a href="chapter_05.xhtml#lexical_scope">Lexical Scope</a>(lexical_scope)), as the expected visibility of these variables is local.</p>
+<p>Variables also have visibility, depending on their scope (<a href="chapter_05.html#scope">Scope</a>(scope)). Most of the variables you will encounter have lexical scope <a href="chapter_05.html#lexical_scope">Lexical Scope</a>(lexical_scope)), as the expected visibility of these variables is local.</p>
 <p>Package variables have global visibility throughout the program, but they are only available when prefixed with the name of the containing package. For example:</p>
 <div class="programlisting">
 <pre>
 <div id="ilexpads_0"></div>
 <div id="isymbol_tables_0"></div>
 <p>This difference in visibility between package variables and lexical variables is apparent in the different storage mechanisms of these variables within Perl 5 itself. Lexical variables get stored in <i>lexical pads</i> attached to scopes. Every new entry into such a lexical scope requires Perl to create a new pad to contain the values of the variables for that particular entry into the scope. (This is how a function can call itself and not clobber the values of existing variables.)</p>
-<p>Package variables have a storage mechanism called symbol tables. Each package has a single symbol table, and every package variable has an entry in this table. You can inspect and modify this symbol table from Perl; this is how importing works (<a href="chapter_05.xhtml#importing">Importing</a>(importing)).</p>
+<p>Package variables have a storage mechanism called symbol tables. Each package has a single symbol table, and every package variable has an entry in this table. You can inspect and modify this symbol table from Perl; this is how importing works (<a href="chapter_05.html#importing">Importing</a>(importing)).</p>
 </div>
 <h4 id="heading_id_9">Variable Sigils</h4>
 <div id="sigils"></div>
 <div id="ivariables__isigils_0"></div>
 <div id="isigils_0"></div>
-<p>In Perl 5, the sigil of the variable in a declaration determines the type of the variable, whether scalar, array, or hash. The sigil of the variable used to access the variable determines the type of access to its value. Sigils on variables vary depending on what you do to the variable. For example, you declare an array as <code>@values</code>. You access the first element--a single value--of the array with <code>$values[0]</code>. You access a list of values from the array with <code>@values[ @indices ]</code>. See the arrays (<a href="chapter_03.xhtml#arrays">Arrays</a>(arrays)) and hashes (<a href="chapter_03.xhtml#hashes">Hashes</a>(hashes)) sections for more.</p>
+<p>In Perl 5, the sigil of the variable in a declaration determines the type of the variable, whether scalar, array, or hash. The sigil of the variable used to access the variable determines the type of access to its value. Sigils on variables vary depending on what you do to the variable. For example, you declare an array as <code>@values</code>. You access the first element--a single value--of the array with <code>$values[0]</code>. You access a list of values from the array with <code>@values[ @indices ]</code>. See the arrays (<a href="chapter_03.html#arrays">Arrays</a>(arrays)) and hashes (<a href="chapter_03.html#hashes">Hashes</a>(hashes)) sections for more.</p>
 <h4 id="heading_id_10">Anonymous Variables</h4>
 <div id="ianonymous_variables_0"></div>
 <div id="ivariables__ianonymous_0"></div>
-<p>Perl 5 variables do not <i>need</i> names; Perl can allocate storage space for variables without storing them in lexical pads or symbol tables. These are <i>anonymous</i> variables. The only way to access them is by reference (<a href="chapter_03.xhtml#references">References</a>(references)).</p>
+<p>Perl 5 variables do not <i>need</i> names; Perl can allocate storage space for variables without storing them in lexical pads or symbol tables. These are <i>anonymous</i> variables. The only way to access them is by reference (<a href="chapter_03.html#references">References</a>(references)).</p>
 <h4 id="heading_id_11">Variables, Types, and Coercion</h4>
 <div id="ivariables__itypes_0"></div>
 <div id="itypes__icontainers_0"></div>
 <div id="itypes__ivariables_0"></div>
 <div id="icontainer_types_0"></div>
-<p>Perl 5 variables do not enforce types on their values. You may store a string in a variable in one line, append to that variable a number on the next, and reassign a reference to a function (<a href="chapter_03.xhtml#function_references">Function References</a>(function_references)) on the third. The types of the <i>values</i> is flexible (or dynamic), but the type of the <i>variable</i> is static. A scalar variable can only hold scalars. An array variable only contains lists. A hash variable must contain an even-sized list of key/value pairs.</p>
-<p>Assigning to a variable may cause coercion (<a href="chapter_03.xhtml#coercion">Coercion</a>(coercion)). The documented way to determine the number of entries in an array is to evaluate that array in scalar context (<a href="chapter_01.xhtml#context_philosophy">Context</a>(context_philosophy)). Because a scalar variable can only ever contain a scalar, assigning an array to a scalar imposes scalar context on the operation and produces the number of elements in the array:</p>
+<p>Perl 5 variables do not enforce types on their values. You may store a string in a variable in one line, append to that variable a number on the next, and reassign a reference to a function (<a href="chapter_03.html#function_references">Function References</a>(function_references)) on the third. The types of the <i>values</i> is flexible (or dynamic), but the type of the <i>variable</i> is static. A scalar variable can only hold scalars. An array variable only contains lists. A hash variable must contain an even-sized list of key/value pairs.</p>
+<p>Assigning to a variable may cause coercion (<a href="chapter_03.html#coercion">Coercion</a>(coercion)). The documented way to determine the number of entries in an array is to evaluate that array in scalar context (<a href="chapter_01.html#context_philosophy">Context</a>(context_philosophy)). Because a scalar variable can only ever contain a scalar, assigning an array to a scalar imposes scalar context on the operation and produces the number of elements in the array:</p>
 <div class="programlisting">
 <pre>
 <code>    my $count = @items;</code>
 <div class="sidebar">
 <p>If the identifier begins with whitespace, that same whitespace must be present exactly in the ending delimiter. Even if you do indent the identifier, Perl 5 will <i>not</i> remove equivalent whitespace from the start of each line of the heredoc.</p>
 </div>
-<p>You may use a string in other contexts, such as boolean or numeric; its contents will determine the resulting value (<a href="chapter_03.xhtml#coercion">Coercion</a>(coercion)).</p>
+<p>You may use a string in other contexts, such as boolean or numeric; its contents will determine the resulting value (<a href="chapter_03.html#coercion">Coercion</a>(coercion)).</p>
 <h4 id="heading_id_14">Unicode and Strings</h4>
 <div id="unicode"></div>
 <div id="iunicode_0"></div>
 <div id="ipragmas__iutf8_0"></div>
 <div id="iutf8_0"></div>
 <div id="iencoding_1"></div>
-<p>You may include Unicode characters in your programs in three ways. The easiest is to use the <code>utf8</code> pragma (<a href="chapter_09.xhtml#pragmas">Pragmas</a>(pragmas)), which tells the Perl parser to interpret the rest of the source code file with the UTF-8 encoding This allows you to use Unicode characters in strings as well in identifiers:</p>
+<p>You may include Unicode characters in your programs in three ways. The easiest is to use the <code>utf8</code> pragma (<a href="chapter_09.html#pragmas">Pragmas</a>(pragmas)), which tells the Perl parser to interpret the rest of the source code file with the UTF-8 encoding This allows you to use Unicode characters in strings as well in identifiers:</p>
 <div class="programlisting">
 <pre>
 <code>    use utf8;
 <div id="iScalar5858Util_0"></div>
 <div id="ilooks_like_number_0"></div>
 <div id="iScalar5858Util__ilooks_like_number_0"></div>
-<p>Because of coercion (<a href="chapter_03.xhtml#coercion">Coercion</a>(coercion)), Perl programmers rarely have to worry about converting text read from outside the program to numbers. Perl will treat anything which looks like a number as a number in numeric contexts. Even though it almost always does so correctly, occasionally it's useful to know if something really does look like a number. The core module <code>Scalar::Util</code> contains a function named <code>looks_like_number</code> which returns a true value if Perl will consider the given argument numeric.</p>
+<p>Because of coercion (<a href="chapter_03.html#coercion">Coercion</a>(coercion)), Perl programmers rarely have to worry about converting text read from outside the program to numbers. Perl will treat anything which looks like a number as a number in numeric contexts. Even though it almost always does so correctly, occasionally it's useful to know if something really does look like a number. The core module <code>Scalar::Util</code> contains a function named <code>looks_like_number</code> which returns a true value if Perl will consider the given argument numeric.</p>
 <div id="iRegexp5858Common_0"></div>
 <p>The <code>Regexp::Common</code> module from the CPAN also provides several well-tested regular expressions to identify valid <i>types</i> (whole number, integer, floating-point value) of numeric values.</p>
 <h4 id="heading_id_21">Undef</h4>
 <div id="iempty_list_0"></div>
 <div id="i4041_0"></div>
 <p>When used on the right-hand side of an assignment, the <code>()</code> construct represents an empty list. When evaluated in scalar context, this evaluates to <code>undef</code>. In list context, it is effectively an empty list.</p>
-<p>When used on the left-hand side of an assignment, the <code>()</code> construct enforces list context. To count the number of elements returned from an expression in list context without using a temporary variable, you use the idiom (<a href="chapter_10.xhtml#idioms">Idioms</a>(idioms)):</p>
+<p>When used on the left-hand side of an assignment, the <code>()</code> construct enforces list context. To count the number of elements returned from an expression in list context without using a temporary variable, you use the idiom (<a href="chapter_10.html#idioms">Idioms</a>(idioms)):</p>
 <div class="programlisting">
 <pre>
 <code>    my $count = <b>()</b> = get_all_clown_hats();</code>
 </pre></div>
-<p>Because of the right associativity (<a href="chapter_04.xhtml#associativity">Associativity</a>(associativity)) of the assignment operator, Perl first evaluates the second assignment by calling <code>get_all_clown_hats()</code> in list context. This produces a list.</p>
+<p>Because of the right associativity (<a href="chapter_04.html#associativity">Associativity</a>(associativity)) of the assignment operator, Perl first evaluates the second assignment by calling <code>get_all_clown_hats()</code> in list context. This produces a list.</p>
 <p>Assignment to the empty list throws away all of the values of the list, but that assignment takes place in scalar context, which evaluates to the number of items on the right hand side of the assignment. As a result, <code>$count</code> contains the number of elements in the list returned from <code>get_all_clown_hats()</code>.</p>
 <p>You don't have to understand all of the implications of this code right now, but it does demonstrate how a few of Perl's fundamental design features can combine to produce interesting and useful behavior.</p>
 <h4 id="heading_id_23">Lists</h4>
 <pre>
 <code>    say name(), ' =&gt; ', age();</code>
 </pre></div>
-<p>Note that you do not need parentheses to <i>create</i> lists; where present, the parentheses in these examples group expressions to change the <i>precedence</i> of those expressions (<a href="chapter_04.xhtml#precedence">Precedence</a>(precedence)).</p>
+<p>Note that you do not need parentheses to <i>create</i> lists; where present, the parentheses in these examples group expressions to change the <i>precedence</i> of those expressions (<a href="chapter_04.html#precedence">Precedence</a>(precedence)).</p>
 <div id="ioperators__irange_0"></div>
 <div id="ioperators__i4646_0"></div>
 <div id="i4646_0"></div>
         gambol();
     }</code>
 </pre></div>
-<p><code>unless</code> works very well for postfix conditionals, especially parameter validation in functions (<a href="chapter_10.xhtml#postfix_parameter_validation">Postfix Parameter Validation</a>(postfix_parameter_validation)):</p>
+<p><code>unless</code> works very well for postfix conditionals, especially parameter validation in functions (<a href="chapter_10.html#postfix_parameter_validation">Postfix Parameter Validation</a>(postfix_parameter_validation)):</p>
 <div class="programlisting">
 <pre>
 <code>    sub frolic
                      &amp;&amp; ok(1, 'second subexpression');</code>
 </pre></div>
 <div class="sidebar">
-<p>The return value of <code>ok()</code> (<a href="chapter_09.xhtml#testing">Testing</a>(testing)) is the boolean value obtained by evaluating the first argument.</p>
+<p>The return value of <code>ok()</code> (<a href="chapter_09.html#testing">Testing</a>(testing)) is the boolean value obtained by evaluating the first argument.</p>
 </div>
 <p>This example prints:</p>
 <div class="screen">
 <div id="iboolean_truth_0"></div>
 <div id="itrue_value_0"></div>
 <div id="ifalse_value_0"></div>
-<p>The conditional directives--<code>if</code>, <code>unless</code>, and the ternary conditional operator--all evaluate an expression in boolean context (<a href="chapter_01.xhtml#context_philosophy">Context</a>(context_philosophy)). As comparison operators such as <code>eq</code>, <code>==</code>, <code>ne</code>, and <code>!=</code> all produce boolean results when evaluated, Perl coerces the results of other expressions--including variables and values--into boolean forms. Empty hashes and arrays evaluate to false.</p>
+<p>The conditional directives--<code>if</code>, <code>unless</code>, and the ternary conditional operator--all evaluate an expression in boolean context (<a href="chapter_01.html#context_philosophy">Context</a>(context_philosophy)). As comparison operators such as <code>eq</code>, <code>==</code>, <code>ne</code>, and <code>!=</code> all produce boolean results when evaluated, Perl coerces the results of other expressions--including variables and values--into boolean forms. Empty hashes and arrays evaluate to false.</p>
 <p>Perl 5 has no single true value, nor a single false value. Any number that evaluates to 0 is false. This includes <code>0</code>, <code>0.0</code>, <code>0e0</code>, <code>0x0</code>, and so on. The empty string (<code>''</code>) and <code>"0"</code> evaluate to false, but the strings <code>"0.0"</code>, <code>"0e0"</code>, and so on do not. The idiom <code>"0 but true"</code> evaluates to 0 in numeric context but evaluates to true, thanks to its string contents. Both the empty list and <code>undef</code> evaluate to false. Empty arrays and hashes return the number 0 in scalar context, so they evaluate to false in boolean context.</p>
 <p>An array which contains a single element--even <code>undef</code>--evaluates to true in boolean context. A hash which contains any elements--even a key and a value of <code>undef</code>--evaluates to true in boolean context.</p>
 <div class="sidebar">
-<p>The <code>Want</code> module available from the CPAN allows you to detect boolean context within your own functions. The core <code>overloading</code> pragma (<a href="chapter_09.xhtml#overloading">Overloading</a>(overloading), <a href="chapter_09.xhtml#pragmas">Pragmas</a>(pragmas)) allows you to specify what your own data types produce when evaluated in a boolean context.</p>
+<p>The <code>Want</code> module available from the CPAN allows you to detect boolean context within your own functions. The core <code>overloading</code> pragma (<a href="chapter_09.html#overloading">Overloading</a>(overloading), <a href="chapter_09.html#pragmas">Pragmas</a>(pragmas)) allows you to specify what your own data types produce when evaluated in a boolean context.</p>
 </div>
 <h4 id="heading_id_29">Looping Directives</h4>
 <div id="looping_directives"></div>
 <p>In this circumstance, returning from <code>greet_person()</code> directly to the caller of <code>log_and_greet_person()</code> is more efficient than returning to <code>log_and_greet_person()</code> and immediately returning <i>from</i> <code>log_and_greet_person()</code>. Returning directly from <code>greet_person()</code> to the caller of <code>log_and_greet_person()</code> is an optimization known as <i>tailcall optimization</i>.</p>
 <p>Perl 5 cannot perform this optimization automatically, but you can perform it manually.</p>
 <div class="sidebar">
-<p>Why would you want to do this? Heavily recursive code (<a href="chapter_05.xhtml#recursion">Recursion</a>(recursion)), especially mutually recursive code, can quickly consume a lot of memory. Reducing the memory needed for internal bookkeeping of control flow can make otherwise expensive algorithms tractable.</p>
+<p>Why would you want to do this? Heavily recursive code (<a href="chapter_05.html#recursion">Recursion</a>(recursion)), especially mutually recursive code, can quickly consume a lot of memory. Reducing the memory needed for internal bookkeeping of control flow can make otherwise expensive algorithms tractable.</p>
 </div>
 <div class="author">
 <p>Check Ruslan Zakirov's tailcall module for maturity and applicability here; it won't be core, but it may be worth mentioning. There are two other sections which mention tailcalls; which has primacy?</p>
 <div id="scalars"></div>
 <div id="iscalar_1"></div>
 <p>Perl 5's fundamental data type is the <i>scalar</i>, which represents a single, discrete value. That value may be a string, an integer, a floating point value, a filehandle, or a reference--but it is always a single value. Scalar values and scalar context have a deep connection; assigning to a scalar provides scalar context.</p>
-<p>Scalars may be lexical, package, or global (<a href="chapter_10.xhtml#globals">Global Variables</a>(globals)) variables. You may only declare lexical or package variables. The names of scalar variables must conform to the <a href="chapter_03.xhtml#names">Names</a>(names) guidelines. Scalar variables always use the leading dollar-sign (<code>$</code>) sigil (<a href="chapter_03.xhtml#sigils">Variable Sigils</a>(sigils)).</p>
+<p>Scalars may be lexical, package, or global (<a href="chapter_10.html#globals">Global Variables</a>(globals)) variables. You may only declare lexical or package variables. The names of scalar variables must conform to the <a href="chapter_03.html#names">Names</a>(names) guidelines. Scalar variables always use the leading dollar-sign (<code>$</code>) sigil (<a href="chapter_03.html#sigils">Variable Sigils</a>(sigils)).</p>
 <div class="sidebar">
-<p>The converse is not <i>universally</i> true; the scalar sigil applied to an operation on an aggregate variable determines the amount type accessed through that operation (<a href="chapter_03.xhtml#arrays">Arrays</a>(arrays), <a href="chapter_03.xhtml#hashes">Hashes</a>(hashes)).</p>
+<p>The converse is not <i>universally</i> true; the scalar sigil applied to an operation on an aggregate variable determines the amount type accessed through that operation (<a href="chapter_03.html#arrays">Arrays</a>(arrays), <a href="chapter_03.html#hashes">Hashes</a>(hashes)).</p>
 </div>
 <h4 id="heading_id_40">Scalars and Types</h4>
 <p>Perl 5 scalars do not have static typing. A scalar variable can contain any type of scalar value without special conversions or casts, and the type of value in a variable can change. This code is legal:</p>
     $value = Store::IceCream-&gt;new();</code>
 </pre></div>
 <p>Yet even though this is <i>legal</i>, it can be confusing. Choose descriptive and unique names for your variables to avoid this confusion.</p>
-<p>The type context of evaluation of a scalar may cause Perl to perform a coercion of the value of that scalar (<a href="chapter_03.xhtml#coercion">Coercion</a>(coercion)). For example, you may treat the contents of a scalar as a string, even if you didn't explicitly assign it a string:</p>
+<p>The type context of evaluation of a scalar may cause Perl to perform a coercion of the value of that scalar (<a href="chapter_03.html#coercion">Coercion</a>(coercion)). For example, you may treat the contents of a scalar as a string, even if you didn't explicitly assign it a string:</p>
 <div class="programlisting">
 <pre>
 <code>    my $zip_code        = 97006;
 <p>This string increment operation turns <code>a</code> into <code>b</code> and <code>z</code> into <code>aa</code>, respecting character set and case. Note that <code>ZZ9</code> becomes <code>ZZ0</code> and <code>ZZ09</code> becomes <code>ZZ10</code>, however--numbers wrap around but do not carry to alphabetic components.</p>
 <div id="istringification_0"></div>
 <div id="inumification_0"></div>
-<p>Evaluating a reference (<a href="chapter_03.xhtml#references">References</a>(references)) in string context produces a string. Evaluating a reference in numeric context produces a number. Neither operation modifies the reference in place, but you cannot recreate the reference from either the string or numeric result:</p>
+<p>Evaluating a reference (<a href="chapter_03.html#references">References</a>(references)) in string context produces a string. Evaluating a reference in numeric context produces a number. Neither operation modifies the reference in place, but you cannot recreate the reference from either the string or numeric result:</p>
 <div class="programlisting">
 <pre>
 <code>    my $authors     = [qw( Pratchett Vinge Conway )];
 <code>    my @cats = ( 'Daisy', 'Petunia', 'Tuxedo', 'Jack', 'Brad' );</code>
 </pre></div>
 <div class="sidebar">
-<p>Remember that the parentheses <i>do not</i> create a list. Without parentheses, this would assign <code>Daisy</code> as the first and only element of the array, due to operator precedence (<a href="chapter_04.xhtml#precedence">Precedence</a>(precedence)).</p>
+<p>Remember that the parentheses <i>do not</i> create a list. Without parentheses, this would assign <code>Daisy</code> as the first and only element of the array, due to operator precedence (<a href="chapter_04.html#precedence">Precedence</a>(precedence)).</p>
 </div>
 <p>Any expression which produces a list in list context can assign to an array:</p>
 <div class="programlisting">
 <pre>
 <code>    Scalar value @cats[1] better written as $cats[1] at...</code>
 </pre></div>
-<p>An array slice imposes list context (<a href="chapter_01.xhtml#context_philosophy">Context</a>(context_philosophy)) on the expression used as its index:</p>
+<p>An array slice imposes list context (<a href="chapter_01.html#context_philosophy">Context</a>(context_philosophy)) on the expression used as its index:</p>
 <div class="programlisting">
 <pre>
 <code>    # function called in list context
 </div>
 <div id="isplice_0"></div>
 <p><code>splice</code> is another important--if less frequently used--array operator. It removes and replaces elements from an array given an offset, a length of a list slice, and replacements. Both replacing and removing are optional; you may omit either behavior. The <code>perlfunc</code> description of <code>splice</code> demonstrates its equivalences with <code>push</code>, <code>pop</code>, <code>shift</code>, and <code>unshift</code>. Note that the other operators are shorter and simpler to read and understand.</p>
-<p>Arrays often contain elements to process in a loop; see <a href="chapter_03.xhtml#looping_directives">Looping Directives</a>(looping_directives) for more detail about Perl 5 control flow and array processing.</p>
+<p>Arrays often contain elements to process in a loop; see <a href="chapter_03.html#looping_directives">Looping Directives</a>(looping_directives) for more detail about Perl 5 control flow and array processing.</p>
 <h4 id="heading_id_46">Arrays and Context</h4>
 <div id="ilist_context__iarrays_0"></div>
 <p>In list context, arrays flatten into lists. If you pass multiple arrays to a normal Perl 5 function, they will flatten into a single list:</p>
     my @array_of_arrays = ( 1 .. 10, ( 11 .. 20, ( 21 .. 30 ) ) );</code>
 </pre></div>
 <p>While some people may initially expect this code to produce an array where the first ten elements are the numbers one through ten and the eleventh element is an array containing the numbers eleven through 20 and an array containing the numbers twenty-one through thirty, this code instead produces an array containing the numbers one through 30, inclusive. Remember that parentheses do not <i>create</i> lists in these circumstances--they only group expressions.</p>
-<p>The solution to this flattening behavior is the same for passing arrays to functions and for creating nested arrays (<a href="chapter_03.xhtml#references">References</a>(references)).</p>
+<p>The solution to this flattening behavior is the same for passing arrays to functions and for creating nested arrays (<a href="chapter_03.html#references">References</a>(references)).</p>
 <h4 id="heading_id_47">Array Interpolation</h4>
 <div id="iarray_interpolation_0"></div>
 <div id="iinterpolation__iarrays_0"></div>
         Annette <b>=&gt;</b> 'French vanilla',
     );</code>
 </pre></div>
-<p>The fat comma operator acts like the regular comma, but it also causes the Perl parser to treat the previous bareword (<a href="chapter_11.xhtml#barewords">Barewords</a>(barewords)) as if it were a quoted word. The <code>strict</code> pragma will not warn about the bare word, and if you have a function with the same name as a hash key, the fat comma will <i>not</i> call the function:</p>
+<p>The fat comma operator acts like the regular comma, but it also causes the Perl parser to treat the previous bareword (<a href="chapter_11.html#barewords">Barewords</a>(barewords)) as if it were a quoted word. The <code>strict</code> pragma will not warn about the bare word, and if you have a function with the same name as a hash key, the fat comma will <i>not</i> call the function:</p>
 <div class="programlisting">
 <pre>
 <code>    sub name { 'Leonardo' }
         return $addresses{<b>+</b>shift};
     }</code>
 </pre></div>
-<p>The unary plus (<a href="chapter_10.xhtml#unary_coercions">Unary Coercions</a>(unary_coercions); <a href="chapter_04.xhtml#numeric_operators">Numeric Operators</a>(numeric_operators)) turns what would be a bareword (<code>shift</code>) subject to autoquoting rules into an expression. As this implies, you can use an arbitrary expression--not only a function call--as the key of a hash:</p>
+<p>The unary plus (<a href="chapter_10.html#unary_coercions">Unary Coercions</a>(unary_coercions); <a href="chapter_04.html#numeric_operators">Numeric Operators</a>(numeric_operators)) turns what would be a bareword (<code>shift</code>) subject to autoquoting rules into an expression. As this implies, you can use an arbitrary expression--not only a function call--as the key of a hash:</p>
 <div class="programlisting">
 <pre>
 <code>    # don't actually <i>do</i> this though
     say "Have Leonardo's address" if exists $addresses{Leonardo};
     say "Have Warnie's address"   if exists $addresses{Warnie};</code>
 </pre></div>
-<p>Using <code>exists</code> instead of accessing the hash key directly avoids two problems. First, it does not check the boolean nature of the hash <i>value</i>; a hash key may exist with a value even if that value evaluates to a boolean false (including <code>undef</code>). Second, with nested data structures, it avoids autovivifying (<a href="chapter_03.xhtml#autovivification">Autovivification</a>(autovivification)) the value.</p>
+<p>Using <code>exists</code> instead of accessing the hash key directly avoids two problems. First, it does not check the boolean nature of the hash <i>value</i>; a hash key may exist with a value even if that value evaluates to a boolean false (including <code>undef</code>). Second, with nested data structures, it avoids autovivifying (<a href="chapter_03.html#autovivification">Autovivification</a>(autovivification)) the value.</p>
 <div id="idefined_0"></div>
 <div id="ioperators__idefined_0"></div>
 <p>The corresponding operator for hash values is <code>defined</code>. If a hash key exists, its value may be <code>undef</code>. Check that with <code>defined</code>:</p>
 </pre></div>
 <p>This lazy orcish maneuver tests for the definedness of the cached value, not its boolean truth. The defined-or assignment operator is new in Perl 5.10.</p>
 <div id="ihashes__inamed_parameters_0"></div>
-<p>Hashes can also collect named parameters passed to functions. If your function takes several arguments, you can use a slurpy hash (<a href="chapter_05.xhtml#parameter_slurping">Slurping</a>(parameter_slurping)) to gather key/value pairs into a single hash:</p>
+<p>Hashes can also collect named parameters passed to functions. If your function takes several arguments, you can use a slurpy hash (<a href="chapter_05.html#parameter_slurping">Slurping</a>(parameter_slurping)) to gather key/value pairs into a single hash:</p>
 <div class="programlisting">
 <pre>
 <code>    sub make_sundae
 <h3 id="heading_id_57">Coercion</h3>
 <div id="coercion"></div>
 <div id="icoercion_0"></div>
-<p>Unlike other languages, where a variable can hold only a particular type of value (a string, a floating-point number, an object), Perl relies on the context of operators to determine how to interpret values (<a href="chapter_01.xhtml#value_contexts">Numeric, String, and Boolean Context</a>(value_contexts)). If you treat a number as a string, Perl will do its best to convert that number into a string (and vice versa). This process is <i>coercion</i>.</p>
+<p>Unlike other languages, where a variable can hold only a particular type of value (a string, a floating-point number, an object), Perl relies on the context of operators to determine how to interpret values (<a href="chapter_01.html#value_contexts">Numeric, String, and Boolean Context</a>(value_contexts)). If you treat a number as a string, Perl will do its best to convert that number into a string (and vice versa). This process is <i>coercion</i>.</p>
 <div id="iDWIM_1"></div>
 <p>By design, Perl attempts to do what you mean (<i>DWIM</i> stands for <i>do what I mean</i>), though you must be specific about your intentions.</p>
 <h4 id="heading_id_58">Boolean Coercion</h4>
 <div id="icoercion__iboolean_0"></div>
 <div id="itruthiness_0"></div>
 <p>Boolean coercion occurs when you test the <i>truthiness</i> of a value <span class="footnote">(footnote: Truthiness is like truthfulness if you squint and say "Yeah, that's true, but....")</span>, such as in a <code>if</code> or <code>while</code> condition. Numeric 0 is false. The undefined value is false. The empty string is false, and so is the string <code>'0'</code>. The strings <code>'0.0'</code> and <code>'0e'</code> are <i>true</i>, however.</p>
-<p>All other values are true, including the idiomatic string <code>'0 but true'</code>. In the case of a scalar with both string and numeric portions (<a href="chapter_03.xhtml#dualvars">Dualvars</a>(dualvars)), Perl 5 prefers to check the string component for boolean truth. <code>'0 but true'</code> does evaluate to zero numerically, but is not the empty string, so it evaluates to true in boolean context.</p>
+<p>All other values are true, including the idiomatic string <code>'0 but true'</code>. In the case of a scalar with both string and numeric portions (<a href="chapter_03.html#dualvars">Dualvars</a>(dualvars)), Perl 5 prefers to check the string component for boolean truth. <code>'0 but true'</code> does evaluate to zero numerically, but is not the empty string, so it evaluates to true in boolean context.</p>
 <h4 id="heading_id_59">String Coercion</h4>
 <div id="icoercion__istring_0"></div>
 <div id="istringify_0"></div>
 <h4 id="heading_id_61">Reference Coercion</h4>
 <div id="icoercion__ireference_0"></div>
 <div id="iautovivification_0"></div>
-<p>In certain circumstances, treating a value as a reference turns that value <i>into</i> a reference. This process of autovivification (<a href="chapter_03.xhtml#autovivification">Autovivification</a>(autovivification)) can be useful for nested data structures. It occurs when you use a dereferencing operation on a non-reference:</p>
+<p>In certain circumstances, treating a value as a reference turns that value <i>into</i> a reference. This process of autovivification (<a href="chapter_03.html#autovivification">Autovivification</a>(autovivification)) can be useful for nested data structures. It occurs when you use a dereferencing operation on a non-reference:</p>
 <div class="programlisting">
 <pre>
 <code>    my %users;
 <div id="ireferences__isubroutines_0"></div>
 <div id="ifunctions__ifirst45class_0"></div>
 <div id="ifirst45class_functions_0"></div>
-<p>Perl 5 supports <i>first-class functions</i>. A function is a data type just as is an array or hash, at least when you use <i>function references</i>. This feature enables many advanced features (<a href="chapter_05.xhtml#closures">Closures</a>(closures)). As with other data types, you may create a function reference by using the reference operator on the name of a function:</p>
+<p>Perl 5 supports <i>first-class functions</i>. A function is a data type just as is an array or hash, at least when you use <i>function references</i>. This feature enables many advanced features (<a href="chapter_05.html#closures">Closures</a>(closures)). As with other data types, you may create a function reference by using the reference operator on the name of a function:</p>
 <div class="programlisting">
 <pre>
 <code>    sub bake_cake { say 'Baking a wonderful cake!' };
 <pre>
 <code>    $bake_something_ref-&gt;( 'cupcakes' );</code>
 </pre></div>
-<p>You may also use function references as methods with objects (<a href="chapter_07.xhtml#moose">Moose</a>(moose)); this is most useful when you've already performed a method lookup:</p>
+<p>You may also use function references as methods with objects (<a href="chapter_07.html#moose">Moose</a>(moose)); this is most useful when you've already performed a method lookup:</p>
 <div class="programlisting">
 <pre>
 <code>    my $clean = $robot_maid-&gt;can( 'cleanup' );
 <div id="ireferences__icounts_0"></div>
 <p>Perl 5 uses a memory management technique known as <i>reference counting</i>. Every value in the program has an attached counter. Perl increases this counter every time something takes a reference to the value, whether implicitly or explicitly. Perl decreases that counter every time a reference goes away. When the counter reaches zero, Perl can safely recycle that value.</p>
 <p>Within the inner block in the example, there's one <code>$fh</code>. (Multiple lines in the source code refer to it, but there's only one <i>reference</i> to it; <code>$fh</code> itself.) <code>$fh</code> is only in scope in the block and does not get assigned to anything outside of the block, so when the block ends, its reference count reaches zero. The recycling of <code>$fh</code> calls an implicit <code>close()</code> method on the filehandle, and so the file gets closed.</p>
-<p>You don't have to understand the details of how all of this works. You only need to understand that your actions in taking references and passing them around affect how Perl manages memory. (Though see <a href="chapter_03.xhtml#circular_references">Circular References</a>(circular_references) for one caveat.)</p>
+<p>You don't have to understand the details of how all of this works. You only need to understand that your actions in taking references and passing them around affect how Perl manages memory. (Though see <a href="chapter_03.html#circular_references">Circular References</a>(circular_references) for one caveat.)</p>
 <h3 id="heading_id_73">Nested Data Structures</h3>
 <div id="nested_data_structures"></div>
 <div id="idata_structures_0"></div>
 <div id="inested_data_structures_0"></div>
-<p>Perl's aggregate data types--arrays and hashes--allow you to store scalars indexed by integers or string keys. Perl 5's references (<a href="chapter_03.xhtml#references">References</a>(references)) allow you to access aggregate data types indirectly, through special scalars. Nested data structures in Perl, such as an array of arrays or a hash of hashes, are possible through the use of references.</p>
+<p>Perl's aggregate data types--arrays and hashes--allow you to store scalars indexed by integers or string keys. Perl 5's references (<a href="chapter_03.html#references">References</a>(references)) allow you to access aggregate data types indirectly, through special scalars. Nested data structures in Perl, such as an array of arrays or a hash of hashes, are possible through the use of references.</p>
 <h4 id="heading_id_74">Declaring Nested Data Structures</h4>
 <p>A simple declaration of an array of arrays might be:</p>
 <div class="programlisting">
 </pre></div>
 <div id="iautovivification_2"></div>
 <p>This behavior is <i>autovivification</i>, and it's more often useful than it isn't. Its benefit is in reducing the initialization code of nested data structures. Its drawback is in its inability to distinguish between the honest intent to create missing elements in nested data structures and typos.</p>
-<p>The <code>autovivification</code> pragma on the CPAN (<a href="chapter_09.xhtml#pragmas">Pragmas</a>(pragmas)) lets you disable autovivification in a lexical scope for specific types of operations; it's worth your time to consider this in large projects, or projects with multiple developers.</p>
+<p>The <code>autovivification</code> pragma on the CPAN (<a href="chapter_09.html#pragmas">Pragmas</a>(pragmas)) lets you disable autovivification in a lexical scope for specific types of operations; it's worth your time to consider this in large projects, or projects with multiple developers.</p>
 <div class="sidebar">
 <p>You can also check for the existence of specific hash keys and the number of elements in arrays before dereferencing each level of a complex data structure, but that can produce tedious, lengthy code which many programmers prefer to avoid.</p>
 <p>You may wonder at the contradiction between taking advantage of autovivification while enabling <code>strictures</code>. The question is one of balance. is it more convenient to catch errors which change the behavior of your program at the expense of disabling those error checks for a few well-encapsulated symbolic references? Is it more convenient to allow data structures to grow rather than specifying their size and allowed keys?</p>
 <div id="imemory_management__icircular_references_0"></div>
 <div id="imemory_management_0"></div>
 <div id="igarbage_collection_0"></div>
-<p>Perl 5's memory management system of reference counting (<a href="chapter_03.xhtml#reference_counts">Reference Counts</a>(reference_counts)) has one drawback apparent to user code. Two references which end up pointing to each other form a <i>circular reference</i> that Perl cannot destroy on its own. Consider a biological model, where each entity has two parents and can have children:</p>
+<p>Perl 5's memory management system of reference counting (<a href="chapter_03.html#reference_counts">Reference Counts</a>(reference_counts)) has one drawback apparent to user code. Two references which end up pointing to each other form a <i>circular reference</i> that Perl cannot destroy on its own. Consider a biological model, where each entity has two parents and can have children:</p>
 <div class="programlisting">
 <pre>
 <code>    my $alice  = { mother =&gt; '',     father =&gt; '',      children =&gt; [] };
 </pre></div>
 <p>With this accomplished, <code>$cianne</code> will retain references to <code>$alice</code> and <code>$robert</code>, but those references will not by themselves prevent Perl's garbage collector from destroying those data structures. You rarely have to use weak references if you design your data structures correctly, but they're useful in a few situations.</p>
 <h4 id="heading_id_79">Alternatives to Nested Data Structures</h4>
-<p>While Perl is content to process data structures nested as deeply as you can imagine, the human cost of understanding these data structures as well as the relationship of various pieces, not to mention the syntax required to access various portions, can be high. Beyond two or three levels of nesting, consider whether modeling various components of your system with classes and objects (<a href="chapter_07.xhtml#moose">Moose</a>(moose)) will allow you to operate on your data within encapsulation boundaries.</p>
+<p>While Perl is content to process data structures nested as deeply as you can imagine, the human cost of understanding these data structures as well as the relationship of various pieces, not to mention the syntax required to access various portions, can be high. Beyond two or three levels of nesting, consider whether modeling various components of your system with classes and objects (<a href="chapter_07.html#moose">Moose</a>(moose)) will allow you to operate on your data within encapsulation boundaries.</p>
 <p>Sometimes bundling data with behaviors appropriate to that data can clarify code.</p>
 </body>
 </html>

src/tutorials/modern-perl/xhtml/chapter_04.html

 <div id="precedence"></div>
 <div id="iprecedence_0"></div>
 <p>The <i>precedence</i> of an operator helps determine when Perl should evaluate it in an expression. Evaluation order proceeds from highest to lowest precedence. For example, because the precedence of multiplication is higher than the precedence of addition, <code>7 + 7 * 10</code> evaluates to <code>77</code>, not <code>140</code>. You may force the evaluation of some operators before others by grouping their subexpressions in parentheses; <code>(7 + 7) * 10</code> <i>does</i> evaluate to <code>140</code>, as the addition operation becomes a single unit which must evaluate fully before multiplication can occur.</p>
-<p>In case of a tie--where two operators have the same precedence--other factors (<a href="chapter_04.xhtml#fixity">Fixity</a>(fixity) and <a href="chapter_04.xhtml#associativity">Associativity</a>(associativity)) break the tie.</p>
+<p>In case of a tie--where two operators have the same precedence--other factors (<a href="chapter_04.html#fixity">Fixity</a>(fixity) and <a href="chapter_04.html#associativity">Associativity</a>(associativity)) break the tie.</p>
 <p><code>perldoc perlop</code> contains a table of precedence. Almost no one has this table memorized. The best way to manage precedence is to keep your expressions simple. The second best way is to use parentheses to clarify precedence in complex expressions. If you find yourself drowning in a sea of parentheses, see the first rule again.</p>
 <h4 id="heading_id_5">Associativity</h4>
 <div id="associativity"></div>
 <code>    # probably buggy code
     say ( 1 + 2 + 3 ) * 4;</code>
 </pre></div>
-<p>... as Perl 5 happily interprets the parentheses as postcircumfix (<a href="chapter_04.xhtml#fixity">Fixity</a>(fixity)) operators denoting the arguments to <code>say</code>, not circumfix parentheses grouping an expression to change precedence. In other words, the code prints the value <code>6</code> and evaluates to the return value of <code>say</code> multiplied by <code>4</code>.</p>
+<p>... as Perl 5 happily interprets the parentheses as postcircumfix (<a href="chapter_04.html#fixity">Fixity</a>(fixity)) operators denoting the arguments to <code>say</code>, not circumfix parentheses grouping an expression to change precedence. In other words, the code prints the value <code>6</code> and evaluates to the return value of <code>say</code> multiplied by <code>4</code>.</p>
 <h4 id="heading_id_7">Fixity</h4>
 <div id="fixity"></div>
 <div id="ifixity_0"></div>
 <p>The <i>fixity</i> of an operator is its position relative to its operands. The mathematic operators tend to be <i>infix</i> operators, where they appear between their operands. Other operators are <i>prefix</i>, where they appear before their operands; these tend to be unary operators, such as the prefix increment operator <code>++$x</code> or the mathematical and boolean negation operators (<code>-$x</code> and <code>!$x</code>, respectively). <i>Postfix</i> operators appear after their operands (such as postfix increment <code>$x++</code>). <i>Circumfix</i> operators surround their operands, such as the anonymous hash and anonymous array creation operators or quoting operators (<code>{ ... }</code> and <code>[ ... ]</code> or <code>qq{ ... }</code>, for example). <i>Postcircumfix</i> operators surround some operands but follow others, as in the case of array or hash indices (<code>$hash{ ... }</code> and <code>$array[ ... ]</code>, for example).</p>
 <h3 id="heading_id_8">Operator Types</h3>
 <div id="operator_types"></div>
-<p>Perl's pervasive contexts--especially value contexts (<a href="chapter_01.xhtml#value_contexts">Numeric, String, and Boolean Context</a>(value_contexts))--extend to the behavior of its operators. Perl operators provide value contexts to their operands. Choosing the most appropriate operator for a given situation requires you to understand what type of value you expect to receive as well as the type of values on which you wish to operate.</p>
+<p>Perl's pervasive contexts--especially value contexts (<a href="chapter_01.html#value_contexts">Numeric, String, and Boolean Context</a>(value_contexts))--extend to the behavior of its operators. Perl operators provide value contexts to their operands. Choosing the most appropriate operator for a given situation requires you to understand what type of value you expect to receive as well as the type of values on which you wish to operate.</p>
 <h4 id="heading_id_9">Numeric Operators</h4>
 <div id="numeric_operators"></div>
 <div id="ioperators__inumeric_0"></div>
 <div id="ioperators__i4545_0"></div>
 <div id="i4545_0"></div>
 <p>The numeric operators enforce numeric contexts on their operands. They consist of the standard arithmetic operators such as addition (<code>+</code>), subtraction (<code>-</code>), multiplication (<code>*</code>), division (<code>/</code>), exponentiation (<code>**</code>), modulo (<code>%</code>), their in-place variants (<code>+=</code>, <code>-=</code>, <code>*=</code>, <code>/=</code>, <code>**=</code>, and <code>%=</code>), and auto-decrement (<code>--</code>), whether postfix or prefix.</p>
-<p>While the auto-increment operator may seem like a numeric operator, it has special string behavior (<a href="chapter_04.xhtml#auto_increment_operator">Special Operators</a>(auto_increment_operator)).</p>
+<p>While the auto-increment operator may seem like a numeric operator, it has special string behavior (<a href="chapter_04.html#auto_increment_operator">Special Operators</a>(auto_increment_operator)).</p>
 <div id="ioperators__i6161_0"></div>
 <div id="i6161_0"></div>
 <div id="ioperators__i3361_0"></div>
 <div id="ioperators__iauto45increment_0"></div>
 <div id="iauto45increment_0"></div>
 <div id="ioperators__i4343_0"></div>
-<p>The auto-increment operator has a special case. If anything has ever used a variable in a numeric context (<a href="chapter_03.xhtml#cached_coercions">Cached Coercions</a>(cached_coercions)), it increments the numeric value of that variable. If the variable is obviously a string (and has never been evaluated in a numeric context), the string value increments with a carry, such that <code>a</code> increments to <code>b</code>, <code>zz</code> to <code>aaa</code>, and <code>a9</code> to <code>b0</code>.</p>
+<p>The auto-increment operator has a special case. If anything has ever used a variable in a numeric context (<a href="chapter_03.html#cached_coercions">Cached Coercions</a>(cached_coercions)), it increments the numeric value of that variable. If the variable is obviously a string (and has never been evaluated in a numeric context), the string value increments with a carry, such that <code>a</code> increments to <code>b</code>, <code>zz</code> to <code>aaa</code>, and <code>a9</code> to <code>b0</code>.</p>
 <div class="programlisting">
 <pre>
 <code>    my $num = 1;

src/tutorials/modern-perl/xhtml/chapter_05.html

 <code>    sub greet_sun;</code>
 </pre></div>
 <div class="sidebar">
-<p>You do not have to declare Perl 5 functions before you use them, except in the special case where they modify <i>how</i> the parser parses them. See <a href="chapter_05.xhtml#attributes">Attributes</a>(attributes).</p>
+<p>You do not have to declare Perl 5 functions before you use them, except in the special case where they modify <i>how</i> the parser parses them. See <a href="chapter_05.html#attributes">Attributes</a>(attributes).</p>
 </div>
 <h3 id="heading_id_4">Invoking Functions</h3>
 <div id="isubroutines__iinvoking_0"></div>
     greet_me( @authors );
     greet_me( %editors );</code>
 </pre></div>
-<p>... though see the <a href="chapter_03.xhtml#references">References</a>(references) section for more details.</p>
+<p>... though see the <a href="chapter_03.html#references">References</a>(references) section for more details.</p>
 <h3 id="heading_id_5">Function Parameters</h3>
 <div id="function_parameters"></div>
 <div id="iparameters_0"></div>
         ...
     }</code>
 </pre></div>
-<p>... at the expense of some clarity. The same principle applies when assigning to an array as a parameter, of course. See <a href="chapter_03.xhtml#references">References</a>(references) for ways to avoid flattening and slurping when passing aggregate parameters.</p>
+<p>... at the expense of some clarity. The same principle applies when assigning to an array as a parameter, of course. See <a href="chapter_03.html#references">References</a>(references) for ways to avoid flattening and slurping when passing aggregate parameters.</p>
 <h4 id="heading_id_8">Aliasing</h4>
 <div id="iparameter_aliasing_0"></div>
 <div id="ifunctions__ialiasing_parameters_0"></div>
 
     Extensions::Math::add( $scalar, $vector );</code>
 </pre></div>
-<p>Functions in namespaces are <i>visible</i> outside of those namespaces in the sense that you can refer to them directly, but they are only <i>callable</i> by their short names from within the namespace in which they are declared--unless you have somehow made them available to the current namespace through the processes of importing and exporting (<a href="chapter_09.xhtml#exporting">Exporting</a>(exporting)).</p>
+<p>Functions in namespaces are <i>visible</i> outside of those namespaces in the sense that you can refer to them directly, but they are only <i>callable</i> by their short names from within the namespace in which they are declared--unless you have somehow made them available to the current namespace through the processes of importing and exporting (<a href="chapter_09.html#exporting">Exporting</a>(exporting)).</p>
 <h4 id="heading_id_10">Importing</h4>
 <div id="importing"></div>
 <div id="ifunctions__iimporting_0"></div>
-<p>When loading a module with the <code>use</code> keyword (<a href="chapter_09.xhtml#modules">Modules</a>(modules)), Perl automatically calls a method named <code>import()</code> on the provided package name. Modules with procedural interfaces can provide their own <code>import()</code> which makes some or all defined symbols available in the calling package's namespace. Any arguments after the name of the module in the <code>use</code> statement get passed to the module's <code>import()</code> method. Thus:</p>
+<p>When loading a module with the <code>use</code> keyword (<a href="chapter_09.html#modules">Modules</a>(modules)), Perl automatically calls a method named <code>import()</code> on the provided package name. Modules with procedural interfaces can provide their own <code>import()</code> which makes some or all defined symbols available in the calling package's namespace. Any arguments after the name of the module in the <code>use</code> statement get passed to the module's <code>import()</code> method. Thus:</p>
 <div class="programlisting">
 <pre>
 <code>    use strict;</code>
     }</code>
 </pre></div>
 <h4 id="heading_id_12">Validating Arguments</h4>
-<p>Defensive programming often benefits from checking types and values of arguments for appropriateness before performing further processing. By default, Perl 5 provides few built-in mechanisms for doing so (and don't expect <a href="chapter_11.xhtml#prototypes">Prototypes</a>(prototypes) to help). You can check that the <i>number</i> of parameters passed to a function is correct by evaluating <code>@_</code> in scalar context:</p>
+<p>Defensive programming often benefits from checking types and values of arguments for appropriateness before performing further processing. By default, Perl 5 provides few built-in mechanisms for doing so (and don't expect <a href="chapter_11.html#prototypes">Prototypes</a>(prototypes) to help). You can check that the <i>number</i> of parameters passed to a function is correct by evaluating <code>@_</code> in scalar context:</p>
 <div class="programlisting">
 <pre>
 <code>    sub add_numbers
         ...
     }</code>
 </pre></div>
-<p>Type checking is more difficult, because of Perl's operator-oriented type conversions (see <a href="chapter_01.xhtml#context_philosophy">Context</a>(context_philosophy)). In cases where you need more strictness, consider the CPAN module <code>Params::Validate</code>.</p>
+<p>Type checking is more difficult, because of Perl's operator-oriented type conversions (see <a href="chapter_01.html#context_philosophy">Context</a>(context_philosophy)). In cases where you need more strictness, consider the CPAN module <code>Params::Validate</code>.</p>
 <h3 id="heading_id_13">Advanced Functions</h3>
-<p>Functions may seem simple, but you can do much, much more with them (see <a href="chapter_05.xhtml#closures">Closures</a>(closures) and <a href="chapter_05.xhtml#anonymous_functions">Anonymous Functions</a>(anonymous_functions) for more details).</p>
+<p>Functions may seem simple, but you can do much, much more with them (see <a href="chapter_05.html#closures">Closures</a>(closures) and <a href="chapter_05.html#anonymous_functions">Anonymous Functions</a>(anonymous_functions) for more details).</p>
 <h4 id="heading_id_14">Recursion</h4>
 <div id="recursion"></div>
 <div id="irecursion_0"></div>
 <h3 id="heading_id_17">Pitfalls and Misfeatures</h3>
 <div id="ifunctions__ipitfalls_0"></div>
 <div id="ifunctions__imisfeatures_0"></div>
-<p>Not all features of Perl 5 functions are always helpful. In particular, <a href="chapter_11.xhtml#prototypes">Prototypes</a>(prototypes) rarely do what you mean. They have their uses, but you can avoid them outside of a few cases.</p>
+<p>Not all features of Perl 5 functions are always helpful. In particular, <a href="chapter_11.html#prototypes">Prototypes</a>(prototypes) rarely do what you mean. They have their uses, but you can avoid them outside of a few cases.</p>
 <div class="editor">
 <p>Check the timeline, but I'm pretty sure about this.</p>
 </div>
     say;</code>
 </pre></div>
 <p>... despite assignment to <code>$_</code> inside the block. You may explicitly lexicalize the topic yourself, though this is more useful when considering dynamic scope.</p>
-<p>Finally, lexical scoping facilitates closures (see <a href="chapter_05.xhtml#closures">Closures</a>(closures)). Beware creating closures accidentally.</p>
+<p>Finally, lexical scoping facilitates closures (see <a href="chapter_05.html#closures">Closures</a>(closures)). Beware creating closures accidentally.</p>
 <h5 id="heading_id_20">Our Scope</h5>
 <div id="our"></div>
 <div id="iour_1"></div>
 <div id="anonymous_functions"></div>
 <div id="ianonymous_function_0"></div>
 <div id="ifunctions__ianonymous_0"></div>
-<p>An <i>anonymous function</i> is a function without a name. It behaves like a named function--you can invoke it, pass arguments to it, return values from it, copy references to it--it can do anything a named function can do. The difference is that it has no name. You always deal with anonymous functions by reference (see <a href="chapter_03.xhtml#references">References</a>(references) and <a href="chapter_03.xhtml#function_references">Function References</a>(function_references)).</p>
+<p>An <i>anonymous function</i> is a function without a name. It behaves like a named function--you can invoke it, pass arguments to it, return values from it, copy references to it--it can do anything a named function can do. The difference is that it has no name. You always deal with anonymous functions by reference (see <a href="chapter_03.html#references">References</a>(references) and <a href="chapter_03.html#function_references">Function References</a>(function_references)).</p>
 <h4 id="heading_id_24">Declaring Anonymous Functions</h4>
 <p>You may never declare an anonymous function on its own; you must construct it and assign it to a variable, invoke it immediately, or pass it as an argument to a function, either explicitly or implicitly. Explicit creation uses the <code>sub</code> keyword with no name:</p>
 <div class="programlisting">
 <p>Note that both references refer to the same underlying anonymous function. Calling <code>subname()</code> on <code>$anon</code> and returning into <code>$named</code> modifies that function, so any other reference to this function will see the same moniker.</p>
 <h4 id="heading_id_26">Implicit Anonymous Functions</h4>
 <div id="ianonymous_functions__iimplicit_0"></div>
-<p>All of these anonymous function declarations have been explicit. Perl 5 allows implicit anonymous functions through the use of prototypes (<a href="chapter_11.xhtml#prototypes">Prototypes</a>(prototypes)). Though this feature exists nominally to enable programmers to write their own syntax such as that for <code>map</code> and <code>eval</code>, an interesting example is the use of <i>delayed</i> functions that don't look like functions. Consider the CPAN module <code>Test::Exception</code>:</p>
+<p>All of these anonymous function declarations have been explicit. Perl 5 allows implicit anonymous functions through the use of prototypes (<a href="chapter_11.html#prototypes">Prototypes</a>(prototypes)). Though this feature exists nominally to enable programmers to write their own syntax such as that for <code>map</code> and <code>eval</code>, an interesting example is the use of <i>delayed</i> functions that don't look like functions. Consider the CPAN module <code>Test::Exception</code>:</p>
 <div class="programlisting">
 <pre>
 <code>    use Test::More tests =&gt; 2;
 <p>This feature is occasionally useful despite its drawbacks. The syntactic clarity available by promoting bare blocks to anonymous functions can be helpful, but use it sparingly and document the API with care.</p>
 <h3 id="heading_id_27">Closures</h3>
 <div id="closures"></div>
-<p>You've seen how functions work (<a href="chapter_05.xhtml#functions">Functions</a>(functions)). You understand how scope works (<a href="chapter_05.xhtml#scope">Scope</a>(scope)). You know that every time control flow enters a function, that function gets a new environment representing that invocation's lexical scope. You can work with function references (<a href="chapter_03.xhtml#references">References</a>(references)) and anonymous functions (<a href="chapter_05.xhtml#anonymous_functions">Anonymous Functions</a>(anonymous_functions)).</p>
+<p>You've seen how functions work (<a href="chapter_05.html#functions">Functions</a>(functions)). You understand how scope works (<a href="chapter_05.html#scope">Scope</a>(scope)). You know that every time control flow enters a function, that function gets a new environment representing that invocation's lexical scope. You can work with function references (<a href="chapter_03.html#references">References</a>(references)) and anonymous functions (<a href="chapter_05.html#anonymous_functions">Anonymous Functions</a>(anonymous_functions)).</p>
 <p>You know everything you need to know to understand closures.</p>
 <div class="sidebar">
 <p>Mark Jason Dominus's <i>Higher Order Perl</i> is the canonical reference on first-class functions, closures, and the amazing things you can do with them. You can read it online at <span class="url">http://hop.perl.plover.com/</span>.</p>
 
     say $cousins-&gt;() for 1 .. 5;</code>
 </pre></div>
-<p>Even though <code>make_iterator()</code> has returned, the anonymous function still refers to the lexical variables <code>@items</code> and <code>$count</code>. Their values persist (<a href="chapter_03.xhtml#reference_counts">Reference Counts</a>(reference_counts)). The anonymous function, stored in <code>$cousins</code>, has closed over these values in the specific lexical environment of the specific invocation of <code>make_iterator()</code>.</p>
+<p>Even though <code>make_iterator()</code> has returned, the anonymous function still refers to the lexical variables <code>@items</code> and <code>$count</code>. Their values persist (<a href="chapter_03.html#reference_counts">Reference Counts</a>(reference_counts)). The anonymous function, stored in <code>$cousins</code>, has closed over these values in the specific lexical environment of the specific invocation of <code>make_iterator()</code>.</p>
 <p>It's easy to demonstrate that the lexical environment is independent between calls to <code>make_iterator()</code>:</p>
 <div class="programlisting">
 <pre>
 <p>Now instead of calling <code>make_sundae()</code>, you can invoke <code>$make_cart_sundae-&gt;()</code> and pass only the interesting arguments, without worrying about forgetting the invariants or passing them incorrectly <span class="footnote">(footnote: You can even use <code>Sub::Install</code> from the CPAN to install this function into your namespace directly.)</span>.</p>
 <h3 id="heading_id_31">State versus Closures</h3>
 <div id="state"></div>
-<p>Closures (<a href="chapter_05.xhtml#closures">Closures</a>(closures)) are an easy, effective, and safe way to make data persist between function invocations without using global variables. If you need to share variables between named functions, you can introduce a new scope (<a href="chapter_05.xhtml#scope">Scope</a>(scope)) for only those function declarations:</p>
+<p>Closures (<a href="chapter_05.html#closures">Closures</a>(closures)) are an easy, effective, and safe way to make data persist between function invocations without using global variables. If you need to share variables between named functions, you can introduce a new scope (<a href="chapter_05.html#scope">Scope</a>(scope)) for only those function declarations:</p>
 <div class="programlisting">
 <pre>
 <code>    {
 </div>
 <h3 id="heading_id_32">Attributes</h3>
 <div id="attributes"></div>
-<p>Named entities in Perl--variables and functions--can have additional metadata attached to them in the form of <i>attributes</i>. Attributes are names (and, often, values) which allow certain types of metaprogramming (<a href="chapter_09.xhtml#code_generation">Code Generation</a>(code_generation)).</p>
+<p>Named entities in Perl--variables and functions--can have additional metadata attached to them in the form of <i>attributes</i>. Attributes are names (and, often, values) which allow certain types of metaprogramming (<a href="chapter_09.html#code_generation">Code Generation</a>(code_generation)).</p>
 <div class="sidebar">
 <p>Declaring attributes can be awkward, and using them effectively is more art than science. They're relatively rare in most programs for good reason, though they <i>can</i> offer compelling benefits of maintenance and clarity.</p>
 </div>
 
     sub shutdown_tests :Test(teardown) { ... }</code>
 </pre></div>
-<p>The <code>Test</code> attribute identifies methods which include test assertions, and optionally identifies the number of assertions the method intends to run. While introspection (<a href="chapter_07.xhtml#reflection">Reflection</a>(reflection)) of these classes could discover the appropriate test methods, given well-designed solid heuristics, the <code>:Test</code> attribute makes the code and its intent unambiguous.</p>
+<p>The <code>Test</code> attribute identifies methods which include test assertions, and optionally identifies the number of assertions the method intends to run. While introspection (<a href="chapter_07.html#reflection">Reflection</a>(reflection)) of these classes could discover the appropriate test methods, given well-designed solid heuristics, the <code>:Test</code> attribute makes the code and its intent unambiguous.</p>
 <p>The <code>setup</code> and <code>teardown</code> parameters allow test classes to define their own support methods without worrying about name clashes or other conflicts due to inheritance or other class design concerns. You <i>could</i> enforce a design where all test classes must override methods named <code>setup()</code> and <code>teardown()</code> themselves, but the attribute approach gives more flexibility of implementation.</p>
 <div class="sidebar">
 <p>The Catalyst web framework also uses attributes to determine the visibility and behavior of methods within web applications.</p>
         say "In AUTOLOAD(@_) <b>for $AUTOLOAD</b>!"
     }</code>
 </pre></div>
-<p>The <code>our</code> declaration (<a href="chapter_05.xhtml#our">Our Scope</a>(our)) scopes this variable to the body of <code>AUTOLOAD()</code>. The variable contains the fully-qualified name of the undefined function. In this case, the function is <code>main::bake_pie</code>. A common idiom is to remove the package name:</p>
+<p>The <code>our</code> declaration (<a href="chapter_05.html#our">Our Scope</a>(our)) scopes this variable to the body of <code>AUTOLOAD()</code>. The variable contains the fully-qualified name of the undefined function. In this case, the function is <code>main::bake_pie</code>. A common idiom is to remove the package name:</p>
 <div class="programlisting">
 <pre>
 <code>    sub AUTOLOAD
         return $method-&gt;( @_ );
     }</code>
 </pre></div>
-<p>The body of the previous <code>AUTOLOAD()</code> has become an anonymous function. The code creates a closure (<a href="chapter_05.xhtml#closures">Closures</a>(closures)) bound over the <i>name</i> of the undefined method. Then it installs that closure in the appropriate symbol table so that all subsequent dispatch to that method will find the created closure and will avoid <code>AUTOLOAD()</code>. Finally, it invokes the method directly and returns the result.</p>
+<p>The body of the previous <code>AUTOLOAD()</code> has become an anonymous function. The code creates a closure (<a href="chapter_05.html#closures">Closures</a>(closures)) bound over the <i>name</i> of the undefined method. Then it installs that closure in the appropriate symbol table so that all subsequent dispatch to that method will find the created closure and will avoid <code>AUTOLOAD()</code>. Finally, it invokes the method directly and returns the result.</p>
 <p>Though this approach is cleaner and almost always more transparent than handling the behavior directly in <code>AUTOLOAD()</code>, the code <i>called</i> by <code>AUTOLOAD()</code> may detect that dispatch has gone through <code>AUTOLOAD()</code>. In short, <code>caller()</code> will reflect the double-dispatch of both techniques shown so far. This may be an issue; certainly you can argue that it's an encapsulation violation to care, but it's also an encapsulation violation to let the details of <i>how</i> an object provides a method to leak out into the wider world.</p>
 <div id="itailcall_0"></div>
 <div id="igoto__itailcall_0"></div>
-<p>Another idiom is to use a tailcall (<a href="chapter_05.xhtml#tail_calls">Tail Calls</a>(tail_calls)) to <i>replace</i> the current invocation of <code>AUTOLOAD()</code> from <code>caller()</code>'s memory with a call to the destination method:</p>
+<p>Another idiom is to use a tailcall (<a href="chapter_05.html#tail_calls">Tail Calls</a>(tail_calls)) to <i>replace</i> the current invocation of <code>AUTOLOAD()</code> from <code>caller()</code>'s memory with a call to the destination method:</p>
 <div class="programlisting">
 <pre>
 <code>    sub AUTOLOAD

src/tutorials/modern-perl/xhtml/chapter_06.html

 <div id="ioperators__i33126_1"></div>
 <div id="iregular_expressions__iatom_0"></div>
 <div id="iatom_0"></div>
-<p>The match operator (<code>//</code> or, more formally, <code>m//</code>) contains a regular expression--in this example, <code>hat</code>. Even though that reads like a word, it means "the <code>h</code> character, followed by the <code>a</code> character, followed by the <code>t</code> character, appearing anywhere in the string." Each character is an <i>atom</i> in the regex: an indivisible unit of the pattern. The regex binding operator (<code>=~</code>) is an infix operator (<a href="chapter_04.xhtml#fixity">Fixity</a>(fixity)) which applies the regular expression on its right to the string produced by the expression on its left. When evaluated in scalar context, a match evaluates to a true value if it succeeds.</p>
+<p>The match operator (<code>//</code> or, more formally, <code>m//</code>) contains a regular expression--in this example, <code>hat</code>. Even though that reads like a word, it means "the <code>h</code> character, followed by the <code>a</code> character, followed by the <code>t</code> character, appearing anywhere in the string." Each character is an <i>atom</i> in the regex: an indivisible unit of the pattern. The regex binding operator (<code>=~</code>) is an infix operator (<a href="chapter_04.html#fixity">Fixity</a>(fixity)) which applies the regular expression on its right to the string produced by the expression on its left. When evaluated in scalar context, a match evaluates to a true value if it succeeds.</p>
 <p>The negated form of the binding operator (<code>!~</code>) evaluates to a false value if the match succeeds.</p>
 <h3 id="heading_id_4">The qr// Operator and Regex Combinations</h3>
 <div id="ioperators__iqr4747_0"></div>
     }</code>
 </pre></div>
 <div id="iregular_expressions__i_w_0"></div>
-<p>Of course, if your list of potential matches were anything other than a list of words, this metacharacter could cause false positives, as it also matches punctuation characters, whitespace, numbers, and many other characters besides word characters. The <code>\w</code> metacharacter represents all alphanumeric characters (in a Unicode sense -- <a href="chapter_03.xhtml#unicode">Unicode and Strings</a>(unicode)) and the underscore:</p>
+<p>Of course, if your list of potential matches were anything other than a list of words, this metacharacter could cause false positives, as it also matches punctuation characters, whitespace, numbers, and many other characters besides word characters. The <code>\w</code> metacharacter represents all alphanumeric characters (in a Unicode sense -- <a href="chapter_03.html#unicode">Unicode and Strings</a>(unicode)) and the underscore:</p>
 <div class="programlisting">
 <pre>
 <code>        next unless $word =~ <b>/l</b>\w\w</code>m/;

src/tutorials/modern-perl/xhtml/chapter_07.html

 <p>Cannot assign a value to a read-only accessor at ....</p>
 </div>
 <div class="sidebar">
-<p>When should you use <code>ro</code> and when <code>rw</code>? It's a matter of design, convenience, and purity. One school of thought (<a href="chapter_07.xhtml#immutability">Immutability</a>(immutability)) suggests making all instance data <code>ro</code> and passing all relevant data into the constructor. In the <code>Cat</code> example, <code>age()</code> might still be an accessor, but the constructor could take the <i>year</i> of the cat's birth and calculate the age itself based on the current year, rather than relying on someone to update the age of all cats manually.</p>
+<p>When should you use <code>ro</code> and when <code>rw</code>? It's a matter of design, convenience, and purity. One school of thought (<a href="chapter_07.html#immutability">Immutability</a>(immutability)) suggests making all instance data <code>ro</code> and passing all relevant data into the constructor. In the <code>Cat</code> example, <code>age()</code> might still be an accessor, but the constructor could take the <i>year</i> of the cat's birth and calculate the age itself based on the current year, rather than relying on someone to update the age of all cats manually.</p>
 <p>This approach helps to consolidate all validation code and helps to ensure that all created objects have valid data. These are design goals worth considering, though Moose does not enforce any particular philosophy in this area.</p>
 </div>
 <p>Now that individual objects can have their own instance data, the value of object orientation may be more obvious. An object is a bookmark for the data it contains as well as the behavior appropriate to that data. An object is a collection of named data and behaviors. A class is the description of the data and behaviors that instances of that class possess.</p>
 </div>
 <h4 id="heading_id_16">Moose and Perl 5 OO</h4>
 <div id="imoose__iversus_Perl_5_OO_0"></div>
-<p>Moose provides many features you'd otherwise have to build for yourself with the default object orientation of Perl 5. While you <i>can</i> build everything you get with Moose yourself (see <a href="chapter_07.xhtml#blessed_references">Blessed References</a>(blessed_references)), or cobble it together with a series of CPAN distributions, Moose is a coherent package which just works, includes good documentation, is part of many successful projects, and is under active development by an attentive and talented community.</p>
+<p>Moose provides many features you'd otherwise have to build for yourself with the default object orientation of Perl 5. While you <i>can</i> build everything you get with Moose yourself (see <a href="chapter_07.html#blessed_references">Blessed References</a>(blessed_references)), or cobble it together with a series of CPAN distributions, Moose is a coherent package which just works, includes good documentation, is part of many successful projects, and is under active development by an attentive and talented community.</p>
 <div id="imetaprogramming_0"></div>
 <div id="iMoose__iMOP_0"></div>
 <div id="iMoose__imetaprogramming_0"></div>
 <p>You've already seen the first two rules with Moose. The third rule is new. The <code>bless</code> keyword associates the name of a class with a reference, such that any method invocation performed on that reference uses the associated class for resolution. That sounds more complicated than it is.</p>
 <div class="sidebar">
 <p>Though these rules explain Perl 5's underlying object system, they are somewhat more minimal in practice than may be practical, especially for larger projects. In particular, they offer few facilities for metaprogramming (using APIs to manipulate the program itself).</p>
-<p>Moose (<a href="chapter_07.xhtml#moose">Moose</a>(moose)) is a better choice for serious, modern Perl programs larger than a couple of hundred lines, but you will likely encounter bare-bones Perl 5 OO in existing code.</p>
+<p>Moose (<a href="chapter_07.html#moose">Moose</a>(moose)) is a better choice for serious, modern Perl programs larger than a couple of hundred lines, but you will likely encounter bare-bones Perl 5 OO in existing code.</p>
 </div>
 <div id="iconstructor_0"></div>
 <div id="iOO__iconstructor_0"></div>
 <div id="imro_0"></div>
 <div id="ipragmas__imro_0"></div>
 <p>Perl 5.10 added a pragma called <code>mro</code> which allows you to use a different method resolution scheme called C3. While the specific details can get complex in the case of complex multiple inheritance hierarchies, the important difference is that method resolution will visit all children of a parent before visiting the parent.</p>
-<p>While other techniques (such as <a href="chapter_07.xhtml#roles">Roles</a>(roles) and Moose method modifiers) allow you to avoid multiple inheritance, the <code>mro</code> pragma can help avoid surprising behavior with method dispatch. Enable it in your class with:</p>
+<p>While other techniques (such as <a href="chapter_07.html#roles">Roles</a>(roles) and Moose method modifiers) allow you to avoid multiple inheritance, the <code>mro</code> pragma can help avoid surprising behavior with method dispatch. Enable it in your class with:</p>
 <div class="programlisting">
 <pre>
 <code>    package InjuredPlayer;
 <div id="iAUTOLOAD_0"></div>
 <div id="iobjects__iAUTOLOAD_0"></div>
 <div id="imethods__iAUTOLOAD_0"></div>
-<p>If there is no applicable method in the invocant's class or any of its superclasses, Perl 5 will next look for an <code>AUTOLOAD</code> function in every class according to the selected method resolution order. Perl will invoke any <code>AUTOLOAD</code> it finds to provide or decline the desired method. See <a href="chapter_05.xhtml#autoload">AUTOLOAD</a>(autoload) for more details.</p>
+<p>If there is no applicable method in the invocant's class or any of its superclasses, Perl 5 will next look for an <code>AUTOLOAD</code> function in every class according to the selected method resolution order. Perl will invoke any <code>AUTOLOAD</code> it finds to provide or decline the desired method. See <a href="chapter_05.html#autoload">AUTOLOAD</a>(autoload) for more details.</p>
 <p>As you might expect, this can get quite complex in the face of multiple inheritance and multiple potential <code>AUTOLOAD</code> targets.</p>
 <h4 id="heading_id_20">Method Overriding and SUPER</h4>
 <p>You may override methods in the default Perl 5 OO system as well as in Moose. Unfortunately, core Perl 5 provides no mechanism for indicating your <i>intent</i> to override a parent's method. Worse yet, any function you pre-declare, declare, or import into the child class may override a method in the parent class simply by existing and having the same name. While you may forget to use the <code>override</code> system of Moose, you have no such protection (even optional) in the default Perl 5 OO system.</p>
 <p>Beware that this dispatcher relies on the package into which the overridden method was originally compiled when redispatching to a parent method. This is a long-standing misfeature retained for the sake of backwards compatibility. If you export methods into other classes or compose roles into classes manually, you may run afoul of this feature. The <code>SUPER</code> module on the CPAN can work around this for you. Moose handles it nicely as well.</p>
 </div>
 <h4 id="heading_id_21">Strategies for Coping with Blessed References</h4>
-<p>Avoid <code>AUTOLOAD</code> where possible. If you <i>must</i> use it, use forward declarations of your functions (<a href="chapter_05.xhtml#functions">Functions</a>(functions)) to help Perl know which <code>AUTOLOAD</code> will provide the method implementation.</p>
+<p>Avoid <code>AUTOLOAD</code> where possible. If you <i>must</i> use it, use forward declarations of your functions (<a href="chapter_05.html#functions">Functions</a>(functions)) to help Perl know which <code>AUTOLOAD</code> will provide the method implementation.</p>
 <p>Use accessor methods rather than accessing instance data directly through the reference. This applies even within the bodies of methods within the class itself. Generating these yourself can be tedious; if you can't use Moose, consider using a module such as <code>Class::Accessor</code> to avoid repetitive boilerplate.</p>
 <p>Expect that someone, somewhere will eventually need to subclass (or delegate to or reimplement the interface of) your classes. Make it easier for them by not assuming details of the internals of your code, by using the two-argument form of <code>bless</code>, and by breaking your classes into the smallest responsible units of code.</p>
 <p>Do not mix functions and methods in the same class.</p>
 <div id="reflection"></div>
 <div id="ireflection_0"></div>
 <div id="iintrospection_0"></div>
-<p><i>Reflection</i> (or <i>introspection</i>) is the process of asking a program about itself as it runs. Even though you can write many useful programs without ever having to use reflection, techniques such as metaprogramming (<a href="chapter_09.xhtml#code_generation">Code Generation</a>(code_generation)) benefit from a deeper understanding of which entities are in the system.</p>
-<p><code>Class::MOP</code> (<a href="chapter_09.xhtml#class_mop">Class::MOP</a>(class_mop)) simplifies many reflection tasks for object systems, but many useful programs do not use objects pervasively, and many useful programs do not use <code>Class::MOP</code>. Several idioms (<a href="chapter_10.xhtml#idioms">Idioms</a>(idioms)) exist for performing reflection effectively in the absence of such a formal system.</p>
+<p><i>Reflection</i> (or <i>introspection</i>) is the process of asking a program about itself as it runs. Even though you can write many useful programs without ever having to use reflection, techniques such as metaprogramming (<a href="chapter_09.html#code_generation">Code Generation</a>(code_generation)) benefit from a deeper understanding of which entities are in the system.</p>
+<p><code>Class::MOP</code> (<a href="chapter_09.html#class_mop">Class::MOP</a>(class_mop)) simplifies many reflection tasks for object systems, but many useful programs do not use objects pervasively, and many useful programs do not use <code>Class::MOP</code>. Several idioms (<a href="chapter_10.html#idioms">Idioms</a>(idioms)) exist for performing reflection effectively in the absence of such a formal system.</p>
 <h4 id="heading_id_23">Checking that a Package Exists</h4>
 <p>To check that a package exists somewhere in the system--that is, if some code somewhere has executed a <code>package</code> directive with a given name--check that the package inherits from <code>UNIVERSAL</code> by testing that the package can perform the <code>can()</code> method:</p>
 <div class="programlisting">
 </pre></div>
 <p>Nothing prevents other code from manipulating <code>%INC</code> itself. Depending on your paranoia level, you may check the path and the expected contents of the package yourself, but modules with good reasons for manipulating this variable (such as <code>Test::MockObject</code> or <code>Test::MockModule</code>) may do so. Code which manipulates <code>%INC</code> for poor reasons deserves replacing.</p>
 <h4 id="heading_id_26">Checking the Version of a Module</h4>
-<p>There is no guarantee that a given module provides a version. Even so, all modules inherit from <code>UNIVERSAL</code> (<a href="chapter_09.xhtml#universal">The UNIVERSAL Package</a>(universal)), so they all have a <code>VERSION()</code> method available:</p>
+<p>There is no guarantee that a given module provides a version. Even so, all modules inherit from <code>UNIVERSAL</code> (<a href="chapter_09.html#universal">The UNIVERSAL Package</a>(universal)), so they all have a <code>VERSION()</code> method available:</p>
 <div class="programlisting">
 <pre>
 <code>    my $mod_ver = $module-&gt;VERSION();</code>
 <pre>
 <code>    say "$func() exists" if $pkg-&gt;can( $func );</code>
 </pre></div>
-<p>Note that <code>$pkg</code> must be a valid invocant; wrap the method call in an <code>eval</code> block if you have any doubts about its validity. Beware that a function implemented in terms of <code>AUTOLOAD()</code> (<a href="chapter_05.xhtml#autoload">AUTOLOAD</a>(autoload)) may report the wrong answer if the function's package does not also override <code>can()</code> correctly. This is a bug in the other package.</p>
+<p>Note that <code>$pkg</code> must be a valid invocant; wrap the method call in an <code>eval</code> block if you have any doubts about its validity. Beware that a function implemented in terms of <code>AUTOLOAD()</code> (<a href="chapter_05.html#autoload">AUTOLOAD</a>(autoload)) may report the wrong answer if the function's package does not also override <code>can()</code> correctly. This is a bug in the other package.</p>
 <p>You may use this technique to determine if a module's <code>import()</code> has imported a function into the current namespace:</p>
 <div class="programlisting">
 <pre>
 <p>See the "Symbol Tables" section in <code>perldoc perlmod</code> for more details, then prefer the other techniques in this section for reflection.</p>
 <h3 id="heading_id_30">Advanced OO Perl</h3>
 <div id="advanced_oo"></div>
-<p>Creating and using objects in Perl 5 with Moose (<a href="chapter_07.xhtml#moose">Moose</a>(moose)) is easy. <i>Designing</i> good object systems is not. Additional capabilities for abstraction also offer possibilities for obfuscation. Only practical experience can help you understand the most important design techniques... but several principles can guide you.</p>
+<p>Creating and using objects in Perl 5 with Moose (<a href="chapter_07.html#moose">Moose</a>(moose)) is easy. <i>Designing</i> good object systems is not. Additional capabilities for abstraction also offer possibilities for obfuscation. Only practical experience can help you understand the most important design techniques... but several principles can guide you.</p>
 <h4 id="heading_id_31">Favor Composition Over Inheritance</h4>
 <p>Novice OO designs often overuse inheritance. It's common to see class hierarchies which try to model all of the behavior for entities within the system in a single class. This adds a conceptual overhead to understanding the system, because you have to understand the hierarchy, and it adds technical weight to every class, because conflicting responsibilities and methods may get in the way of necessary behaviors or future modifications.</p>
 <p>The encapsulation provided by classes offers better ways to organize code. You don't have to inherit from superclasses to provide behavior to users of objects. A <code>Car</code> object does not have to inherit from a <code>Vehicle::Wheeled</code> object; it can contain several <code>Wheel</code> objects as instance attributes.</p>

src/tutorials/modern-perl/xhtml/chapter_09.html

     truth_values.t (Wstat: 512 Tests: 4 Failed: 2)
       Failed tests:  2-3</code>
 </pre></div>
-<p>That's a lot of output to display what is already obvious: the second and third tests fail because zero and the empty string evaluate to false. It's easy to fix that failure by inverting the sense of the condition with the use of boolean coercion (<a href="chapter_03.xhtml#boolean_coercion">Boolean Coercion</a>(boolean_coercion)):</p>
+<p>That's a lot of output to display what is already obvious: the second and third tests fail because zero and the empty string evaluate to false. It's easy to fix that failure by inverting the sense of the condition with the use of boolean coercion (<a href="chapter_03.html#boolean_coercion">Boolean Coercion</a>(boolean_coercion)):</p>
 <div class="programlisting">
 <pre>
 <code>    ok(   <b>!</b> 0, '... and the number zero should not'  );
 <div id="icmp_ok4041_0"></div>
 <div id="itesting__icmp_ok4041_0"></div>
 <div id="iTest5858More__icmp_ok4041_0"></div>
-<p>Both <code>is()</code> and <code>isnt()</code> perform <i>string comparisons</i> with the Perl 5 operators <code>eq</code> and <code>ne</code>. This almost always does the right thing, but for complex values such as objects with overloading (<a href="chapter_09.xhtml#overloading">Overloading</a>(overloading)) or dual vars (<a href="chapter_03.xhtml#dualvars">Dualvars</a>(dualvars)), you may prefer explicit comparison testing. The <code>cmp_ok()</code> function allows you to specify your own comparison operator:</p>
+<p>Both <code>is()</code> and <code>isnt()</code> perform <i>string comparisons</i> with the Perl 5 operators <code>eq</code> and <code>ne</code>. This almost always does the right thing, but for complex values such as objects with overloading (<a href="chapter_09.html#overloading">Overloading</a>(overloading)) or dual vars (<a href="chapter_03.html#dualvars">Dualvars</a>(dualvars)), you may prefer explicit comparison testing. The <code>cmp_ok()</code> function allows you to specify your own comparison operator:</p>
 <div class="programlisting">
 <pre>
 <code>    cmp_ok(     100, $cur_balance, '&lt;=', 'I should have at least $100' );
 <div id="iisa_ok4041_0"></div>
 <div id="itesting__iisa_ok4041_0"></div>
 <div id="iTest5858More__iisa_ok4041_0"></div>
-<p>Classes and objects provide their own interesting ways to interact with tests. Test that a class or object extends another class (<a href="chapter_07.xhtml#inheritance">Inheritance</a>(inheritance)) with <code>isa_ok()</code>:</p>
+<p>Classes and objects provide their own interesting ways to interact with tests. Test that a class or object extends another class (<a href="chapter_07.html#inheritance">Inheritance</a>(inheritance)) with <code>isa_ok()</code>:</p>
 <div class="programlisting">
 <pre>
 <code>    my $chimpzilla = RobotMonkey-&gt;new();
 <div id="iclose_0"></div>
 <div id="ikeywords__iclose_0"></div>
 <p>When you've finished working with a file, you may <code>close</code> it explicitly or allow its filehandle to go out of scope, in which case Perl will close it for you. The benefit of calling <code>close</code> explicitly is that you can check for--and recover from--specific errors, such as running out of space on a storage device or a broken network connection.</p>
-<p>As usual, <code>autodie</code> (<a href="chapter_12.xhtml#autodie">The autodie Pragma</a>(autodie)) handles these checks for you:</p>
+<p>As usual, <code>autodie</code> (<a href="chapter_12.html#autodie">The autodie Pragma</a>(autodie)) handles these checks for you:</p>
 <div class="programlisting">
 <pre>
 <code>    use autodie;
 <p>For every line read, Perl 5 increments the value of the variable <code>$.</code>, which serves as a line counter.</p>
 <div id="ivariables__i3646_1"></div>
 <div id="i3646_1"></div>
-<p><code>readline</code> uses the current contents of <code>$/</code> as the line-ending sequence (see example in <a href="chapter_05.xhtml#dynamic_scope">Dynamic Scope</a>(dynamic_scope)). The value of this variable defaults to the most appropriate line-ending character sequence for text files on your current platform. In truth, the word <i>line</i> is a misnomer. You can set <code>$/</code> to contain any sequence of characters <span class="footnote">(footnote: ... but never a regular expression, because Perl 5 does not support that.)</span>. This is useful for highly-structured data in which you want to read a <i>record</i> at a time.</p>
+<p><code>readline</code> uses the current contents of <code>$/</code> as the line-ending sequence (see example in <a href="chapter_05.html#dynamic_scope">Dynamic Scope</a>(dynamic_scope)). The value of this variable defaults to the most appropriate line-ending character sequence for text files on your current platform. In truth, the word <i>line</i> is a misnomer. You can set <code>$/</code> to contain any sequence of characters <span class="footnote">(footnote: ... but never a regular expression, because Perl 5 does not support that.)</span>. This is useful for highly-structured data in which you want to read a <i>record</i> at a time.</p>
 <div id="ivariables__i36124_0"></div>
 <div id="i36124_1"></div>
 <div id="ibuffering_0"></div>
 <div id="iexceptions__i3664_0"></div>
 <p><code>die()</code> sets the global variable <code>$@</code> to its argument and immediately exits the current function <i>without returning anything</i>. If the calling function does not explicitly handle this exception, the exception will propagate upwards to every caller until something handles the exception or the program exits with an error message.</p>
 <div class="sidebar">
-<p>This dynamic scoping of exception throwing and handling is the same as the dynamic scoping of <code>local</code> symbols (<a href="chapter_05.xhtml#dynamic_scope">Dynamic Scope</a>(dynamic_scope)).</p>
+<p>This dynamic scoping of exception throwing and handling is the same as the dynamic scoping of <code>local</code> symbols (<a href="chapter_05.html#dynamic_scope">Dynamic Scope</a>(dynamic_scope)).</p>
 </div>
 <h4 id="heading_id_21">Catching Exceptions</h4>
 <div id="catching_exceptions"></div>
 <p>A list header and/or some reordering could help.</p>
 </div>
 <ul>
-<li>Using a disallowed key in a locked hash (<a href="chapter_03.xhtml#locked_hashes">Locking Hashes</a>(locked_hashes))</li>
-<li>Blessing a non-reference (<a href="chapter_07.xhtml#blessed_references">Blessed References</a>(blessed_references))</li>
-<li>Calling a method on an invalid invocant (<a href="chapter_07.xhtml#moose">Moose</a>(moose))</li>
+<li>Using a disallowed key in a locked hash (<a href="chapter_03.html#locked_hashes">Locking Hashes</a>(locked_hashes))</li>
+<li>Blessing a non-reference (<a href="chapter_07.html#blessed_references">Blessed References</a>(blessed_references))</li>
+<li>Calling a method on an invalid invocant (<a href="chapter_07.html#moose">Moose</a>(moose))</li>
 <li>Failing to find a method of the given name on the invocant</li>
-<li>Perl encountered a tainting violation (<a href="chapter_09.xhtml#taint">Taint</a>(taint))</li>
+<li>Perl encountered a tainting violation (<a href="chapter_09.html#taint">Taint</a>(taint))</li>
 <li>Modifying a read-only value</li>
-<li>Performing the wrong operation on the wrong type of reference (<a href="chapter_03.xhtml#references">References</a>(references))</li>
+<li>Performing the wrong operation on the wrong type of reference (<a href="chapter_03.html#references">References</a>(references))</li>
 </ul>
-<p>If you have enabled fatal lexical warnings (<a href="chapter_09.xhtml#registering_warnings">Registering Your Own Warnings</a>(registering_warnings)), you can catch the exceptions they throw. The same goes for exceptions from <code>autodie</code> (<a href="chapter_12.xhtml#autodie">The autodie Pragma</a>(autodie)).</p>
+<p>If you have enabled fatal lexical warnings (<a href="chapter_09.html#registering_warnings">Registering Your Own Warnings</a>(registering_warnings)), you can catch the exceptions they throw. The same goes for exceptions from <code>autodie</code> (<a href="chapter_12.html#autodie">The autodie Pragma</a>(autodie)).</p>
 <h3 id="heading_id_24">Handling Warnings</h3>
 <div id="handling_warnings"></div>
 <p>Perl 5 produces optional warnings for many confusing, unclear, and ambiguous situations. Even though you should almost always enable warnings unconditionally, certain circumstances dictate prudence in disabling certain warnings--and Perl supports this.</p>
 <p>All of <code>-w</code>, <code>-W</code>, and <code>-X</code> affect the value of the global variable <code>$^W</code>. Code written before the <code>warnings</code> pragma (Perl 5.6.0 in spring 2000) may <code>local</code>ize <code>$^W</code> to suppress certain warnings within a given scope. New code should use the pragma instead.</p>
 <h4 id="heading_id_27">Disabling Warning Categories</h4>
 <p>To disable selective warnings within a scope, use <code>no warnings;</code> with an argument list. Omitting the argument list disables all warnings within that scope.</p>
-<p><code>perldoc perllexwarn</code> lists all of the warnings categories your version of Perl 5 understands with the <code>warnings</code> pragma. Most of them represent truly interesting conditions in which Perl may find your program. A few may be unhelpful in specific conditions. For example, the <code>recursion</code> warning will occur if Perl detects that a function has called itself more than a hundred times. If you are confident in your ability to write recursion-ending conditions, you may disable this warning within the scope of the recursion. (Alternately see <a href="chapter_05.xhtml#tail_calls">Tail Calls</a>(tail_calls).)</p>
-<p>If you're generating code (<a href="chapter_09.xhtml#code_generation">Code Generation</a>(code_generation)) or locally redefining symbols, you may wish to disable the <code>redefine</code> warnings.</p>
+<p><code>perldoc perllexwarn</code> lists all of the warnings categories your version of Perl 5 understands with the <code>warnings</code> pragma. Most of them represent truly interesting conditions in which Perl may find your program. A few may be unhelpful in specific conditions. For example, the <code>recursion</code> warning will occur if Perl detects that a function has called itself more than a hundred times. If you are confident in your ability to write recursion-ending conditions, you may disable this warning within the scope of the recursion. (Alternately see <a href="chapter_05.html#tail_calls">Tail Calls</a>(tail_calls).)</p>
+<p>If you're generating code (<a href="chapter_09.html#code_generation">Code Generation</a>(code_generation)) or locally redefining symbols, you may wish to disable the <code>redefine</code> warnings.</p>
 <p>Some experienced Perl hackers disable the <code>uninitialized</code> value warnings in string-processing code which concatenates values from many sources. Careful initialization of variables can avoid the need to disable the warning, but local style and concision may render this warning moot.</p>
 <h4 id="heading_id_28">Making Warnings Fatal</h4>
 <div id="fatal_warnings"></div>
     use CGI ':standard';         # calls CGI-&gt;import( ':standard' )
     use feature qw( say switch ) # calls feature-&gt;import( qw( say switch ) )</code>
 </pre></div>
-<p>You do not have to provide an <code>import()</code> method, and you may use it to do anything you wish, but the standard API expectation is that it takes a list of arguments of symbols (usually functions) to make available in the calling namespace. This is not a strong requirement; pragmas (<a href="chapter_09.xhtml#pragmas">Pragmas</a>(pragmas)) such as <code>strict</code> use arguments to change their behavior instead of exporting symbols.</p>
+<p>You do not have to provide an <code>import()</code> method, and you may use it to do anything you wish, but the standard API expectation is that it takes a list of arguments of symbols (usually functions) to make available in the calling namespace. This is not a strong requirement; pragmas (<a href="chapter_09.html#pragmas">Pragmas</a>(pragmas)) such as <code>strict</code> use arguments to change their behavior instead of exporting symbols.</p>
 <div id="ino_0"></div>
 <div id="iunimporting_0"></div>
 <p>The <code>no</code> keyword calls a module's <code>unimport()</code> method, if it exists, passing any arguments. While it's possible to remove exported symbols, it's more common to disable specific features of pragmas and other modules which introduce new behaviors through <code>import()</code>:</p>
 <p>Even if you do not use an object-oriented approach, modeling every distinct entity or responsibility in your system with its own module keeps related code together and separate code separate.</p>
 <h3 id="heading_id_35">Pragmas</h3>
 <div id="pragmas"></div>
-<p>Perl 5's extension mechanism is modules (<a href="chapter_09.xhtml#modules">Modules</a>(modules)). Most modules provide functions to call or they define classes (<a href="chapter_07.xhtml#moose">Moose</a>(moose)), but some modules instead influence the behavior of the language itself.</p>
+<p>Perl 5's extension mechanism is modules (<a href="chapter_09.html#modules">Modules</a>(modules)). Most modules provide functions to call or they define classes (<a href="chapter_07.html#moose">Moose</a>(moose)), but some modules instead influence the behavior of the language itself.</p>
 <div id="ipragma_0"></div>
 <div id="imodules__ipragmas_0"></div>
 <p>A module which influences the behavior of the compiler is a <i>pragma</i>. By convention, pragmas have lower-case names to differentiate them from other modules. You've heard of some before: <code>strict</code> and <code>warnings</code>, for example.</p>
 <li>the <code>utf8</code> pragma enables the use of the UTF-8 encoding of source code</li>
 <li>the <code>autodie</code> pragma (new in 5.10.1) enables automatic error checking of system calls and keywords, reducing the need for manual error checking</li>
 <li>the <code>constant</code> pragma allows you to create compile-time constant values (though see <code>Readonly</code> from the CPAN for an alternative)</li>
-<li>the <code>vars</code> pragma allows you to declare package global variables, such as <code>$VERSION</code> or those for exporting (<a href="chapter_09.xhtml#exporting">Exporting</a>(exporting)) and manual OO (<a href="chapter_07.xhtml#blessed_references">Blessed References</a>(blessed_references))</li>
+<li>the <code>vars</code> pragma allows you to declare package global variables, such as <code>$VERSION</code> or those for exporting (<a href="chapter_09.html#exporting">Exporting</a>(exporting)) and manual OO (<a href="chapter_07.html#blessed_references">Blessed References</a>(blessed_references))</li>
 </ul>
 <p>Several useful pragmas exist on the CPAN as well. Two worth exploring in detail are <code>autobox</code>, which enables object-like behavior for Perl 5's core types (scalars, references, arrays, and hashes) and <code>perl5i</code>, which combines and enables many experimental language extensions into a coherent whole. These two pragmas may not belong yet in your production code without extensive testing and thoughtful consideration, but they demonstrate the power and utility of pragmas.</p>
 <h4 id="heading_id_39">Your own Pragmas</h4>
 <h3 id="heading_id_40">Distributions</h3>
 <div id="distributions"></div>
 <div id="idistribution_1"></div>
-<p>A <i>distribution</i> is a collection of one or more modules (<a href="chapter_09.xhtml#modules">Modules</a>(modules)) which forms a single redistributable, testable, and installable unit. Effectively it's a collection of module and metadata.</p>
+<p>A <i>distribution</i> is a collection of one or more modules (<a href="chapter_09.html#modules">Modules</a>(modules)) which forms a single redistributable, testable, and installable unit. Effectively it's a collection of module and metadata.</p>
 <p>The easiest way to manage software configuration, building, distribution, testing, and installation even within your organization is to create distributions compatible with the CPAN. The conventions of the CPAN--how to package a distribution, how to resolve its dependencies, where to install software, how to verify that it works, how to display documentation, how to manage a repository--have all arisen from the rough consensus of thousands of contributors working on tens of thousands of projects.</p>
 <p>In particular, the copious amount of testing and reporting and dependency checking achieved by CPAN developers exceeds the available information and quality of work in any other language community. A distribution built to CPAN standards can be tested on several versions of Perl 5 on several different hardware platforms within a few hours of its uploading--all without human intervention.</p>
 <p>You may choose never to release any of your code as public CPAN distributions, but you can reuse existing CPAN tools and designs as possible. The combination of intelligent defaults and customizability are likely to meet your specific needs.</p>
 <li><code>CPANPLUS</code> is an alternate CPAN client with a different design approach. It does some things better than <code>CPAN.pm</code>, but they are largely equivalent at this point. Use whichever you prefer.</li>
 <li><code>Module::Build</code> is a pure-Perl tool suite for configuring, building, installing, and testing distributions. It works with the <i>Build.PL</i> file mentioned earlier.</li>
 <li><code>ExtUtils::MakeMaker</code> is an older, legacy tool which <code>Module::Build</code> intends to replace. It is still in wide use, though it is in maintenance mode and receives only the most critical bugfixes. It works with the <i>Makefile.PL</i> file mentioned earlier.</li>
-<li><code>Test::More</code> (<a href="chapter_09.xhtml#testing">Testing</a>(testing)) is the basic and most widely used testing module used to write automated tests for Perl software.</li>
-<li><code>Test::Harness</code> and <code>prove</code> (<a href="chapter_09.xhtml#running_tests">Running Tests</a>(running_tests)) are the tools used to run tests and to interpret and report their results.</li>
+<li><code>Test::More</code> (<a href="chapter_09.html#testing">Testing</a>(testing)) is the basic and most widely used testing module used to write automated tests for Perl software.</li>
+<li><code>Test::Harness</code> and <code>prove</code> (<a href="chapter_09.html#running_tests">Running Tests</a>(running_tests)) are the tools used to run tests and to interpret and report their results.</li>
 </ul>
 <p>In addition, several non-core CPAN modules make your life easier as a developer:</p>
 <ul>
 <div id="iIO_0"></div>
 <div id="iCODE_0"></div>
 <p>Built-in types are <code>SCALAR</code>, <code>ARRAY</code>, <code>HASH</code>, <code>REGEX</code>, <code>IO</code>, and <code>CODE</code>.</p>
-<p>You can override <code>isa()</code> in your own classes. This can be useful when working with mock objects (see <code>Test::MockObject</code> and <code>Test::MockModule</code> on the CPAN, for example) or with code that does not use roles (<a href="chapter_07.xhtml#roles">Roles</a>(roles)).</p>
+<p>You can override <code>isa()</code> in your own classes. This can be useful when working with mock objects (see <code>Test::MockObject</code> and <code>Test::MockModule</code> on the CPAN, for example) or with code that does not use roles (<a href="chapter_07.html#roles">Roles</a>(roles)).</p>
 <h4 id="heading_id_46">The can() Method</h4>
 <div id="iUNIVERSAL5858can_1"></div>
 <div id="ican4041_1"></div>
-<p>The <code>can()</code> method takes the string containing the name of a method (though see <a href="chapter_11.xhtml#method_sub_equivalence">Method-Function Equivalence</a>(method_sub_equivalence) for a disclaimer). It returns a reference to the function which implements that method, if it exists. Otherwise, it returns false. You may call this on a class, an object, or the name of a package. In the latter case, it returns a reference to a function, not a method.</p>
+<p>The <code>can()</code> method takes the string containing the name of a method (though see <a href="chapter_11.html#method_sub_equivalence">Method-Function Equivalence</a>(method_sub_equivalence) for a disclaimer). It returns a reference to the function which implements that method, if it exists. Otherwise, it returns false. You may call this on a class, an object, or the name of a package. In the latter case, it returns a reference to a function, not a method.</p>
 <p>Given a class named <code>SpiderMonkey</code> with a method named <code>screech</code>, you can get a reference to the method with:</p>
 <div class="programlisting">
 <pre>
         $register-&gt;();
     }</code>
 </pre></div>
-<p>You can (and should) override <code>can()</code> in your own code if you use <code>AUTOLOAD()</code>. See <a href="chapter_05.xhtml#autoload_drawbacks">Drawbacks of AUTOLOAD</a>(autoload_drawbacks) for a longer explanation.</p>
+<p>You can (and should) override <code>can()</code> in your own code if you use <code>AUTOLOAD()</code>. See <a href="chapter_05.html#autoload_drawbacks">Drawbacks of AUTOLOAD</a>(autoload_drawbacks) for a longer explanation.</p>
 <div class="sidebar">
 <p>There is <i>one</i> known case where calling <code>UNIVERSAL::can()</code> as a function and not a method is not incorrect: to determine whether a class exists in Perl 5. If <code>UNIVERSAL::can( $classname, 'can' )</code> returns true, someone somewhere has defined a class of the name <code>$classname</code>. Alternately, <code>Moose</code>'s introspection is much more powerful and easier to use.</p>
 </div>
 <h4 id="heading_id_48">The DOES() Method</h4>
 <div id="iUNIVERSAL5858DOES_0"></div>
 <div id="iDOES4041_1"></div>
-<p>The <code>DOES()</code> method is new in Perl 5.10.0. It exists to support the use of roles (<a href="chapter_07.xhtml#roles">Roles</a>(roles)) in programs. Pass it an invocant and the name of a role, and the method will return true if the appropriate class somehow performs that role. (The class may do so through inheritance, through delegation, through composition, through role application, or any other mechanism.)</p>
+<p>The <code>DOES()</code> method is new in Perl 5.10.0. It exists to support the use of roles (<a href="chapter_07.html#roles">Roles</a>(roles)) in programs. Pass it an invocant and the name of a role, and the method will return true if the appropriate class somehow performs that role. (The class may do so through inheritance, through delegation, through composition, through role application, or any other mechanism.)</p>
 <p>The default implementation of <code>DOES()</code> falls back to <code>isa()</code>, because inheritance is one mechanism by which a class may perform a role. Given a <code>Cappuchin</code>:</p>
 <div class="programlisting">
 <pre>
 <p>Novice programmers write more code than they need to write, partly from unfamiliarity with their languages, libraries, and idioms, but also due to inexperience creating and maintaining good abstractions. They start by writing long lists of procedural code, then discover functions, then parameters, then objects, and--perhaps--higher-order functions and closures.</p>
 <div id="imetaprogramming_1"></div>
 <div id="icode_generation_0"></div>
-<p><i>Metaprogramming</i> (or <i>code generation</i>)--writing programs which write programs--is another abstraction technique. It can be as clear as exploiting higher-order programming capabilities or it can be a rathole down which you find yourself confused and frightened. The techniques are powerful and useful, however--and some of them form the basis of powerful tools such as Moose (<a href="chapter_07.xhtml#moose">Moose</a>(moose)).</p>
-<p>The <code>AUTOLOAD</code> technique (<a href="chapter_05.xhtml#autoload">AUTOLOAD</a>(autoload)) for missing functions and methods demonstrates this technique in a constrained form; Perl 5's function and method dispatch system allows you to customize what happens when normal lookup fails.</p>
+<p><i>Metaprogramming</i> (or <i>code generation</i>)--writing programs which write programs--is another abstraction technique. It can be as clear as exploiting higher-order programming capabilities or it can be a rathole down which you find yourself confused and frightened. The techniques are powerful and useful, however--and some of them form the basis of powerful tools such as Moose (<a href="chapter_07.html#moose">Moose</a>(moose)).</p>
+<p>The <code>AUTOLOAD</code> technique (<a href="chapter_05.html#autoload">AUTOLOAD</a>(autoload)) for missing functions and methods demonstrates this technique in a constrained form; Perl 5's function and method dispatch system allows you to customize what happens when normal lookup fails.</p>
 <h4 id="heading_id_51">eval</h4>
 <div id="ieval_string_0"></div>
 <div id="ioperators__ieval_0"></div>
 <p>Even so, this technique is simple and reasonably easy to understand.</p>
 <h4 id="heading_id_52">Parametric Closures</h4>
 <div id="iclosures__iparametric_0"></div>
-<p>While building accessors and mutators with <code>eval</code> is straightforward, closures (<a href="chapter_05.xhtml#closures">Closures</a>(closures)) allow you to add parameters to generated code at compilation time without requiring additional evaluation:</p>
+<p>While building accessors and mutators with <code>eval</code> is straightforward, closures (<a href="chapter_05.html#closures">Closures</a>(closures)) allow you to add parameters to generated code at compilation time without requiring additional evaluation:</p>
 <div class="programlisting">
 <pre>
 <code>    sub generate_accessors
 <p>... is primarily one of maintainability.</p>
 <div id="iBEGIN__iimplicit_0"></div>
 <div id="imodules__iimplicit_BEGIN_0"></div>
-<p>Within a module, <code>BEGIN</code> concerns tend not to matter because <code>use</code> adds an implicit <code>BEGIN</code> around the <code>require</code> and <code>import</code> (<a href="chapter_05.xhtml#importing">Importing</a>(importing)). Any code outside of a function but inside the module will execute <i>before</i> the <code>import()</code> call occurs. If you <code>require</code> the module, however, there is no implicit <code>BEGIN</code> block. The execution of code outside of functions will happen at the <i>end</i> of parsing.</p>
+<p>Within a module, <code>BEGIN</code> concerns tend not to matter because <code>use</code> adds an implicit <code>BEGIN</code> around the <code>require</code> and <code>import</code> (<a href="chapter_05.html#importing">Importing</a>(importing)). Any code outside of a function but inside the module will execute <i>before</i> the <code>import()</code> call occurs. If you <code>require</code> the module, however, there is no implicit <code>BEGIN</code> block. The execution of code outside of functions will happen at the <i>end</i> of parsing.</p>
 <p>Also beware of the interaction between lexical <i>declaration</i> (the association of a name with a scope) and lexical <i>assignment</i>. The former happens during compilation, while the latter occurs at the point of execution. This code has a subtle bug:</p>
 <div class="programlisting">
 <pre>
 <div id="iobjects__imeta_object_protocol_0"></div>
 <div id="iMOP_1"></div>
 <div id="imeta_object_protocol_0"></div>
-<p>Unlike installing function references to populate namespaces and to create methods, there's no simple built-in way to create classes in Perl 5. Fortunately, a mature and powerful distribution is available from the CPAN to do just this. <code>Clas::MOP</code> is the library which makes <code>Moose</code> (<a href="chapter_07.xhtml#moose">Moose</a>(moose)) possible. It provides a <i>meta object protocol</i>--a mechanism for creating and manipulating an object system in terms of itself.</p>
+<p>Unlike installing function references to populate namespaces and to create methods, there's no simple built-in way to create classes in Perl 5. Fortunately, a mature and powerful distribution is available from the CPAN to do just this. <code>Clas::MOP</code> is the library which makes <code>Moose</code> (<a href="chapter_07.html#moose">Moose</a>(moose)) possible. It provides a <i>meta object protocol</i>--a mechanism for creating and manipulating an object system in terms of itself.</p>
 <p>Rather than writing your own fragile <code>eval</code> string code or trying to poke into symbol tables manually, you can manipulate the entities and abstractions of your program with objects and methods.</p>
 <p>To create a class:</p>
 <div class="programlisting">
 <code>    my @attrs = $class-&gt;get_all_attributes();
     my @meths = $class-&gt;get_all_methods();</code>
 </pre></div>
-<p>You can similarly create and manipulate and introspect attributes and methods with <code>Class::MOP::Attribute</code> and <code>Class::MOP::Method</code>. This metaobject protocol and the flexibility it affords powers Moose (<a href="chapter_07.xhtml#moose">Moose</a>(moose)).</p>
+<p>You can similarly create and manipulate and introspect attributes and methods with <code>Class::MOP::Attribute</code> and <code>Class::MOP::Method</code>. This metaobject protocol and the flexibility it affords powers Moose (<a href="chapter_07.html#moose">Moose</a>(moose)).</p>
 <h3 id="heading_id_55">Overloading</h3>
 <div id="overloading"></div>
 <div id="ioverloading_0"></div>
         'bool' =&gt; sub { 0 },
         <b>'""'   =&gt; sub { '(null)' };</b></code>