Shop now Shop now Shop now Shop All Amazon Fashion Up to 70% off Fashion Cloud Drive Photos Shop now Shop Amazon Fire TV Shop now Shop Fire HD 6 Learn More Shop now Shop now Shop now
Intermediate Perl and over 2 million other books are available for Amazon Kindle . Learn more
  • RRP: £29.99
  • You Save: £10.42 (35%)
FREE Delivery in the UK.
Only 7 left in stock (more on the way).
Dispatched from and sold by Amazon.
Gift-wrap available.
Quantity:1
Intermediate Perl has been added to your Basket
Condition: Used: Good
Comment: Used Good condition book may have signs of cover wear and/or marks on corners and page edges. Inside pages may have highlighting, writing and underlining. All purchases eligible for Amazon customer service and a 30-day return policy.
Trade in your item
Get a £0.60
Gift Card.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

Intermediate Perl Paperback – 16 Aug 2012

4 customer reviews

See all formats and editions Hide other formats and editions
Amazon Price New from Used from
Kindle Edition
"Please retry"
Paperback
"Please retry"
£19.57
£14.87 £7.57
£19.57 FREE Delivery in the UK. Only 7 left in stock (more on the way). Dispatched from and sold by Amazon. Gift-wrap available.

Special Offers and Product Promotions

  • Save £20 on Amazon.co.uk with the aqua Classic card. Get an initial credit line of £250-£1,200 and build your credit rating. Representative 32.9% APR (variable). Subject to term and conditions. Learn more.

Frequently Bought Together

  • Intermediate Perl
  • +
  • Learning Perl
  • +
  • Programming Perl: Unmatched power for text processing and scripting
Total price: £66.57
Buy the selected items together



Product details

  • Paperback: 396 pages
  • Publisher: O'Reilly Media; 2 edition (16 Aug. 2012)
  • Language: English
  • ISBN-10: 1449393098
  • ISBN-13: 978-1449393090
  • Product Dimensions: 17.8 x 3.5 x 23.3 cm
  • Average Customer Review: 4.5 out of 5 stars  See all reviews (4 customer reviews)
  • Amazon Bestsellers Rank: 167,422 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Authors

Discover books, learn about writers, and more.

Product Description

Book Description

Beyond The Basics of Learning Perl

From the Publisher

Perl programmers need a clear roadmap for improving their skills. Intermediate Perl teaches a working knowledge of Perl's objects, references, and modules -- all of which makes the language so versatile and effective. Written by the authors of the bestselling Llama book, Learning Perl, this guide offers a gentle but thorough introduction to intermediate programming in Perl. Topics include packages and namespaces, references and scoping, manipulating complex data structures, writing and using modules, package implementation, and using CPAN. --This text refers to an out of print or unavailable edition of this title.

Inside This Book

(Learn More)
Browse and search another edition of this book.
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

4.5 out of 5 stars
5 star
2
4 star
2
3 star
0
2 star
0
1 star
0
See all 4 customer reviews
Share your thoughts with other customers

Most Helpful Customer Reviews

9 of 9 people found the following review helpful By Thing with a hook on 14 July 2007
Format: Paperback
If you've mastered The Llama (Learning Perl), 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 Programming Perl 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.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
7 of 7 people found the following review helpful By D. J. Walrond on 20 July 2006
Format: Paperback
The first edition of this book was called "Learning Perl Objects, References, and Modules", which is a bit of a mouthful and therefore has sensibly been renamed to "Intermediate Perl". It's the follow up book to "Learning Perl", written by the same authors so if you have finished "Learning Perl" and want to learn more Perl, then this is the book for you.

The book is designed for the reader to work from cover to cover. Basic knowledge of Perl is assumed, so you could skip "Learning Perl" if you've been using the language for a while. There are some exercises at the end of each chapter, with answers given in the Appendix. The book was originally written from courses the authors ran, so it is tuned to have an appropriate learning curve if your Perl knowledge can be summed up by "Learning Perl". Compared with "Programming Perl" it is a completely different style of book; "Programming Perl" is more of a reference book, so is useful in a different way to "Intermediate Perl". If you are looking to develop your Perl skills and want a bit of hand holding then "Intermediate Perl" will certainly help with that.

The book is written in a quite chatty manner: it covers the basics then builds up slowly to the more complex tasks of dealing with larger programs and modules. The book looks at how to write better Perl programs and introduces writing Perl modules. For a 250 page book there is certainly a lot packed into it.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
3 of 3 people found the following review helpful By R. A. Bagshaw on 23 Nov. 2006
Format: Paperback
This is actually a really good book but I can't help but feel that it delves into some topics very early and this can create some confusion. I purchased this book after reading the original Learning Perl book, the first chapter of intermediate perl was very tricky for me but then it did seem to make more sense as I completed chapters. Great book if you take your time! my advice, buy this book, read it slowly, read some chapters again, and dont worry too much with questions like "Why would I ever use a reference?" until you are at least onto basic object principles.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
Format: Paperback
After reading "Learning Perl" i thought i knew enough to write Perl programs, but felt some knowledge was missing.
Theres a lot more to modules, when you start writing them.

"Intermediate Perl" picks up where Learning Perl left off. At the same pace, and quality of narrative.
It fills in all the gaps with References, Namespaces, Modules, and OO Modules.

It's a must buy if your writing large Perl programs.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 24 reviews
81 of 86 people found the following review helpful
Three years later, Sailors upgrade Perl navigation software 4 April 2006
By raul parolari - Published on Amazon.com
Format: 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".
20 of 20 people found the following review helpful
Good sequel to Learning Perl 26 Jan. 2007
By calvinnme - Published on Amazon.com
Format: 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.
10 of 10 people found the following review helpful
Good Book For Classroom Setting 20 Feb. 2007
By J. MCADAMS - Published on Amazon.com
Format: Paperback Verified Purchase
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.
8 of 9 people found the following review helpful
Good follow up to the The Llama, but poorly organised 14 July 2007
By Thing with a hook - Published on Amazon.com
Format: 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.
5 of 5 people found the following review helpful
Great resource for frequently-used techniques 14 Jan. 2013
By Ronald Rahaman - Published on Amazon.com
Format: Kindle Edition Verified Purchase
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).
Were these reviews helpful? Let us know


Feedback