Prefactoring | 
 enlarge | Author: Ken Pugh
Publisher: O'Reilly Media, Inc.
Category: Book
List Price: $29.95
Buy New: $7.88
You Save: $22.07 (74%)
New (32) Used (14) from $3.98
Rating:  20 reviews
Sales Rank: 703181
Format: Illustrated
Media: Paperback
Pages: 238
Number Of Items: 1
Shipping Weight (lbs): 0.9
Dimensions (in): 9.1 x 7 x 0.8
ISBN: 0596008740
Dewey Decimal Number: 370
EAN: 9780596008741
Publication Date: September 1, 2005
Availability: Usually ships in 1-2 business days
Shipping: Expedited shipping available
Shipping: International shipping available
Condition: Brand new book. Shipped from our NYC store. Slight Shelf wear to cover. Pages are clean and unmarked.
| |
| Similar Items:
|
| Editorial Reviews:
Product Description
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
|
| Customer Reviews: Read 15 more reviews...
 It's always good to remember the basics April 6, 2006
Matthew B. Doar (San Jose, CA USA)
3 out of 3 found this review helpful
This book does what it sets out to do: it describes some wise ideas for software design. (If the name of the book bothers you, get a grip: at least it's short.) Some of these ideas may be familiar to experienced developers, in which case it's a well-written refresher. For some of the ideas, this may be the first time you've seen them described in that way, and a different perspective is also useful.
So, what do I like about this book?
- The ideas are practical, common-sense ones.
- I like the revisiting of a small number of examples, developing them a little more each time as familiar problems with them are identified.
- The book sits comfortably in the world of Agile development, but is not rabid about it.
- Design diagrams are used sparingly, enough to educate and remind, but not overwhelmingly so.
This book covers fundamental design concepts March 5, 2006
Scott W. Ambler (Toronto, Canada)
4 out of 5 found this review helpful
When I first heard the term "prefactoring" I thought "Great, yet another marketing buzzword created solely to sell books and services." Was I ever wrong. Prefactoring summarizes, and provides concrete examples and advice, for developing high-quality code. This book covers the fundamentals which every developer should know but often don't. Among the multitude of techniques, Pugh describes how to reduce coupling, increase cohesion, take an interface-centric approach, and write literate code. Yes, the book is aimed at junior to mid-level developers, but even senior developers will gain a few new insights and will likely be reminded of several good ideas which they had long forgotten.
I'm shocked by some of the misleading reviews which this book has received (one even reviewed other reviews which misrepresented the book to begin with, what's that all about?). Pugh is very clear about refactoring, and I quote "Refactoring is the practice of altering code to improve its internal structure without changing its external behavior." So, with all due respect to the people who claim that Pugh misrepresented refactoring, did you even read the book?
The term "prefactoring" may achieve buzzword status - not because it's a marketing scam but because it represents a collection of solid technical concepts. Prefactoring is a "must read" book for anyone new to software development, and a "should read" book for everyone else. If everyone understood and followed the ideas described in this book, we'd see a doubling of productivity within the IT industry.
Ignore the naysayers, this is a good book! February 2, 2006
Mark Collins-cope
I have to admit having a smile on my face when I saw the title of this book. Not that our industry goes round in
circles or anything - but it seemed inevitable that given the rise of "refactoring" as technique, that someone
would finally say - "hey, why don't we write our code so we don't have to refactor it!"
Of course *it is* more complicated
than that - and as Ken says in the book - many of his prefactoring techniques were learned during refactoring.
Anyhow, certainly worth a look at this book - it containts a lot of good design advice that you can apply in a
pre- or post-factoring manner.
Perhaps inevitably - some Amazon reviews see this book as an attack on "agile" methods but I think they miss a fundamental point - good design advice is good design advice - regardless of whether you emphasise more design up front or refactoring existing code.
As with all books - keep an open mind - and take what you think is valuable from it!
good book for an unexperienced programmer July 14, 2008
Rafael
This book makes a lot of things (like error handling) clear. However,
it may seem not deep enough. I give it 5 stars because it did not disappoint me at all.
Draws important connections between designs and real-world applications February 7, 2006
Midwest Book Review (Oregon, WI USA)
1 out of 3 found this review helpful
Ken Pugh's Prefactoring: Extreme Abstraction, Extreme Separation, Extreme Readability: it provides software developers with insights based on author Pugh's own real-world experiences and it draws important connections between designs and real-world applications. Learn when to produce code and when to leave out troublesome lengthy versions, how to identify extreme naming problems, and how to separate policy from implementation to keep code more readable.
|
|
|
