Customer Reviews


23 Reviews
5 star:
 (14)
4 star:
 (9)
3 star:    (0)
2 star:    (0)
1 star:    (0)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 
‹ Previous | 1 2 3 | Next ›
Most Helpful First | Newest First

78 of 83 people found the following review helpful
4.0 out of 5 stars Three years later, Sailors upgrade Perl navigation software, April 4, 2006
This review is from: Intermediate Perl (Paperback)
This book updates the 2003 "Perl References, Objects & Modules" from the same authors, which described (in a humorous but also realistic way) a group of "Sailors" writing navigation software.

First, I summarize the major changes of the new version:
1) The description of the methodology to partition software has been extended, leading to 3 separate chapters (3, 10, 15). I must say that it is not very clear why they are scattered in that order. I personally concluded that they are best read sequentially and in this order: first Chapter 10, "Building Larger Programs" (where the Sailors start reusing software first via 'cut and paste', then come to sanity via eval/do/require and finally 'package'); then Chapter 2, "Using Modules" (the natural follow up to 'package'); finally Chapter 15, "Exporter". Read in this order, they are a comprehensive and excellent overview of this subject. In the order presented in the book, they are odd (why would the sailors, after learning to use Modules in chapter 3, start 'cut and paste' and 'eval files' to reuse software in chapter 10?).
2) A new chapter "Intermediate Foundations", with a good section reminding the differences between 'eval string' versus 'eval {block }'.
3) The Testing area is enhanced with a new chapter "Advanced Testing". Information on CPAN & distributions is updated in several chapters. Also, while the examples in the book are largely the same, code style is improved; for example, the chapter on grep/map uses the 'grep { filter } array' and 'map { transform } array' style, rather than the less clear ', Expr' style of the first edition.
In all, a better book (aside from the absurd chapter organization choice remarked above).

For the ones who have not read the 1st edition, the strongs points of the rest of the book are:
a) the chapters 5, 6 on Data Structure manipulations. The best is the way that anonymous arrays & hashes are presented, showing how they simplify the code of an example (as their introduction removes a jungle of temporary variables). Autovivification follows, with another excellent example (a "data reduction report generator").
b) chapter 7 "Subroutine References", identical to the first edition, one of the best chapters, introducing anonymous subroutines by continously refining an example, and then doing the same for "Closures". The only regret is that the final example on closures is a bit dull (as the "findFile" runs always to the end in one shot), obscuring the central capability of closures to keep each its context simultaneously (imagine an example that computes different Dna strands alternating between them, or, to stay with the book's theme, moves different boats from their initial position...). Still, for people (like me) coming from static languages, the chapter was an authentic gift.
c) chapter 9 "Reference Tricks", with a great presentation of sorting, the famous Schwartzian Transform, and the processing of recursively defined data.
d) finally, the chapters on Objects, and the Class Hierarchy. Remark the simple and effective presentation of Inheritance, used to factor out code common to some classes (without indulging in any of the mystical overtones that often accompany this OO subject).

The points where the book is less perfect:
-) Although the book wants to stop at the "Intermediate level", it could at least indicate to the reader subjects to be developed; for example, closures and mod_perl (problems with Cgi under 'registry'), need of caution with unwanted autovivifications (when testing for existence), etc. Role of lexicals vs local should also be better explained.
-) Chapter 4, on References, attacks the subject of (de)referencing nested data structures. The central problem (known to strike terror in Perl tests and interviews): why do we need to write @{ $x[0] } to retrieve the array referenced by the first element of array @x? Rather than ingenious rules on "when braces are needed" and "when they can be lifted", I think it would be best to tell the facts:

"Gentlemen: the dark secret here is that the sigils $, @, % bind more tightly than the [], {} and -> subscripts. This forces us to place braces around $x[0] in the previous example and write @{ $x[0] }. If instead we wrote @$x[0], Perl would try to retrieve a slice (element 0) of the array referenced by scalar $x (that was not our case). Got that? now, lets' be brave: what if we have a reference $ref to a list of lists and we want one of the far lists?
In this case, we must write @{ $ref->[$i] } to allow $ref to work undisturbed on the first list, and (only then!) collect the far list. To get a slice of the far list (say, elements $m and $n), just append [$m, $n] to the expression just written. If you have hashes instead of arrays, replace [] with {}, and all the rest is identical. END OF STORY".
Yes, the previous paragraph is not a cute fairy tale, and it requires some experimenting to be interiorized. But, once you do, isn't this inmensely simpler (6 lines!) to remember? Fairy tales are sweet but do not make you strong!

