Refactoring to Patterns (Addison-Wesley Signature Series) (Hardcover)

by Joshua Kerievsky (Author)

Editorial Reviews

Product Description

This is the eBook version of the printed book. If the print book includes a CD-ROM, this content is not included within the eBook version.

In 1994, Design Patterns changed the landscape of object-oriented development by introducing classic solutions to recurring design problems. In 1999, Refactoring revolutionized design by introducing an effective process for improving code. With the highly anticipated Refactoring to Patterns, Joshua Kerievsky has changed our approach to design by forever uniting patterns with the evolutionary process of refactoring.

This book introduces the theory and practice of pattern-directed refactorings: sequences of low-level refactorings that allow designers to safely move designs to, towards, or away from pattern implementations. Using code from real-world projects, Kerievsky documents the thinking and steps underlying over two dozen pattern-based design transformations. Along the way he offers insights into pattern differences and how to implement patterns in the simplest possible ways.

Coverage includes:

• A catalog of twenty-seven pattern-directed refactorings, featuring real-world code examples
• Descriptions of twelve design smells that indicate the need for this book’s refactorings
• General information and new insights about patterns and refactoring
• Detailed implementation mechanics: how low-level refactorings are combined to implement high-level patterns
• Multiple ways to implement the same pattern—and when to use each
• Practical ways to get started even if you have little experience with patterns or refactoring

Refactoring to Patterns reflects three years of refinement and the insights of more than sixty software engineering thought leaders in the global patterns, refactoring, and agile development communities. Whether you’re focused on legacy or “greenfield” development, this book will make you a better software designer by helping you learn how to make important design changes safely and effectively.

--This text refers to the Kindle Edition edition.

From the Publisher
In 1994, Design Patterns changed the landscape of object-oriented development by introducing classic solutions to recurring design problems. In 1999, Refactoring revolutionized design by introducing an effective process for improving code. With the highly anticipated Refactoring to Patterns, Joshua Kerievsky has changed our approach to design by forever uniting patterns with the evolutionary process of refactoring.

This book introduces the theory and practice of pattern-directed refactorings: sequences of low-level refactorings that allow designers to safely move designs to, towards, or away from pattern implementations. Using code from real-world projects, Kerievsky documents the thinking and steps underlying over two dozen pattern-based design transformations. Along the way he offers insights into pattern differences and how to implement patterns in the simplest possible ways.

Coverage includes:

A catalog of twenty-seven pattern-directed refactorings, featuring real-world code examples
Descriptions of twelve design smells that indicate the need for this book’s refactorings
General information and new insights about patterns and refactoring
Detailed implementation mechanics: how low-level refactorings are combined to implement high-level patterns
Multiple ways to implement the same pattern—and when to use each
Practical ways to get started even if you have little experience with patterns or refactoring

Refactoring to Patterns reflects three years of refinement and the insights of more than sixty software engineering thought leaders in the global patterns, refactoring, and agile development communities. Whether you’re focused on legacy or "greenfield" development, this book will make you a better software designer by helping you learn how to make important design changes safely and effectively.

See all Editorial Reviews

Product Details

• Hardcover: 400 pages
• Publisher: Addison-Wesley Professional (August 15, 2004)
• Language: English
• ISBN-10: 0321213351
• ISBN-13: 978-0321213358
• Product Dimensions: 9.4 x 7.2 x 1.2 inches
• Shipping Weight: 2.2 pounds (View shipping rates and policies)
• Average Customer Review: 4.1 out of 5 stars See all reviews (44 customer reviews)
• Amazon.com Sales Rank: #142,436 in Books (See Bestsellers in Books)

• This item is part of The Signature Series.

Customer Reviews

Most Helpful Customer Reviews

60 of 64 people found the following review helpful:

5.0 out of 5 stars A book I've been waiting for, September 5, 2004

By	wiredweird "wiredweird" (Earth, or somewhere nearby) - See all my reviews (TOP 100 REVIEWER)

Kerievsky has done it. He has started to pull together anti-patterns (a.k.a. "bad smells"), refactorings, and patterns into one unified study. All three work well individually. Together, they make a powerful combination.

