- Get it by Thursday, September 28 , Order by 12:00 PM Eastern and choose Expedited Delivery during checkout.
Prefactoring approaches software development of new systems using lessons learned from many developers over the years. It is a compendium of ideas gained from retrospectives on what went right and what went wrong in development. Some of these ideas came from experience in refactoring. Refactoring is improving the design of existing code to make it simpler and easier to maintain.
This practical, thought-provoking guide details prefactoring guidelines in design, code, and testing. These guidelines can help you create more readable and maintainable code in your next project.
To help communicate the many facets of this approach, Prefactoring follows the development of a software system for a fictitious client, named Sam, from vision through implementation. Some of the guidelines you'll encounter along the way include:
- When You're Abstract, Be Abstract All the Way
- Splitters Can Be Lumped Easier Than Lumpers Can Be Split
- Do a Little Job Well and You May Be Called Upon Often
- Plan Globally, Develop Locally
- Communicate with Your Code
- The Easiest Code to Debug Is That Which is Not Written
- Use the Client's Language
- Don't Let the Cold Air In
- Never Be Silent
- Don't Speed Until You Know Where You Are Going
|Publisher:||O'Reilly Media, Incorporated|
|Product dimensions:||7.00(w) x 9.19(h) x 0.59(d)|
About the Author
Ken Pugh has extensive experience in the area of software analysis and design, both as a doer and as a teacher. He's a well-known, frequent conference speaker.
Most Helpful Customer Reviews
Prefactoring is a concept with which I was not familiar until I read this book. The term refactoring is known to most agile programmers and is the act of re-writing and re-working code until it reaches a state of perfection. Since perfection is never achieved, the work of refactoring goes on for ever. Prefactoring on the other hand is the act of writing good code, based on all your previous software experience. Similar to a standard programming book, this book begins with the most general topics (classes, interfaces) to moves toward the more specific (implementation). While some of the author¿s ideas for prefactoring are common-sense for experienced programmers, he does share a lot of interesting ideas. As an example, he states ¿when you¿re abstract, be abstract all the way¿, suggesting that classes shouldn¿t use primitives to describe data. In other words, instead of a double to represent a dollar amount, why not use a custom type called Dollar? Additionally, why use a string to represent every type of text data? Why not use a custom type called CommonString to represent text data that consists of A-Z,0-9? Okay, so a string isn¿t a primitive, but you get the point. Throughout the book are snippets of code, discussion about good and bad design aspects and a one sentence summary of the point. This layout makes the book easy to read, quick to re-check your design, and very valuable. Now this book isn¿t designed for the beginning programmer. Prefactoring requires that you use your experience in software development to continually create better code. However, this is an excellent book for the junior-level programmer on up. Prefactoring is a very interesting concept, once which I think the author was able to successfully get me to buy into. This is also an excellent book simply for the software design guidelines. This is an excellent software architecture book, highly recommended.