Customer Reviews

Wicked Cool Perl Scripts: Useful Perl Scripts That Solve Difficult Problems

5 star:		(0)
4 star:		(5)
3 star:		(3)
2 star:		(1)
1 star:		(3)

 

 

I couldn't resist the title, so I got this book. Unfortunately, I cannot reccommend it to people who want to learn to write better Perl, execpt as a source of examples of the mistakes you should avoid.

For example, in one of the earliest examples, the authors uses "return undef" in a situation where the return value of the routine is assigned to an array, to indicate the routine didn't find any of whatever it was looking for. Unfortunately, this is a mistake, the correct code would be to use "return;" all on its own. The correct solution produces an empty array or interim values; the mistake creates an array containing one element, 'undef'.

There are a number of similar mistakes which indicate the author is in over his head, writing things he doesn't understand; the editors know even less about the matter; and the code was never tested and verified for correctness.

If you want to learn Perl, get "Learning Perl"; If you want to improve your Perl, get "Intermediate Perl.

Tom

I don't usually feel strong enough to write reviews however don't buy this book unless you want to spend hours debugging someone elses code just for the fun of it. I could have written my own in less time that it took me to fix the errors found in the code. In addition you would expect the downloadable code to work and they don't either. They are not even the same code examples found in the book. Unless you want to pay for the ideas and what modules to use this book is a waste of money.

I'm going to be grumpy about this.

I have nothing good to say about this book. I don't have anything bad to say (except maybe that I dislike titles like this), but nothing grabbed me, nothing excited me.

Maybe that's because the kinds of examples presented are just what Perl is best at doing - the author demonstrates that a properly stocked toolbox can indeed be used to build a birdhouse, repair a sticking door, hang a picture. Yaaaawnn..

If you know nothing whatsoever about Perl, I suppose this might be fun. But why would you read it if you knew nothing? I think that's probably the basic flaw here: it's not a "Learn Perl" book, and it doesn't explore the more esoteric areas. The subtitle says "Useful Perl Scripts that solve difficult problems", but there are no difficult problems here, just building birdhouses, hanging pictures, and so on.

Just not my cup of tea, I guess.

Perl is a great language, but I doubt anyone would call it 'self explanatory'. That's where I find fault with this book. It's page after page of code, with very little explanation of that code and how it works.

That being said, I did like the examples used in the book. And I think this book fits nicely between Programming Perl and the Perl Cookbook. Though I would certainly buy those two books before buying this one.

This books gives good examples of different perl scripts for many situations. What I really like about the book was the outline for each script. It gave an intro to the situation and what the script would do, the script itself, an explanation on how the script works, and then tips for modifying the script to fit you needs. A neat book just to poke around in. The only downside was that the majority of scripts were web oriented, because I use perl to administer my network and was looking for something more along that line.

This book wants to be a recipe book. But in my opinion it doesn't do it's job very well. There are too many simple examples inside (which take a lot of space) and can be found in similar form on-line. Also, the author doesn't do a very well job at explaining things the right way and it seems the examples aren't that well thought through (both the choice of examples and their presentation).

The recipes explained in the book are not nearly as good as those in ie. Perl Cookbook, and don't seem to be that usable either. This book looks more like a collection of school assignments with solutions than practical examples needed by a developer. It may be interesting for someone who wants to learn Perl, but then it may also be too hard for beginners to comprehend the code inside the book (the explanations are not that elaborate).

The list of recipes might look interesting at first glance, but if you go into depth with this book, you soon notice that it simply isn't worth it.

This is a great book for learning by example, particularly as a follow-on to something like Learning Perl to get you started. It provides a number of useful scripts (even though some of them duplicate functionality of common system utilities), with explanations of how and why they work, and even notes on how you might alter the code to suit your own purposes. If you're a relatively new programmer that already has the basics of Perl in mind, but find yourself at loose ends wondering what to do next to help cement what you know and start learning more, this book may be exactly what you need. It's also useful for figuring out some of the basic principles of translating code between Perl and another language, thanks to the source code explanations.

The scripts themselves, however, are not exactly what I would call "wicked cool". The title is an obvious marketing conceit, designed to make the book seem more enticing. Most of the scripts, in fact, are surprisingly mundane -- but that doesn't mean they aren't useful. You may actually find yourself using some of them, with minor alterations, in your day-to-day life. Just don't expect to be wowed by the scripts themselves.