This isn't as rigorously analytic as the original Design Patterns book. I fully expect more theory-oriented writers to follow the trail blazed here. Instead, Kerievsky gives worked examples, in great detail. At every point, he starts with a code sample drawn from real life, complex enough to be interesting. Then, step by step, he shows the incremental changes made to transition from it's problematic start to its pattern-based end point. Experienced programmers may find this plodding and repetitive. Beginners, however, often have a hard time planning incremental changes and executing them. The author takes care to keep the code in working order at each increment, showing a clear path through the forest of possibilities. Some readers may even trace the path backwards, giving another look at how each change moves toward the end state. The worked examples are the real strength of this text.

This is a book for the software maintainer. In other words, it addresses 90% or 99% of the work that real programmers do. Just about every other software text on the market assumes that the project just started - the disks are empty and the compiler shrink-wrap is on the floor. I admit, that kind of programming is the most fun. It's just not realistic, though. Most work is rework, the kind demonstrated here.

Another great feature of this book is what it lacks: dogmatic harangues about methodology. It even keeps a skeptical attitude towards patterns, since heavyweight design techniques aren't always right for lightweight problems. Kerievsky mentions agile-ism, but doesn't make it a part of the process. He does, however, take the continuous testing idea from the eXtremists and work that into the demonstrations. Bravo! Hardware designers may wonder what the fuss is about, since thorough testing has been part of their culture for years. It's a happy novelty in much of the software world, though, and deserves to become standard practice.

My only problem with this book is that there isn't more of it. For example, constructor chaining is a great idea. There are two kind of chain, though. He shows the increasing parameter list, where simpler constructors supply default values for the more ones with more parameters. It's also possible to chain in decreasing order, where each constructor processes one parameter and passes on the simplified list. (What's good for constructors, of course, is also good for other collections of related methods.)

The book's ideal reader understands an OO language, uses subclassing regularly, and knows something about design patterns. That reader, with enough patience to follow the examples, will learn a lot. More experienced developers won't need the step by step approach, but may benefit from seeing multiple refactorings working together to solve a complex problem. It has my highest recommendation for any developer who really thinks about design and redesign.

//wiredweird

40 of 43 people found the following review helpful:

5.0 out of 5 stars Wonderful! Brings patterns into coding, not just designing, September 19, 2004

By	Michael Cohn "agile developer" (Lafayette, CO USA) - See all my reviews (REAL NAME)

Based on its title alone I had high expectations for this book. It didn't disappoint. The book takes two of the most important advances of the past decade (patterns and refactoring) and puts them together into a whole that is definitely more than the sum of its parts.

I've read many good patterns books and have been applying patterns to how I think and talk about software since the original "Design Patterns" book in 1995. However, something was always missing. Through my consulting work, whenever I introduced patterns to a new team they would take quickly to the idea and patterns would become part of how they thought-but only when designing, not when coding. Since we spent more time coding than designing, patterns played less of a role than they could have.

This book does an excellent job of bringing patterns into coding, rather than relegating them just to design discussions. As the author points out, "patterns are best viewed in the light of refactoring and that they are destinations best reached by applying sequences of low-level refactorings."

This book has earned a permanent place on my bookshelf. That is, when it's not open beside me as I program. Very highly recommended!

35 of 39 people found the following review helpful:

3.0 out of 5 stars Over-complicated examples ruin a superb piece of work., November 7, 2004

By	Bibek (UK) - See all my reviews

This book is the only one of its kind that tries to use a patterns approach to refactoring. It is a good add-on to Martin Fowler's book. It's a very valuable contribution to the refactoring community. Kerievsky has a no-nonsense, down-to-earth approach to the subject of Patterns. However unlike Fowler who makes an effort to keep the code examples in his book as simple as possible, Kerievsky has made his examples over-complicated with all kinds of detailed finance domain references and the XML DOM. The example he uses to show how the Builder pattern simplifies creation of Composites is like a really heavy chapter on XML processing/generation.
The "Replace Conditional Logic with Strategy" is like a chapter on Investments / Loans. It really distracts the reader's attention from the pattern or refactoring.
This is a shame because it is impossible to write a good book on refactoring without nice examples. It is also a bit surprising that none of the other Amazon reviews mention this issue.