-) Also: why teach first ${$item}[1] and only later introduce the arrow notation $item->[1]? Invert the order: use the arrow notation (universally intuitive) to develop the examples, mentioning briefly (for masochists and obfuscators) the other notation.

In conclusion: in spite of its shortcomings and defects, this is a very useful book to progress in Perl, as its "progressive refining method" forces you to a constant mental gymnastic to reach every formulation (the opposite of the "cut and paste" culture).
One last note: after reading the chapters on Objects, it is interesting to plunge into D.Conway's "Perl Best Practices" (see my review), chapter 15 "Objects", to examine a different object implementation ("the inside-out objects"). Aside from the fascinating thesis exposed there, the fact that one can easily acquire 2 different perspectives on how to construct (internally) Objects in Perl, shows perhaps that this book allows the reader to begin moving beyond the "intermediate level".
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


19 of 19 people found the following review helpful
5.0 out of 5 stars Good sequel to Learning Perl, January 26, 2007
This review is from: Intermediate Perl (Paperback)
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.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


9 of 9 people found the following review helpful
5.0 out of 5 stars Good Book For Classroom Setting, February 19, 2007
By 
J. MCADAMS (Kirkland, WA USA) - See all my reviews
(REAL NAME)   
Verified Purchase(What's this?)
This review is from: Intermediate Perl (Paperback)
I picked up this book for a class that I was teaching at my office. The goal of the class was to train HTML/CSS/JavaScript and/or Java programmers to code in Perl since a large portion of our code base is written in Perl. Overall, I think that the book was a good choice for the class for a number of reasons.

First of all, the book is already written with a classroom setting in mind. The authors have used previous versions of the book, titled "Learning Perl Objects, References and Modules", for their own courses. This updated version benefits from all of the hours of empirical testing that it has received in the classroom. There are many thoughtful additions like having all of the chapters close to the same size. This allowed for me to assign a single chapter per session and know that I could comfortably fit the lecture and discussion of the chapter into a two-hour session. There are also exercises at the end of each chapter and answers for those exercises (with discussion) in an appendix.

This book is good for getting people just learning the language ready for the TMTOWTDI/TIMTOWTDI aspect of Perl. Take something simple like opening files... there are at least four 'standard' ways to do it. The book prepares you for all of the different versions of annoyances/features like this that show up in Perl code by walking through the evolution of the feature.

Another reason that I like this selection of book is that data files and code examples are actually available for download. I've been shocked that some of the programming books that I've gotten lately actually don't have this addition.

Finally, the course that I'm teaching is for people who probably already know how to program, at least a little, but they don't know Perl. I didn't want to drag them through all of the picky details of the language by starting with "Learning Perl" or something equivalent. This book has been a good choice for introducing programmers to Perl. I do have to stop occasionally and explain some fundamentals of the language, but not too often... maybe I just work with smart (or shy) people :)

Of course, the book isn't perfect. As odd as it seems, one of the biggest complaints that I get is over the Gilligan references that are used in all of the examples in the book. There is also some coverage of packaging modules for CPAN. This is useful, just not for the particular class that I'm teaching, so we skipped that chapter. Of course, both of these complaints are pretty weak.

In short, this is a good book, especially if you are doing a training session about Perl.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


8 of 9 people found the following review helpful
4.0 out of 5 stars Good follow up to the The Llama, but poorly organised, July 14, 2007
This review is from: Intermediate Perl (Paperback)
If you've mastered The Llama, make haste to read this one. Even if you only want to do scripting with Perl, you'll eventually find you need data structures slightly more complicated than just flat arrays and hashes, and you need to know about references for that. While The Camel does contain a fair chunk of material on just this subject, it was a bit too much for me to digest after The Llama. If Intermediate Perl (aka The Alpaca) had been around for me to read, I would have had a much easier time.

Written in the same style as The Llama, this breeze through most of the rest of Perl, in particular: references, objects, packages and modules. These are the bits that you need to use Perl as a general purpose programming language, not just for scripting. In a similar pragmatic vein, it also covers how to use tools to build your own packages in the CPAN style, and there's a good chunk of material on using Test::More for unit tests. Probably the only thing missing is material on type globs and symbol tables, although hopefully, brian d foy's forthcoming Mastering Perl will fill in these gaps.

The bottom line is this is Llama part 2, and you need to read it if you want to have any hope of understanding anyone else's Perl. But I can't give it five stars. The major problem is that the material is not very well organised. At the chapter level, objects are sandwiched between modules and packages. It would have been far preferable to keep the module and package information together. As a result, the distinction between modules and packages is rather muddied, and the introduction of objects in the middle just makes things worse. Overall, I found the explanations to lack the clarity of the Llama.

A more minor complaint is that, while there are mercifully fewer annoying footnotes, the Gilligan's Island theme (if, like me, you had no exposure to this growing up, you might want to read the Wikipedia article first!) grates far sooner than the Flintstones flavour of the Llama.

That said, make this your second book on Perl. Then, _still_ don't read The Camel yet. Avail yourself of Perl Best Practices first.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


15 of 19 people found the following review helpful
4.0 out of 5 stars Not As Good As Learning Perl, June 11, 2006
By 
Dan McKinnon (Tewksbury, MA USA) - See all my reviews
(VINE VOICE)   
This review is from: Intermediate Perl (Paperback)
'Learning Perl' by the same authors is one of my favorite books of all time in in the O'Reilly family of books. It's incredibly well written, easy to follow, and it's like having the best instructor you could want teaching you live and in person. As for 'Intermediate Perl', this book is supposed to take regular Perl developers beyond the scripting abilities of the language, allowing them control of much of the power of any other popular and powerful programming language in the development world. While this book has lots of nice material, I find the book to not be as clear, concise, and easy to follow as the precursor to this book. I am certainly no Perl expert, so maybe that is part of the problem, but upon opening this book I had hoped to find a book that was easier to read for any and all programmers.

All in all, a nice book, but not up to snuff with what I had hoped for.

**** RECOMMENDED
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4 of 4 people found the following review helpful
5.0 out of 5 stars Great resource for frequently-used techniques, January 14, 2013
By 
Ronald Rahaman (Evanston, IL USA) - See all my reviews
(REAL NAME)   
Verified Purchase(What's this?)
This review is from: Intermediate Perl (Kindle Edition)
This book both an excellent tutorial and reference for essential Perl techniques such as:

(1) Using data references
(2) Using nested data structures
(3) Program organization (i.e.: using modules effectively)

This was the book that really took me to the next level, in terms of productivity. Likewise, if I haven't used Perl in a while, and I find myself a little rusty, I can always come back to this book and get back up to speed in just a few minutes.

I think this book is much better than _Programming Perl_ by Larry Wall, from the same publisher. _Programming Perl_ is much more verbose while somehow being less informative, so it is very difficult to use as a reference. _Programming Perl_ also has much fewer examples, making it unsuitable to use as a tutorial.

The only possible downside to _Intermediate Perl_ is that it doesn't cover introductory Perl concepts. However, I can hardly fault the book for this, as it is intended to be a follow-up to the introductory book, _Learning Perl_ by the same authors and publisher (which I also highly recommend).
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 2 people found the following review helpful
4.0 out of 5 stars Leap from Perl scripting to serious development, October 28, 2012
This review is from: Intermediate Perl (Paperback)
After having learned the basics in Learning Perl ("Llama book"), Intermediate Perl takes you to the next level. It is aimed at doing more serious development work (programs of over 1000 lines of code). Hence it introduces the more advanced concepts as complex data structures, references, packages and OOP.

Structure
This book covers a lot in its 21 chapters. It serves well a classroom or self-paced learning discipline with equally length chapters of approximately one hour reading time and exercises that help you practice the newly introduced concepts.

I like the introductional chapters, getting into CPAN, intermediate foundations (grep, map, eval) and references. Good prep work to start tackling more complex problems. Up until chapter 10 it expands on references concepts which was a really good read. At chapter 11 there is a turning point into software development: how to write bigger and more maintainable programs in Perl. How to create your own Perl distribution, Perl's OOP design and (Advanced) Testing, ending with Moose and contributing to CPAN. At this point, when using all these concepts in your daily work, you are probably becoming a master. The next logical step is to then read Mastering Perl, the 3rd O'Reilly Perl learning series book or the Perl bible, Programming Perl.

OOP Perl
I found this the most complex part of the book, not as clear as the other topics (ch 1-11 and Testing). I am not sure this is inherent to Perl's design of OOP or the way Intermediate Perl presented the content and/or its samples. I probably have to start using OOP more in my work, and I am going to read Damian Conwey's OOP title on the subject which seems a good place to learn OOP Perl in depth.

Overall opinion
I can recommend Intermediate Perl as a logical step after the Llama. If you want to build larger, more powerful/ robust programs, this gives you a jumpstart. You might as me need more material and practice on object oriented Perl but that is fine, this is still a very useful reference that brings together fundamental intermediate to advanced Perl techniques.

If you are serious about a career in Perl development this book should be on your shelf. For simple scripting needs it might be overkill, but even then you will need to pass a reference around form time to time, re-use software from CPAN, etc. Apart from that, you will learn better, faster, and more efficient coding practices in Perl from this book.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 2 people found the following review helpful
5.0 out of 5 stars Intermediate Perl - Pleasantly surprised, March 6, 2011
Verified Purchase(What's this?)
This review is from: Intermediate Perl (Paperback)
My original intention was to leave this book on my bookshelf as part of a collection of other books on perl. By chance I opened the book and started browsing and was pleasantly surprised that I will have to take out pen and pencil and a highlighter to study the contents.

What's cool is I can use this book as a reference primarily for different ideas for things I've already done in perl and for some things that I hadn't even thought of doing.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


3 of 4 people found the following review helpful
5.0 out of 5 stars A worthy (as expected) successor, October 9, 2007
By 
Joseph B. Cohen "Pragmatist" (Brooklyn, NY United States) - See all my reviews
(REAL NAME)   
This review is from: Intermediate Perl (Paperback)
Successors are not always as expected. In this case you do get from this trio of authors, who are classics in their own right, just what you expect. In my own case, I needed to get good at OO Perl and fast. In three days, I covered the major chapters thoroughly, went off to my interview and in the end was told, "hey, you really know your stuff". This book intends and does indeed follow well the Learning Perl classic. If you finished the meat of the classic, this is the dessert. You'll recognize the writing style and flavour. There are no surprises. In my opinion, another classic.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
5.0 out of 5 stars Must have for serious Perl enlightenment, April 10, 2013
By 
D. Page (San Antonio, TX) - See all my reviews
(REAL NAME)   
Verified Purchase(What's this?)
This review is from: Intermediate Perl (Paperback)
I own a ton of technical books on various computer subjects. If they were all as well written as this, life would be so much easier. It is clear and concise. Easily re-readable for more difficult concepts. Every chapter has self exercises, and the answers are in the back. I honestly wish other books were written in this detailed, easy to follow style. The code examples actually demonstrate the concepts and do not introduce distractions from what you are trying to learn. This book is very gratifying to work through because you actually learn at a good pace. The chapters serve as a great desk side reference. My only complaint is that "Intermediate" is in the title, which looks like of noobish on my desk. On the other hand, you know exactly where you are in the series hierarchy..
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


‹ Previous | 1 2 3 | Next ›
Most Helpful First | Newest First

Details

Intermediate Perl
Intermediate Perl by Randal Schwartz (Paperback - August 16, 2012)
$44.99 $29.70
In Stock
Add to cart Add to wishlist
Search these reviews only
Send us feedback How can we make Amazon Customer Reviews better for you? Let us know here.