The problem with book titles which marry terms like 'wicked' and 'cool' with programming, is that scripts which, for example, determine the particular type of EOL marker in a file, may not match your personal definition of cool. More realistically, the book's subtitle promises that the 40ish programs given here are 'useful', and this is more or less true.

There's plenty here with a system administration flavour, e.g. a duplicate file finder, a website dead link checker, a Unix user deletion script. Also, the Tk toolkit is used for some simple GUIs, and the Image::Magick module for manipulating graphics, which is probably enough to get you started on your own ideas.

Even if your needs and interests don't align with the author's, a lot of the scripts remain useful, if not for the exact content, then at least for providing the skeleton that you can use for your own ends. Some of the scripts use an object oriented interface, but don't require the user to create an OO module, so as long as you're comfortable with references, most of the code here is very good for building a beginner's confidence in tackling non trivial scripts. There's also a reasonable amount of explanation of what the different bits of the code are doing, although the layout of the annotation is not particularly effective (the Head First books still lead the way in this), and the discussion does not go too high level. This is appropriate for the most part, but you're probably not going to be able to get too far with Tk on your own from just the material provided in this book.

On the downside, the Perl itself is not very idiomatic, so you may pick up some bad habits from the style. For example, the size of an array is checked with 'if ($#words != 1)' where 'if (@words != 2)' would be the more usual form. Sometimes scalars are implicitly initialised with undef (e.g. 'my $x', the usual practice), sometimes they're explicitly assigned (e.g. 'my $x = undef'), all in the same script. Return statements are always given in the form 'return ($x)'. This is nothing a good dose of Perl Best Practices can't fix, however.

Additionally, there are some unfortunate typos, e.g. the discussion of script 38 refers to $\ as the input record separator, while the code itself correctly uses $/. I spotted a stray 'TODO: Need something here to go somewhere' comment in script 34 which did not inspire an enormous amount of confidence.

And when it comes down to it, I just didn't find many of the scripts all that interesting. There's a whole chapter on downloading and using United States Geographical Survey mapping data, which didn't do much for me, I have to admit. The 'internet data mining' chapter is very weak, consisting of only two scripts, the first using the Finance::Quote module to print out a stock price, and the second to download some pictures from the web. For a book published in 2006, one might have expected something on web services or RSS. Given the amount of material devoted to GUIs and graphics, it's also a bit disappointing that there's almost nothing music or sound-related to be found in the entire book (one of the scripts does play a sound, but shells out to do so). The final chapter is about displaying a regular expression pattern as a finite state machine. Again, this is a solid, non-trivial example of running Perl, but if like me, you find regular expressions about as intrinsically fascinating as printf formatting codes, your pulse will not be racing at the prospect of slogging through all 2,000ish lines.

Overall, this is a decent if not spectacular collection. If you've learnt just enough Perl to be dangerous, but are not quite sure how to put it all together into a running program, this book provides inspiration. You might want to look at Perl Cookbook too, though.

I had high hopes for this book, but it fails on several levels.

- Most of the scripts in the book use an external module for the important work. For me this means I can't customize the script as much as I'd like to.

- A lot of the code messes around with the internals of a module. This is a terrible way to program. The end result is that now those modules have updated code and so these scripts don't work for me. Which leads me straight to:

- Most scripts just don't work.

Steve, if you are reading this, check out "Programming Perl"...it's a great place to start learning Perl.

I don't recommend this book for beginning PERL programmers as there is not enough explanation to be useful for that purpose. Beginners should read "Learning PERL" in its latest edition. However, if you are an intermediate to advanced PERL programmer this book is a good resource for all kind of problems that you might not often run into, but when you do, you might find it difficult to visualize the solution in PERL.

In the UNIX system administration section of the book, my favorites are the manual user-creation utility, and also the process killer. At the end of the book is an entire chapter dedicated to the regular expression grapher. This chapter shows you how to create a Perl script to process a regular expression text string and convert it into a decent-looking state-based graphic. In other words, you will get a PNG file with nodes representing each node, repeats, and backtracks in the regular expression.

Some of the scripts are very specific solutions to rather unique issues. For example, the author has one script where, when a key is pressed, a particular image is displayed and sound is played to entertain his toddler. Another large section of the book is dedicated to downloading and processing United States Geological Survey (USGS) topographical maps. The author is very good about explaining each script, even pointing out some troubleshooting hints in case you adapt the script to your own situation and it does not work properly. I guess I would compare this book to the "Hack" series that O'Reilly & Associates publishes on a number of specialized topics.