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
My new employer sponsors me a phone of my choice (up to a certain cost) and I'm very inclined to order a 
I ve been hacking on some static analyses stuff for 
Not so long ago I read 
Thanks to the release team 
You may not know this, but I am a huge PowerDNS fan. This may be because it is so simple to use, supports different databases as backends or maybe just because I do not like BIND, pick one.
I also happen to live in Germany where ISPs usually do not give static IP-addresses to private customers. Unless you pay extra or limit yourself to a bunch of providers that do good service but rely on old (DSL) technology, limiting you to some 16MBit/s down and 1MBit/s up. Luckily my ISP does not force the IP-address change, but it does happen from time to time (once in a couple of month usually). To access the machine(s) at home while on a non-IPv6-capable connection, I have been using my old (old, old, old) DynDNS.com account and pointing a CNAME from under die-welt.net to it.
Some time ago, DynDNS.com started supporting AAAA records in their zones and I was happy: no need to type hostname.ipv6.kerker.die-welt.net to connect via v6 just let the application decide. Well, yes, almost. It s just DynDNS.com resets the AAAA record when you update the A record with ddclient and there is currently no IPv6 support in any of the DynDNS.com clients for Linux. So I end up with no AAAA record and am not as happy as I should be.
Last Friday I got a mail from DynDNS:
Most UNIX users have heard of the
Thanks to