Review: Higher Order Perl, by Mark Jason Dominus
Publisher:
Morgan Kaufmann
Copyright:
2005
ISBN:
1-55860-701-3
Format:
Trade paperback
Pages:
563
Disclaimer: The author and I both used to be (technically still are, but
the newsgroup is dead) moderators of comp.lang.perl.moderated, and I knew
him electronically from answering questions on the Perl Usenet newsgroups
many years ago.
Perl is, in general construction, a typical imperative language in the
style of C, with object-oriented capabilities bolted (somewhat awkwardly)
on. Most Perl code looks remarkably like C code with more powerful
built-in data types and no memory management. A minority of Perl programs
embrace object-oriented techniques and remind one of C++ or Java (or
Python). But Perl also has powerful capabilities borrowed from functional
programming languages and the Lisp tradition, even though many Perl
programmers rarely use them and aren't familiar with them. Higher
Order Perl focuses on those capabilities and how to use them effectively,
starting with callbacks and uses of function pointers and moving into
recursion and analysis of recursive functions, iterators, currying, and
parsers. It concludes with a fully-worked example of constructing a
declarative programming system using the techniques developed earlier in
the book.
Higher Order Perl is a programming book for an intermediate to
advanced Perl programmer, already a rare topic. This is not a look at how
to apply Perl to another area of programming, or a cookbook of techniques.
It's an attempt to help a Perl programmer think about and use the language
differently, and it follows through on that. It's refreshing and rare to
read a programming technique book that's targeted at the practicing
expert. (I think the size of the audience is often too small for
publishers to target it.) Even the most experienced Perl programmer is
probably going to learn something fundamental from this book, not just
interesting trivia around the edges.
On the negative side, though, I found the book a bit too focused on
computer science and mathematics problems, particularly in the choice of
examples and sample scripts. (And I say this as someone who has a
master's degree in computer science with a software theory focus.) This
is a bit hard to avoid for topics like recursion, where problems like
computing Fibonacci numbers are classic, but throughout the book I
struggled to focus past feelings of "but why would I ever do that"? The
extended discussion of the Newton-Raphson method is the most memorable;
I'm not sure that's a problem many Perl programmers would have and need a
higher-order technique for. There's also a lot of discussion of recursion
analysis and transformations between recursive and iterative expressions
of problems, which is ground I remember well from my degree but which I've
rarely had any practical use for in day-to-day programming.
This is not a uniform problem, though, just a tendency. There are some
great examples that I think are more in the mainstream of Perl problems,
including a reinvention of File::Find that shows how to add more
flexibility, a web spider, and a great discussion on how to construct a
conventional queryable database on top of a flat file (a topic that's near
and dear to my heart).
And then there's the chapter on infinite streams. Dominus presents a
method of using closures to create a version of an interator: a sort of
infinite linked list that can keep generating additional elements. He
presents this in several contexts, but one of them is log parsing, and
that turned out to be exactly the solution that I needed for a problem I
was working on while reading this book. I've
written about this elsewhere, but
this was a wonderful idea that helped me think about both Perl and a major
application area in a completely new way, and I wrote an application using
that knowledge that would have taken me much longer using different
techniques and would have been much less fun. So, for me, this chapter
was more than worth the entire book, and blankets the rest of it in a
delighted feeling. Other people may or may not have that experience. I
think it will depend on whether one of these techniques hits home for you
the way that one did for me.
This is a book with some idiosyncracies, and some sections that may drag.
Having lots of fully-worked examples is a major plus, but some of those
are so comprehensive that one can get a bit lost in the details. That
particularly hit me with the last couple of chapters on parsing and on the
example declarative programming application. Quite a bit of that text
involved reinventing a recursive descent parser (another very computer
science example), when I'm not quite sure why one wouldn't use one of the
existing parser generators on CPAN for practical purposes, and inventing a
lot of new syntax to try to make parser Perl code more readable. But one
certainly can't complain that Dominus omits necessary details, and there
is some appeal in watching an experienced programmer work through a
problem from analysis to implementation.
But, despite the idiosyncracies, I recommend this book to any experienced
Perl programmer who wants to expand their view of the language. The
techniques here — closures, higher-order functions, iterators and streams,
and formal parsers — are powerful and underused in the Perl community.
You may want to pick and choose which sections you pay close attention to,
but I think everyone will find something of interest here. In the weeks
since I read this book, my opinion of it has only grown. And I can't tell
you just how much I loved the infinite stream concept.
Rating: 8 out of 10