|more useful options|
Perl! I Didn't Know You Could Do That...by footpad (Abbot)
|on Sep 26, 2001 at 00:49 UTC||Need Help??|
Order Perl! I Didn't Know You Could Do That...
Item Description: A Showcase of Perl and Many CPAN modules
Review Synopsis: A Gimmick book. Don't Bother.
According to its introduction, "Perl! I Didn't Know You Could Do That... (PIDK) attempts to, "highlight some of the cool things you can do with Perl that you might not necessarily be aware of." Certainly the book's Table of Contents suggests that author Martin C. Brown covers a wide variety of topics in the book's 213 pages (not counting the index). However, I strongly suspect that your satisfaction with the book will depend greatly on how broadly you define "highlight."
PIDK isn't a traditional technical book; it's more of a collection of tidbits designed to showcase some interesting, perhaps even cool things to do with Perl and different CPAN modules. It provides 51 separate essays loosely grouped together in various topic areas. There's a little bit of CGI, a little bit of system administration, a little bit of Perl internals, and even a little bit of platform specific stuff for PalmOS databases, Mac interface design, Microsoft Office integration, and (of course) Unix tools.
Given the number of topics, you might be afraid that Brown isn't able to cover his material very well or very deeply. This is a valid fear, given that each topic has an average of four pages of material devoted to it, including code fragments, tables, and screenshots.
Brown resorts to a number of unsatisfying tricks to achieve this. First, the book doesn't provide complete code listings in the prose itself. While each topic comes with one or more code samples, they're only available on the book's CD and frequently un-commented.
(Personally, I prefer to see code samples presented and discussed in a book's prose, as is done in CGI Programming with Perl, Effective Perl Programming, Writing CGI Applications with Perl, and in the periodical columns of a certain monk of note.)
Placing the code only on the CD has other drawbacks. You're not able to determine its quality until after you've bought the book and broken the no-refund seal. Only then are your worst fears realized.
It's not that the code samples are necessarily bad or poorly written; however, they're not well-written. Few use strict or -w and none of the CGI examples use -T, though they do use CGI.pm. Not deeply, but they do use it.
Brown also avoids any depth in his topics, preferring an anectdotal style that can be charitably described as "breezy." While it makes for readable prose, it doesn't provide much in the way of value or education. Sometimes, these introductions border on the inane. For example, consider the opening sentence of Item 8, Using SQL with Text Databases:
When I first read this, my initial reaction was, "Duh!" While the next few paragraphs build a case for creating database-driven web sites, he concludes his argument with the following:
As you might expect, he uses this to demonstrate DBD::CSV; however, any capable database programmer will tell you that while text files can be easier to maintain and support than proprietary database formats, all databases require maintenance.
A few pages later, Brown provides an adequate introduction to the main SQL DML statements. However, as is typical for the book as a whole, he ignores the DDL statements. (If you're looking for an introduction to SQL and/or effective database programing techniques with Perl, I highly recommend O'Reilly's Programming the Perl DBI: Database Programming with Perl, which contains a far superior introduction to SQL and a more relevant introduction to DBD::CSV.)
On the other hand, there are a number of topics that could be of interest to nearly everyone. Item 37, converting POD Files on the Fly is an interesting read for folks that are still coming up to speed on the Unix mindset and Item 28, Searching a Search Engine, shows whether or not (as of the book's writing) various WWW::Search modules were working. (I assume that things have changed in the interim, but that list is a good starting place.)
This "half a loaf" approach is seen throughout the book. For every interesting thing shown, there are a host of issues that are sidestepped or ignored. Frankly, I suspect you'll get more out of the POD of the CPAN modules involved than you will from Brown's keen insights into their use. Similarly, I suspect that many of the best ideas are already in the archives.
Now, I admit that it's possible to argue, "it's not that type of book. It's just a showcase of cool tricks." However, the book's "concept" is in itself a problem.
You may know that IDG's "Dummies" books are considered the most successfully marketed series in technical publishing. As we've seen in various knock-off series that've appeared over the years (Idiot's Guide to Foo, Teach Yourself Foo in a Ridiculous Time Frame, Foo for Smarties, and so on), books designed around marketing concepts rarely succeed in providing satisfactory experiences for anyone other than the publisher. The same is true of Sybex's I Didn't Know You Could Do That... series, each of which sports photos of monkeys and lots of bananas.
PIDK is part of that series, which also contains titles covering MP3's, iMacs, basic Internet useage, and other introductory titles. Clearly, this isn't a series targeted at programmers, which is too bad because the lack of useful specifics in the prose means a lot of people are going to think Brown's code samples are idiomatic and should be studied for good programming practises. Ouch.
As with other "concept" books, PIDK follows a certain formula. Each page contains one of nine different photographs of monkeys, a banana appears on the back cover, and so on. It's meant to be clever and approachable; unfortunately, it's tiresome, distracting, and (eventually) annoying--like a good joke told too many times.
Please understand that I agree that there is a place for the various series and that selected titles in those series are quite good. This isn't one of them. It's not overtly bad, just limited and--frankly--mediocre. Given the quality we get with most of O'Reilly's titles (and notable other titles), mediocrity just isn't good enough for the Perl market.
To be completely fair, there's enough material in the book to provide at least one helpful tidbit. Just be aware that you're going to put up with a lot to get to it. Given the number of quality titles available, I can't see many people thinking their $25/U.S. will be well spent.
PIDK isn't as bad as some of the titles we've reviewed previously, however, it's nowhere as useful as others. It was written to fit a marketing concept and--frankly--I'd rather see people support Perl authors that teach what you need to know rather than pander to some marketing gimmick.
Your mileage may vary, of course. I can see some appreciating the high level overview that Brown provides to various topics. I can see others taking and building on the framework he provides. If nothing else, it's nice to learn more about some of the better modules on CPAN. However, you'll need to make that decision for yourself.
Because of this, I strongly recommend you not buy this book online--unless you like to gamble. If you happen to see it in a bookstore, then certainly take some time to leaf through it and see if there might be something interesting. Keep in mind, however, that the book's breadth also means there are going to be topics that will not interest you.
If I graded books using letter grades, I'd probably give this one an "E" for effort. It may help one monk out of a hundred; however, I personally find the prose too superficial, the code samples too limited, and the marketing ploy too cheap to give this anything more than Two out of Five Camels.
2001-09-25 Edit by Corion : Added missing </OL> tag
Update: fixed various typos. (thanks, grinder!)