The first edition of this book was "Learning Perl Objects, References, and Modules". I never read that previous edition, so I can't comment on how that book stacks up against this new edition. This book is intended to pick up where Learning Perl left off. Its purpose is to show you how to use Perl to write larger more complex programs. As in Learning Perl, each chapter is small enough to read in an hour or so. Each chapter ends with a series of exercises to help you practice what you've just learned, and the answers are in the appendix for your reference. You don't have to know Unix to benefit from this book. Most everything in this book applies equally well to Windows ActivePerl from ActiveState and all other modern implementations of Perl. To use this book effectively, you just need to be familiar with the material in Learning Perl and have the ambition to go further. You should read this book from beginning to end, stopping to do the exercises as you go along. The following is the structure of the book:
Chapter 1, Introduction, just goes over what you should already know and how to use the book.
Chapter 2, Intermediate Foundations, introduces some intermediate-level Perl idioms used throughout the book. These are the things that typically set apart the beginning and intermediate Perl programmers.
Chapter 3, Using Modules, is about the building blocks for Perl programs. They provide reusable subroutines, variables, and even object-oriented classes. It also looks at the basics of using modules that others have already written.
Chapter 4 introduces references, which are the basis for complex data structures, object-oriented programming (OOP), and fancy subroutine magic. They're the magic that was added between Perl version 4 and version 5 to make it all possible. A Perl scalar variable holds a single value. An array holds an ordered list of one or more scalars. A hash holds a collection of scalars as values, keyed by other scalars. Although a scalar can be an arbitrary string, which allows complex data to be encoded into an array or hash, none of the three data types are well suited to complex data interrelationships. This is a job for the reference, which enables a level of redirection that allows the same code to operate on different sets of data.
Chapter 5, References and Scoping shows how to copy and pass around references like any other scalar. At any given time, Perl knows the number of references to a particular data item. Perl can also create references to anonymous data structures and create references automatically as needed to fulfill certain kinds of operations. This chapter look at copying references and how it affects scoping and memory usage.
Chapter 6, Manipulating Complex Data Structures, starts by using the debugger to examine complex data structures and then uses Data::Dumper to show the data under programmatic control. Next, you learn to store and retrieve complex data easily and quickly using Storable, and finally you wrap up with a review of grep and map and see how they apply to complex data.
Chapter 7, Subroutine References shows how to capture behavior as an anonymous subroutine that you create dynamically and execute later. In the same way that taking a reference to an array lets you have the same code work on different arrays at different times, taking a reference to a subroutine allows the same code to call different subroutines at different times. Also, references permit complex data structures. A reference to a subroutine allows a subroutine to effectively become part of that complex data structure
Chapter 8, Filehandle References, stores filehandles in scalar variables that you can easily pass around your program or store in data structures. You've seen arrays, hashes, and subroutines passed around in references, permitting a level of indirection to solve certain types of problems. We can also store filehandles in references to create new solutions to old problems.
Chapter 9, Practical Reference Tricks,looks at optimizing sorting and dealing with recursively defined data.
Chapter 10, Building Larger Programs, looks at how to break up a program into pieces and includes some of the concerns that arise when you put those pieces back together again, or when many people work together on the same program. You learn to build larger programs by separating code into separate files and namespaces.
Chapter 11, Introduction to Objects, shows how to work with classes, method calls, inheritance, and overriding.
Chapter 12, Objects with Data, shows how to add per-instance data, including constructors, getters, and setters.
Chapter 13, Object Destruction looks at an important topic: what happens when objects go away. When the last reference to a Perl data structure goes away, Perl automatically reclaims the memory of that data structure, including destroying any links to other data. Of course, that in turn may cause Perl to destroy other ("contained") structures as well.
Chapter 14, Some Advanced Object Topics, answers the questions "Do all objects inherit from a common class?" "What if a method is missing?" "What about multiple inheritance?" or "How can I tell what sort of object I have?" and other advanced questions pertaining to objects.
Chapter 15, Exporter, shows how to decide what to export and how to create your own import routines. In Chapter 3, you learned how to use modules, some of which pulled functions into the current namespace. Now you learn how to get your own modules to do that.
Chapter 16, Writing a Distribution, shows how to package a module for sharing, including portable installation instructions. In the previous chapter, you created a fictional Island::Plotting::Maps module and built the right support for Exporter so that we could include use Island::Plotting::Maps in a program. While the resulting .pm file was useful, it wasn't very practical. There is more work to do before you can share your work, whether that means simply installing it yourselves on another machine or giving it to someone else to use.
Chapter 17, Essential Testing, covers testing your code to ensure it does what you want it to do. As briefly described in Chapter 16, a distribution contains a testing facility that you can invoke from make test. This allows you to write and run tests during development and maintenance, and it also lets your end user verify that the module works in their environment. You should look at "Perl Testing: A Developer's Notebook" for in-depth coverage.
Chapter 18, Advanced Testing, gives you a taste of some of the more popular test modules. These modules are usually not part of the Perl standard distribution (unlike Test::More) and you'll need to install them yourself. You'll learn how to test complex aspects of code and also meta-code subjects such as documentation and test coverage.
Chapter 19, Contributing to CPAN, shows how you can contribute to the Perl community at large. The mechanism for sharing your work is called the Comprehensive Perl Archive Network (CPAN), which has thousands of different modules.
I found this book to be a seamless continuation of "Learning Perl". Everything is explained very well and there are plenty of examples. It really is ideal for self study. Having the answers at the back of the book was helpful, too. There are not just a bunch of pieces of code as answers, but good explanations as to how and why you would take a particular path in solving an exercise. Highly recommended, especially to the self-taught.