- Paperback: 336 pages
- Publisher: Addison-Wesley Professional; 1 edition (March 15, 2004)
- Language: English
- ISBN-10: 0201795264
- ISBN-13: 978-0201795264
- Product Dimensions: 6.9 x 0.8 x 9.1 inches
- Shipping Weight: 1.2 pounds
- Average Customer Review: 8 customer reviews
- Amazon Best Sellers Rank: #1,763,088 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Perl Medic: Transforming Legacy Code 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Customers who bought this item also bought
Perl ranks among hackers' favorite languages--there's always another approach to a problem, always optimization to be done, and forever new techniques to try. Perl's a hoot. But the culture of tinkering that surrounds Perl has resulted in a large body of hard-to-understand legacy code. That legacy code has to be maintained, extended, and adapted to new conditions--often without the help of the person who originally created it. Perl Medic considers Perl from the perspective of a programmer looking at code written by someone else and trying to answer the ancient question: "What were they thinking?"
It's a creative approach, and one that makes good reading for someone well-versed in Perl programming (author Peter Scott makes the analogy of becoming fluent in a human language, such as French, then studying its various accents and dialects). He shows, for example, a kludgy piece of code that's meant to catch CGI form uploads, then indicates that the obvious replacement is the CGI.pm module. Elsewhere, Scott shows why symbolic references are bad, and how to avoid them by means of hashes. Some of the value in this book is in the form of documentation of the differences among Perl versions; other useful coverage deals with warnings and strictness control as debugging tools. Read this straight through to improve your own code; use the index to help decipher and improve what someone else has written. --David Wall
Topics covered: How to write good Perl code, read bad Perl code, and convert bad Perl code into good in less time that would be required to write an equivalent replacement program from scratch. Testing, debugging, documenting, replacing custom code with CPAN modules, and embracing features that became available in later versions of Perl are all covered. Overall, the author endorses and generally explains the principles of Extreme Programming (XP) for Perl work.
From the Back Cover
- Cure whatever ails your Perl code!
- Maintain, optimize, and scale any Perl software... whether you wrote it or not
- Perl software engineering best practices for enterprise environments
- Includes case studies and code in a fun-to-read format
If you code in Perl, you need to read this book.—Adam Turoff, Technical Editor, The Perl Review.
Scott's explanations of complex material are smooth and deceptively simple. He knows his subject matter and his craft-he makes it look easy. Scott remains relentless practical-even the 'Analysis' chapter is filled with code and tests to run.—Dan Livingston, author of several computer books including Advanced Flash 5: Actionscript in Action
Bring new power, performance, and scalability to your existing Perl code!
Today's Perl developers spend 60-80% of their time working with existing Perl code. Now, there's a start-to-finish guide to understanding that code, maintaining it, updating it, and refactoring it for maximum performance and reliability. Peter J. Scott, lead author of Perl Debugged, has written the first systematic guide to Perl software engineering. Through extensive examples, he shows how to bring powerful discipline, consistency, and structure to any Perl program-new or old. You'll discover how to:
- Scale existing Perl code to serve larger network, Web, enterprise, or e-commerce applications
- Rewrite, restructure, and upgrade any Perl program for improved performance
- Bring standards and best practices to your entire library of Perl software
- Organize Perl code into modules and components that are easier to reuse
- Upgrade code written for earlier versions of Perl
- Write and execute better tests for your software...or anyone else's
- Use Perl in team-based, methodology-driven environments
- Document your Perl code more effectively and efficiently
If you've ever inherited Perl code that's hard to maintain, if you write Perl code others will read, if you want to write code that'll be easier for you to maintain, the book that comes to your rescue is Perl Medic.On the Web Site
Download all of the book's sample code from <www.perlmedic.com>.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
There is more advice on code style, low-level stuff like brace indentation and choosing decent variable names. Additionally, tracing, profiling, benchmarking and logging are again introduced. Some of this is admittedly rather reminiscent of what appeared in Perl Debugged. Happily, also present is the clear writing, which is informal without ever talking down to the reader.
Perl Medic, however, has a more agile flavour than Perl Debugged. Again, there is a chapter on unit testing, but it's much more fleshed out in this book, featuring far more modules, and providing an entire Test Driven Development example of a bounds-checked array.
Also, some refactorings are introduced, such as inlining temporary variables and extracting subroutines. The final chapter of the book is a refactoring example on some ancient Perl 4 cgi code, that pulls together most of the themes of the book.
There's also an in-depth discussion of what the strict and warnings pragmas entail, beyond that provided by most books. Also worthy of note is the chapter on 'cargo cult' Perl, where the author's pet peeves about non-idiomatic Perl code are explored, from practices which are merely pointless to the downright wrong.
Much of this material is general good practice. However, there are some chapters that help to justify the 'legacy code' approach. Chapter 7 provides a potted history of the different versions of Perl from Perl 4 onwards, and how to spot which version a program was targetted at. There is some mention of legacy code in the unit testing chapter, but not much.
In general, I think a lot of the suggestions will be obvious to anyone with experience with Perl, or experience with another modern programming language: use new modules from CPAN where you can, use lexically scoped (my) variables and localise global access and, of course, turn on strict and warnings. Overall, I wasn't much convinced with the 'legacy code' aspect of the book and the strained medical metaphor renders many of the chapter names nonsensical.
Another slight problem I had is that, like Perl Debugged, there can be a lack of flow between (and sometimes within) chapters. Chapter 10, nominally about maintainability, starts with assertions and Eiffel-style contract programming, and then goes onto logging, tieing, overloading, POD and version control integration. It's hard to see this as a cohesive whole.
If you're looking for a book on dealing with legacy code, Michael Feathers' Working Effectively with Legacy Code provides more bang for your buck -- although it's not Perl-specific (in fact, I'm pretty sure there's no Perl code in it at all). However, if you're a budding agilist looking for Perl-based examples of refactoring and TDD, then this is a good choice. Less experienced Perl programmers should definitely consider this, especially alongside Perl Debugged, as it provides both a good grounding in best practices, and more advanced development skills such as profiling and code coverage.
Perl gets a lot of bad press from people who claim that it encourages people to write unreadable code. Whilst there's certainly a lot of very bad Perl code out there I think that's more a sign that it's used by a lot of people who don't know how to program than a reflection on the language itself. And that's where this book comes in. It assumes that you are familiar with the syntax of Perl but that you've never really been shown how to use it effectively. Which is a situation that many Perl programmers find themselves in.
Perl Medic is actually targetted at people who have to maintain older Perl code written by someone else, but I think that the information it contains is just as useful to anyone coding in Perl. Peter Scott has a lot of experience in writing Perl and in training other people to write Perl and the distillation of that experience and knowledge into these 300-odd pages mean that there are few Perl programmers who won't pick up something useful from this book.
The main emphasis in the book is on increasing the maintainability of code. The techniques are wide-ranging. I particularly enjoyed the examples of refactoring programs and the coverage of using modules from CPAN. Two other very good sections are the one on antipatterns in chapter 4 and the one on cargo cult programming in chapter 6. Together these sections give a programmer a number of easy to recognise quick wins when improving existing code and a checklist of things not to do when writing new code.
There are a couple of niggles. I've already mentioned that I think the book has been slightly mis-targetted and that it should have been aimed at anyone writing Perl code. The other problem that I had was that the medic analogy that runs through the book gets a bit strained at times. But these are only minor and they shouldn't prevent you from adding this book to your library.
In fact, all in all, the quote on the front cover is pretty accurate.
Most recent customer reviews
In fact it's my only regret about this book...
This book is an absolute "must have" for every Perl beginner.Read more