1. Chapter 1 Introduction: Becoming a Master

   1. What It Means to Be a Master

   2. Who Should Read This Book

   3. How to Read This Book

   4. What Should You Know Already?

   5. What I Cover

   6. What I Don’t Cover

2. Chapter 2 Advanced Regular Expressions

   1. References to Regular Expressions

   2. Noncapturing Grouping, (?:PATTERN)

   3. Readable Regexes, /x and (?#...)

   4. Global Matching

   5. Lookarounds

   6. Deciphering Regular Expressions

   7. Final Thoughts

   8. Summary

   9. Further Reading

3. Chapter 3 Secure Programming Techniques

   1. Bad Data Can Ruin Your Day

   2. Taint Checking

   3. Untainting Data

   4. List Forms of system and exec

   5. Summary

   6. Further Reading

4. Chapter 4 Debugging Perl

   1. Before You Waste Too Much Time

   2. The Best Debugger in the World

   3. perl5db.pl

   4. Alternative Debuggers

   5. Other Debuggers

   6. Summary

   7. Further Reading

5. Chapter 5 Profiling Perl

   1. Finding the Culprit

   2. The General Approach

   3. Profiling DBI

   4. Devel::DProf

   5. Writing My Own Profiler

   6. Profiling Test Suites

   7. Summary

   8. Further Reading

6. Chapter 6 Benchmarking Perl

   1. Benchmarking Theory

   2. Benchmarking Time

   3. Comparing Code

   4. Don’t Turn Off Your Thinking Cap

   5. Memory Use

   6. The perlbench Tool

   7. Summary

   8. Further Reading

7. Chapter 7 Cleaning Up Perl

   1. Good Style

   2. perltidy

   3. De-Obfuscation

   4. Perl::Critic

   5. Summary

   6. Further Reading

8. Chapter 8 Symbol Tables and Typeglobs

   1. Package and Lexical Variables

   2. The Symbol Table

   3. Summary

   4. Further Reading

9. Chapter 9 Dynamic Subroutines

   1. Subroutines As Data

   2. Creating and Replacing Named Subroutines

   3. Symbolic References

   4. Iterating Through Subroutine Lists

   5. Processing Pipelines

   6. Method Lists

   7. Subroutines As Arguments

   8. Autoloaded Methods

   9. Hashes As Objects

   10. AutoSplit

   11. Summary

   12. Further Reading

10. Chapter 10 Modifying and Jury-Rigging Modules

    1. Choosing the Right Solution

    2. Replacing Module Parts

    3. Subclassing

    4. Wrapping Subroutines

    5. Summary

    6. Further Reading

11. Chapter 11 Configuring Perl Programs

    1. Things Not to Do

    2. Better Ways

    3. Command-Line Switches

    4. Configuration Files

    5. Scripts with a Different Name

    6. Interactive and Noninteractive Programs

    7. perl’s Config

    8. Summary

    9. Further Reading

12. Chapter 12 Detecting and Reporting Errors

    1. Perl Error Basics

    2. Reporting Module Errors

    3. Exceptions

    4. Summary

    5. Further Reading

13. Chapter 13 Logging

    1. Recording Errors and Other Information

    2. Log4perl

    3. Summary

    4. Further Reading

14. Chapter 14 Data Persistence

    1. Flat Files

    2. Storable

    3. DBM Files

    4. Summary

    5. Further Reading

15. Chapter 15 Working with Pod

    1. The Pod Format

    2. Translating Pod

    3. Testing Pod

    4. Summary

    5. Further Reading

16. Chapter 16 Working with Bits

    1. Binary Numbers

    2. Bit Operators

    3. Bit Vectors

    4. The vec Function

    5. Keeping Track of Things

    6. Summary

    7. Further Reading

17. Chapter 17 The Magic of Tied Variables

    1. They Look Like Normal Variables

    2. At the User Level

    3. Behind the Curtain

    4. Scalars

    5. Arrays

    6. Hashes

    7. Filehandles

    8. Summary

    9. Further Reading

18. Chapter 18 Modules As Programs

    1. The main Thing

    2. Backing Up

    3. Who’s Calling?

    4. Testing the Program

    5. Distributing the Programs

    6. Summary

    7. Further Reading

1. Appendix Further Reading

   1. Perl Books

   2. Non-Perl Books

2. Appendix brian’s Guide to Solving Any Perl Problem

   1. My Philosophy of Problem-Solving

   2. My Method

3. Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects.

The animals on the cover of Mastering Perl are a vicuña (Vicugna vicugna) mother and her young. Vicuñas are found in the central Andes Mountains of South America, at altitudes of 4,000 to 5,500 meters. For centuries, the vicuña has been treasured for its coat of soft, insulating hair that produces some of the finest and rarest wool on Earth. Vicuña yarns and fabrics can fetch up to $3,000 per yard.

Vicuñas held a special place among ancient Incan societies. Incans believed that the animal was the reincarnation of a beautiful maiden who had received a coat of gold as a reward for succumbing to the advances of a decrepit and homely king. Every four years, Incans would hold a chacu, a hunt to trap thousands of vicuñas, shear their coats, and release them back to the wild. Incan law forbade the killing of vicuñas, and only members of royalty were allowed to wear garments made from the animal's coat.

Unregulated hunting of vicuñas led to the animal being placed on the endangered species list in 1974. By that time, their number had dwindled to 6,000. However, close regulation, particularly by the government of Peru, has led to the vicuña's resurgence, and today the number is over 120,000. The chacu is now sanctioned and regulated by the Peruvian government, and a portion of the profits is returned to villagers in the Andes.

The cover image is a 19th-century engraving from the Dover Pictorial Archive. The cover font is Adobe ITC Garamond. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont's TheSans Mono Condensed.