Review:
Advanced Perl Programming, by Sriram Srinivasan
| Publisher: |
O'Reilly |
| Copyright: |
August 1997 |
| ISBN: |
1-56592-220-4 |
| Format: |
Trade paperback |
| Pages: |
392 |
The problem with buying lots of books is that one frequently doesn't read
them soon after purchase. And while nearly all fiction and most
non-fiction doesn't have a time limit, technical books are more of a
problem. As you might have guessed from the publication date and subject
matter of this book, it's one I waited too long to read.
I picked up
Advanced Perl Programming not too long after it was
first published in 1997. I bought it primarily for the chapters on XS
programming, since I was just starting to develop and help maintain code
that built Perl interfaces for C libraries. And then it sat on my
bookshelf in the office, and then at home, until it was 16 years old.
That's problematic for a general Perl programming guide; it's particularly
troublesome for a book that dives deep into internals. That said, I still
got some interesting information from it.
Advanced Perl Programming is something of a grab bag of different
and largely unrelated topics. It starts with a data structures overview
(which is mostly about references), covers typeglobs and the Perl symbol
table, briefly discusses closures, and then dives deeper into eval.
That's followed by an overview of modules and object-oriented programming
in Perl. The general Perl topics close with a solid (if outdated)
discussion of tied objects and a somewhat rambling and remarkably general
discussion of persistance. Srinivasan then covers some recommended module
APIs for networking and graphics (Tk, specifically) while working through
some complex examples, takes a deeper dive into eval and code generation,
and concludes with three chapters on XS and embedded Perl interpreters.
This is all solid material, but a lot of it is at least partly obsolete.
The chapters on modules and object-oriented programming fare the worst;
you'll find much better guides to those topics elsewhere. Data structures
also fare poorly, partly because Srinivasan is still happy to use symbolic
references, now considered bad style due to lack of compile-time checking.
(That does mean, though, that this is one of the best introductions to
symbolic references that you'll find, since few other Perl programmers
discuss them.) But the rest of the book is fairly solid, if limited by
age. If I'd read it when I first started with XS, it would have indeed
helped.
Advanced Perl Programming contains a succinct and clear
overview of Perl internals and data representation (assuming, of course,
it's not changed drastically, but I didn't notice any significant issues
from what I know of internals from quite a lot of XS programming),
particularly when combined with the earlier chapter on typeglobs and the
symbol table.
It is interesting, though, to see how much accepted Perl style has
changed. Srinivasan is quite fond of eval with a scalar argument to
construct code at runtime, something that most current authors recommend
against when it can be avoided. The loss of static syntax checking means
the technique is often hard to debug and can cause surprising runtime
errors. Several of the more advanced tricks in this book are built on
that framework, including a moderately interesting templating system that
he constructs from scratch in this book. The examples here are also
missing the focus on
use strict, warnings, and avoiding special
variables and unusual constructs that you see in more recent Perl books.
This is a very thoughtful book, with several structural techniques that I
appreciated and would like to see more technical writers use. One is the
comparisons to the approaches of other languages at the end of most
chapters. It puts Perl's approach in a broader context and encourages
thought about alternative ways to view a particular feature and
implementation tradeoffs in Perl's choices. Another is the careful
discussion of design approaches and possibilities during the construction
of larger examples. I think there's a tendency in technical books to
spend a lot of time developing the best possible implementation of
something and then show that completed example. Even with a detailed
analysis of its construction, this can be less useful than a broader
discussion of possible approaches, including dead ends.
The problem, of course, is that 16 years is a long time, even for a
relatively mature programming language, and Perl has changed. There are
significant improvements not only to the standard library but to Perl core
functionality that have happened since this book was written. The chapter
on tying, which is otherwise excellent, is badly out of date on what
functionality and methods are available and is no longer a reliable guide
to using that feature except for simple cases. Similar problems plague
the chapter on persistence, which develops the concept from basics that
most programmers reading an advanced book no longer need, and which has
been rendered mostly obsolete by further developments in the Perl module
ecosystem.
I think the best parts of this book, the ones that cover material that I
think is still relatively accurate and that are not well-covered by other
resources, are the chapters on typeglobs and on XS. The typeglob
discussion is both clear and informative, covering material and techniques
that are used in a few core Perl modules and that I've never seen
adequately addressed elsewhere. I'd subsequently picked up XS and Perl
embedding the hard way: lots of trial and error and reading difficult POD
documentation. I wish I'd read this book earlier, since Srinivasan does a
great job of basic orientation. He doesn't go far enough for me (the book
I probably wanted was
Extending and Embedding Perl by Jenness and
Cozens, published five years later), but I would have been up and running
with basic XS much faster by starting here.
If this were 1997, or even 2000, I would probably recommend this book,
albeit with a few caveats.
Higher Order
Perl is the place you should go for discussion of closures, rather than
here (although of course it didn't exist then). I wasn't fond of string
eval even in 1997, and I still think it produces code that, while
efficient and quite powerful, is horribly difficult to understand. And
the introduction to modules is adequate but not compelling; most other
introductions to object-oriented programming and module construction in
Perl are better. But even discarding those chapters (and the mostly
unnecessary Tk reference), there's a lot of great material here that would
have been quite helpful in 2000.
Unfortunately, this is not the sort of technical book that ages well, and
while I did pick up some useful background knowledge and a much better
understanding of typeglobs, I mostly read this book because I wanted to
salvage some knowledge from a book that sat for far too long on my
shelves. There's really no reason to buy it today. If you run across it
in a library, there are a few chapters that are still worth reading, but
by and large if you know enough Perl to know where to be careful of
landmines due to changes in Perl since the book was written, you also know
enough Perl to not really need this book.
Rating: 5 out of 10
Alexander Reichle-Schmehl created Debian bug
#710000 on Monday May 27th 2013, against the ftp.debian.org
pseudo-package, by cloning a bug report by Rene Engelhard. So,
technically speaking, Rene reported this bug....but Tolimar is
responsible for that.
Bug #700000 was reported as of February 7th: 3 months and 20 days
for 10,000 bugs. This is again a VERY significant drop in the bug reporting
rate in Debian. Is that related to the release of jessie? We'll see
that in the upcoming 4 months.
So it's been about a year since I 
I wrote a small 
The fifth internation 
like last week, I was working on the preparation of the 
My new employer sponsors me a phone of my choice (up to a certain cost) and I'm very inclined to order a 
On saturday 25. of May I gave a talk about FreedomBox
at the "Claim back your device" track of LinuxTag in Berlin.
LinuxTag is a fairly big annual conference
about (yes, you guessed right) Linux and related topics.
The FreedomBox is a project to help non-geeks care about their
personal privacy when online, same ways as geeks have practiced for a
decade or more. Concrete goal is to design a small, cheap physical box
similar to an internet gateway or wifi router
but with three additions: