Customer Reviews

Perl Hacks: Tips & Tools for Programming, Debugging, and Surviving

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

 

 

This book is for experienced working Perl programmers - most likely system administrators but not necessarily - that need working solutions to real problems you'll most likely find in the workplace. There are a few diversions into such "cute" ideas as building animations in Perl, but most of these hacks are for the working programmer who is looking for ways to automate processes, build interfaces that don't get in the way of developers, and thoroughly test and simulate code. Amazon does not show the table of contents so I review this book in the context of the table of contents.
Chapter 1, Productivity Hacks
The hacks in this chapter are about relentless automation - saving time and effort. They allow you to find the information you want, automate repeated tasks, and find ways not to have to think about things that you do all the time.
Chapter 2, User Interaction
Menus, graphics, beeps, and command lines: these are all ways your programs grab user attention. This chapter is about keeping your users happy and even making your interfaces "pretty" with Perl. People may not notice when your code stays out of their way, but you know by their grimaces when it becomes an obstacle. My favorite hack in this chapter was Hack #16 "Interactive Graphical Apps". This uses sdlperl, which is a binding of the C low-level graphical library SDL for the Perl language. The hack is a short example program animating a colored rectangle and its fading tail. It first creates the needed series of surfaces, with a fading color and transparency, then animates sprites along a periodic path. It is a good example of using a GUI in PERL.
Chapter 3, Data Munging
Perl exists to extract, reformat, and report data. This chapter is about novel ways to connect to data and databases that are not "kludgy". For example, Hack #21 is "Use Any Spreadsheet As a Data Source". In it you use the Spreadsheet::Read module to give you a single interface to the data of most spreadsheet formats available, hiding all the troublesome work that deals with the parsers and portability, yet being flexible enough to get to the guts of the spreadsheet.
In Hack #20, "Read Files Backwards" suppose you have a server process that continually writes its status to a file. You only care about its current status, not its historical data. If its status is up, everyone is happy. If its status is down, you need to panic and notify everyone, thus you need to read the log file backwards and this hack shows you how.
Chapter 4, Working with Modules
Perl 5's greatest invention is the concept of the module - a unit of reusable code.
If you're doing any serious work with Perl, you'll spend a lot of time working with modules: installing them, upgrading them, loading them, working around weird and unhelpful features, and even distributing them. It makes a lot of sense to understand how Perl and modules interact and how to work with them effectively.
Chapter 5, Object Hacks
Abstraction, encapsulation, and genericity are the keys to designing large, maintainable systems. Some people claim that Perl doesn't really do OO, but they're wrong and these hacks demonstrate that by building some powerful abstractions.
Chapter 6, Debugging
Someday you'll have to dig through a pile of Perl left by an obnoxious coworker. This chapter prepares you for the worst with a toolkit full of tips and techniques to disarm the weirdest code you can imagine.
Chapter 7, Developer Tricks
Maintaining a program is different from maintaining an entire system. This is doubly true if you work with other people. If anything, discipline and consistency are more important than ever. This chapter is all about testing code, working with benchmarks, and even simulating hostile environments.
Chapter 8, Know Thy Code
If you really want to take advantage of the deeper mysteries of Perl, you have to be able to look deeply into the language, the libraries, and the interpreter itself--as well as your own code--and understand what's happening.
Chapter 9, Expand Your Perl Foo
This chapter explores a few of the odder ideas in the world of Perl. Then you'll be ready to discover your own. The explicit list of hacks is as follows:
Chapter 1. Productivity Hacks
Hack 1. Add CPAN Shortcuts to Firefox
Hack 2. Put Perldoc to Work
Hack 3. Browse Perl Docs Online
Hack 4. Make the Most of Shell Aliases
Hack 5. Autocomplete Perl Identifiers in Vim
Hack 6. Use the Best Emacs Mode for Perl
Hack 7. Enforce Local Style
Hack 8. Don't Save Bad Perl
Hack 9. Automate Checkin Code Reviews
Hack 10. Run Tests from Within Vim
Hack 11. Run Perl from Emacs
Chapter 2. User Interaction
Hack 12. Use $EDITOR As Your UI
Hack 13. Interact Correctly on the Command Line
Hack 14. Simplify Your Terminal Interactions
Hack 15. Alert Your Mac
Hack 16. Interactive Graphical Apps
Hack 17. Collect Configuration Information
Hack 18. Rewrite the Web
Chapter 3. Data Munging
Hack 19. Treat a File As an Array
Hack 20. Read Files Backwards
Hack 21. Use Any Spreadsheet As a Data Source
Hack 22. Factor Out Database Code
Hack 23. Build a SQL Library
Hack 24. Query Databases Dynamically Without SQL
Hack 25. Bind Database Columns
Hack 26. Iterate and Generate Expensive Data
Hack 27. Pull Multiple Values from an Iterator
Chapter 4. Working with Modules
Hack 28. Shorten Long Class Names
Hack 29. Manage Module Paths
Hack 30. Reload Modified Modules
Hack 31. Create Personal Module Bundles
Hack 32. Manage Module Installations
Hack 33. Presolve Module Paths
Hack 34. Create a Standard Module Toolkit
Hack 35. Write Demos from Tutorials
Hack 36. Replace Bad Code from the Outside
Hack 37. Drink to the CPAN
Hack 38. Improve Exceptional Conditions
Hack 39. Search CPAN Modules Locally
Hack 40. Package Standalone Perl Applications
Hack 41. Create Your Own Lexical Warnings
Hack 42. Find and Report Module Bugs
Chapter 5. Object Hacks
Hack 43. Turn Your Objects Inside Out
Hack 44. Serialize Objects (Mostly) for Free
Hack 45. Add Information with Attributes
Hack 46. Make Methods Really Private
Hack 47. Autodeclare Method Arguments
Hack 48. Control Access to Remote Objects
Hack 49. Make Your Objects Truly Polymorphic
Hack 50. Autogenerate Your Accessors
Chapter 6. Debugging
Hack 51. Find Compilation Errors Fast
Hack 52. Make Invisible Characters Apparent
Hack 53. Debug with Test Cases
Hack 54. Debug with Comments
Hack 55. Show Source Code on Errors
Hack 56. Deparse Anonymous Functions
Hack 57. Name Your Anonymous Subroutines
Hack 58. Find a Subroutine's Source
Hack 59. Customize the Debugger
Chapter 7. Developer Tricks
Hack 60. Rebuild Your Distributions
Hack 61. Test with Specifications
Hack 62. Segregate Developer and User Tests
Hack 63. Run Tests Automatically
Hack 64. See Test Failure Diagnostics -- in Color!
Hack 65. Test Live Code
Hack 66. Cheat on Benchmarks
Hack 67. Build Your Own Perl
Hack 68. Run Test Suites Persistently
Hack 69. Simulate Hostile Environments in Your Tests
Chapter 8. Know Thy Code
Hack 70. Understand What Happens When
Hack 71. Inspect Your Data Structures
Hack 72. Find Functions Safely
Hack 73. Know What's Core and When
Hack 74. Trace All Used Modules
Hack 75. Find All Symbols in a Package
Hack 76. Peek Inside Closures
Hack 77. Find All Global Variables
Hack 78. Introspect Your Subroutines
Hack 79. Find Imported Functions
Hack 80. Profile Your Program Size
Hack 81. Reuse Perl Processes
Hack 82. Trace Your Ops
Hack 83. Write Your Own Warnings
Chapter 9. Expand Your Perl Foo
Hack 84. Double Your Data with Dualvars
Hack 85. Replace Soft References with Real Ones
Hack 86. Optimize Away the Annoying Stuff
Hack 87. Lock Down Your Hashes
Hack 88. Clean Up at the End of a Scope
Hack 89. Invoke Functions in Odd Ways
Hack 90. Glob Those Sequences
Hack 91. Write Less Error-Checking Code
Hack 92. Return Smarter Values
Hack 93. Return Active Values
Hack 94. Add Your Own Perl Syntax
Hack 95. Modify Semantics with a Source Filter
Hack 96. Use Shared Libraries Without XS
Hack 97. Run Two Services on a Single TCP Port
Hack 98. Improve Your Dispatch Tables
Hack 99. Track Your Approximations
Hack 100. Overload Your Operators
Hack 101. Learn from Obfuscations

If your a serious Perl programmer or a long-time Perl scripter whose looking to broaden your horizons then this is an excellent book. Surprisingly, this is really a Perl book for professional Perl developers, sys-admins, and scripters. This book avoids parlor-tricks like "Controlling your coffee maker with Perl" and focuses on how best to make writing and testing Perl code quick, easy, and sometimes even fun.

O'Reilly's "Hacks" series of books have been hit or miss. Many books in this series regurgitate the basics a veteran probably already knows or provide convoluted or contrived examples that usually try to do too much, leaving you to extrapolate to the problem at hand. "Hacks" books can often contain an overabundance of gimmicks or games which, while instructive, can only have practical considerations for very few programmers. Some of these flaws would be acceptable in a book about "gaming" or "tuning your car" for non-professionals; this book is for people who know Perl and want to do more with it.

Perl is a language that often gets called on for quick and dirty tasks so perhaps it's natural that the book has allot of excellent advice. This book manages to not reiterate the information of the core Perl book trilogy ("Learning Perl", "Programming Perl" and the "Perl Cookbook"). Instead it focuses on practical UI, database, and developer tips and tricks. It assumes you know how to put Perl through it's paces and focuses on helping you do things more effectively.

I won't repeat the table of contents except to say that object-oriented programming, modules, user-interfaces, databases, and debugging are given plenty of coverage. If you find yourself working more with modules and packages, don't debug your Perl programs with print statements anymore, or are buried under unorganized Perl spaghetti then this book is for you.

I can't recommend this to a Perl beginner. You're much better off with perldoc or "Learning Perl". It's not a "101 things you can do with regular expressions" book either. If you write one-liner Perl scripts and never wish to move beyond that then this isn't your book either.

I'm not a "professional" Amazon reviewer. I just read this book and like what I've read and examples I've used. Perl has become a daily part of my job and it's books like these that demonstrate it to be capable language for rapid long-term development. It's odd that a book in the "Hacks" series so clearly demonstrates that Perl is capable of so much more.

To be completely honest, this isn't the book I thought it was going to be. Most O'Reilly Hacks books start off pretty simply and in a few chapters take you to the further reaches of their subject area. Whilst this is a great way to quickly get a good taste of a particular topic, it has the occasional disadvantage that for subjects that you know well, the first couple of chapters can seem a bit basic. As I know Perl pretty well, I thought I would be on familiar ground for at least half of the book.

I was wrong.

Oh, it started off easily enough. Making use of various browser and command line tools to get easy access to Perl documentation, creating some useful shell aliases to cut down typing for your most common tasks. "Oh yes", I thought smugly to myself, "I know all that". But by about Hack 5 I was reading about little tweaks that I didn't know about. I'd start a hack thinking that I knew everything that the authors were going to cover and end up frustrated that I was on the tube and couldn't immediately try out the new trick I had just learnt.

It's really that kind of book. Pretty much everyone who reads it will pick up something that will it easier for them to get their job done (well, assuming that their job involves writing Perl code!) And, of course, looking at the list of authors, that's only to be expected. The three authors listed on the cover are three of the Perl communities most respected members. And the list of other contributers reads like a who's who of people who are doing interesting things with Perl - people whose use.perl journals are always interesting or whose posts on Perl Monks are worth reading before other people's. Luckily, it turns out that all these excellent programmers can also explain what they are doing (and why they are doing it) very clearly.

Like all books in the Hacks series, it's a little bitty. The hacks are organised into nine broad chapters, but the connections between hacks in the same chapter can sometimes be a bit hard to see. But I enjoyed that. In places it made the book a bit of a rollercoaster ride. You're never quite sure what is coming next, but you know it's going to be fun.

In fact, the more I think about it, the more apt the fairground analogy seems. When you ask Perl programmers what they like about Perl, you'll often hear "fun" mentioned near the top of the list. People use Perl because they enjoy it. And the authors' enjoyment of Perl really comes through in the book. It's obvious that they really wanted to show people the things that they thought were really cool.

Although I did learn useful tips from the earlier part of the book, it was really the last three chapters that were the most useful for me. Chapter 7, Developer Tricks, had a lot of useful things to say about testing, Chapter 8, Know Thy Code, contains a lot of information on using Perl to examine your Perl code and Chapter 9, Expand Your Perl Foo was a grab-bag of obscure (but still useful) Perl tricks.

So where does this book fit in to O'Reilly's Perl canon? I can't recommend it for beginners. But if you're a working Perl programmer with a couple of years' experience then I'd be very surprised if you didn't pick up something that will be useful to you. And don't worry about it overlapping with other books in your Perl library - offhand I can't think of anything in the book that has been covered in any previous Perl book.

All in all, this would make a very useful addition to your Perl library.

In a time when new computer languages are dime a dozen, perl unquestionably retains its beauty. Keeping with the philosophy of perl - there is more than one way to do it - the book shows you ingenious ways to work with this powerful language. This is a true hacks book and meant mostly for the advanced user. Before reading this book, I didn't even realize what I didn't know and I rate myself just short of contributing to CPAN. Even if you have read all the popular books - Perl Programming, Perl Best Practices etc. you'll still find a lot of gems.

Simply put if you like perl, you'll love this book. Welcome to the next level...

From the title, I wasn't quite sure what to expect from Perl Hacks. Was it going to be about rummaging around in Perl's internals? Making Perl do clever, yet ultimately dumb and pointless tricks? It turns out that, while there is some fairly voodooish material here, some of it quite playful, on the whole it's a very practical book. Aimed firmly at the advanced Perl programmer who knows when it's appropriate to mess about with the symbol table, temporarily turn off warnings, or crack out one of the B:: modules, this is a collection of 101 suggestions to improve your productivity, boggle your mind about what Perl can do, or both.

The content reminds me a little of the likes of Exceptional C++ Style, a mixture of advanced best practices, and things which you may not need to know, but you'll probably still be interested in finding out how it works. For instance, have you ever considered tieing an array or hash variable to a function? Ever wanted to name a supposed anonymous subroutine? Print out the source code as well as the line number of a syntax error? Nor me, but Perl Hacks shows how it could be useful. These are illustrative of the spirit of the book.

My favourite material was probably the chapter on modules. Included are how-tos for outputting all the modules used in a package, automatically reloading modules in running code, shortening long package names with the CPAN 'aliased' module, and making up your own bundle of modules for easy installation. There's also an interesting object chapter with subjects such as: inside out objects, using YAML for serialisation, using traits and autogeneration of accessors.

Additionally, there's a little on using those scary B:: packages, using modules which use the B:: packages or other dark magic (e.g. peeking inside closures), some fairly hardcore tracing and profiling, that touches on some Perl VM internals. Also worth mentioning is the hack that hijacks the angle bracket glob operator to create Haskell/Python-style list comprehensions.

You are going to have to be one scarily gifted Perl hacker not to find something useful or at least thought-provoking at regular intervals throughout this book. My only complaint is that the hack format, which the blurb on the back of the book describes as a "short lesson", does not lend itself equally well to all hacks. While I liked the chapter on objects, some of the hacks (in particular the traits hack, some of the testing material) were too short.

If you like the sound of a book that's somewhere between Perl Cookbook, Perl Best Practices and the second edition of Advanced Perl Programming, you're going to love this.

Perl is my workhorse language. I've written more Perl code, both personally and professionally, than any other language I've learned. Whenever I receive a new project, I immediately think of how I would accomplish it quickly in Perl. I've also been a fan of O'Reilly's "Hacks" series of books. When I heard of the marriage of Perl and O'Reilly's "Hacks" series in the book Perl Hacks, I knew I had to pick up a copy. It was a match made in heaven. The nature of Perl for terse, yet powerful constructs, and the hackish nature of the "Hacks" series makes for one of my favorite books in this series. The collection of articles in Perl Hacks are great for putting more productivity into your programming experience.

Those of you not familiar with O'Reilly's "Hacks" Series may need an introduction. The "Hacks" Series is an ever-growing set of books with focused attention on a particular topic, like Astronomy, Mental Improvement, or even Halo 2. The books are generally short, and contain article-length "hacks" of varying difficulty, noted by a thermometer next to the hack number and description. These "hacks" fall into several categories; the non-obvious solution to a problem, the performance improvement, and the "gee, I didn't know it could do that" oddity. What makes this series special compared with other books is the willingness to "void the warranty" on a particular product, and get straight to the internals, whether they lay in hardware or software. If something can be made better by opening the covers, or twiddling with the program layout, then its eligible for inclusion in these books. The series lends itself to a wide range of topics, and the format is great for a quick read, or for (my favorite) just randomly opening the book and reading what's there.

Perl Hacks is not a book that you'd find yourself reading straight through (although you do want to make sure you visit every hack in the book at least once). The book is divided into nine chapters: Productivity Hacks, User Interaction, Data Munging, Working with Modules, Object Hacks, Debugging, Developer Tricks, Know Thy Code, and Expand Your Perl Foo. There are 101 hacks in this book, ranging from the simple (Reading files backward, or managing your module paths) to the truly perverse (Replacing bad code without touching it by substituting the system-wide exit call with your own[...]. Each hack title is listed in the table of contents, with both the page number and the hack number. Each hack contains a graphic of a thermometer next to the number to show the relative difficulty of the hack (higher temperatures = more difficult hacks). There quite a variety of hacks placed throughout the book. Not once did I feel that the book was padded with something that really didn't belong in the book. If anything Perl Hacks opened my eyes to things that I would never have thought to do, but could easily see as being useful. I wouldn't have thought to create my own personal module bundles for moving my Perl programs between machines (I've always done it the old fashioned way: run, cpan install, repeat), but hack #31 makes it so "of course" that I'm thinking of including this in all of my Perl code that I ship. Hack #74 shows how to trace all of the modules your program uses (and all of their modules, too). Hack #52 is a simple hack ("Make Invisible Characters Apparent") but I can see this saving a developer or two some time when figuring out why their code isn't behaving properly. Of course, not all hacks in the book are productive (at least, not while you're programming). Hack #37, "Drink to the CPAN" is a drinking game you and your Perl buddies may want to try.

Perl Hacks is a short book, at less than 300 pages, but it's loaded with incredibly useful information. Much like the "Perl Cookbook" (also from O'Reilly) you'll find lots of useful items hidden in their pages. Many times I started with one hack, and finished the chapter reading the rest of the hacks because there were just that interesting. Perl Hacks is highly recommended for any Perl programmer to have on their programmer book shelf. Sure, you might be able to find some of the hacks out there on the net, but I think you'll find as I have that this is more of a go-to reference for finding out some of the more interesting corners of Perl.

I received this book as a token of appreciation for my contributions to
the 2006 Perl Advent Calendar. It's the first book I read as part of the
O'Reilly Hacks' series of books, and it proved to be a light yet informative and entertaining
read.

The book covers various useful "hacks" or small tricks that allow one to
achieve a lot of cool tasks when working with Perl. These tricks are unorthodox
and stretch the limit of one's Perl knowledge. Since they require an advanced
knowledge and understanding of Perl, I would recommend this book only for Perl
experts. Some of the B:: using modules were even too high-level for me to
understand how they worked internally. However, I understood the purpose of the
code in all cases, even if I didn't understand the code itself.

So it is a recommended read for people who've worked with Perl a lot,
and wish to learn many new and useful tricks. Perl Hacks for Perl hackers,
indeed!

Perl hacks is an intriguing book which explores specific problems and their quite practical solutions. This book is easy to dive in and out of. It reads more like a collection of bite sized detective stories rather than a novel.

Either novice or guru Perl coders will discover great solutions to issues they don't even know that they are having. It's continually clever, surprising, and astonishingly useful.

Part of what is most astonishing is that the cures to even monumental ailments are so short and sweet. Perl Hacks is a great way to rediscover how awesome Perl is.

Imagine that chromatic were to write a professional once-a-week blog for the span of about two years, with edits and ideas from Damian Conway and Curtis "Ovid" Poe, focusing on cool Perl tricks. The result would look very similar to the Perl Hacks book.

The book is filled with lots of small, self-contained gems. I've put a few of these ideas into immediate practice, like Smart::Comments. Other ideas solve problems that I didn't think had any simple solutions, like reading files backwards, which I'll use the next time I need it. Many of their ideas are curriosities, the sorts of things that are kinda cool but I never think I'll need like vi and emacs hacks, or database stuff; still, knowing that they are there and where to read more makes me much more likely to use those tools if ever the need arises.

In all I'm very pleased with my purchase and I would recommend it to others. You're almost certain to find a few ideas that you can put into immediate use and many ideas that you'll bookmark mentally so you can use them in the future.

I've learned enough from the first two chapters along to justify the price of this book. Even if you are an intermediate Perl programmer, this book has various tidbits that will improve your code. If anything, I would call this the Perl Cookbook 2. It may not be as big as the original cookbook, but the recipes in here can save you time and make your code more correct.

This should be a definite buy for anyone who writes Perl scripts for work or pleasure, regardless of experience.