Start reading Refactoring to Patterns (Addison-Wesley Signature Series) on the free Kindle Reading App or on your Kindle in under a minute. Don't have a Kindle? Get your Kindle here.
Programming Books C Java PHP Python Learn more Browse Programming Books

Deliver to your Kindle or other device

Enter a promotion code
or gift card
 
 
 

Try it free

Sample the beginning of this book for free

Deliver to your Kindle or other device

Sorry, this item is not available in
Image not available for
Color:
Image not available

To view this video download Flash Player

 

Refactoring to Patterns (Addison-Wesley Signature Series) [Kindle Edition]

Joshua Kerievsky
4.2 out of 5 stars  See all reviews (55 customer reviews)

Digital List Price: $54.99 What's this?
Print List Price: $67.99
Kindle Price: $31.49
You Save: $36.50 (54%)

Free Kindle Reading App Anybody can read Kindle books—even without a Kindle device—with the FREE Kindle app for smartphones, tablets and computers.

To get the free app, enter your email address or mobile phone number.

Formats

Amazon Price New from Used from
Kindle Edition $31.49  
Hardcover $54.98  
Paperback --  
Unknown Binding --  
Shop the new tech.book(store)
New! Introducing the tech.book(store), a hub for Software Developers and Architects, Networking Administrators, TPMs, and other technology professionals to find highly-rated and highly-relevant career resources. Shop books on programming and big data, or read this week's blog posts by authors and thought-leaders in the tech industry. > Shop now

Book Description

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.



Editorial Reviews

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.

From the Back Cover

Advance Praise for Refactoring to Patterns

"For refactoring to be valuable it must be going somewhere, not just an abstract intellectual exercise. Patterns document program structures with known good properties. Put the two together and you have Refactoring to Patterns." Kent Beck, Director, Three Rivers Institute

"In the GoF book we claimed that design patterns are targets for refactorings. This book finally shows that we didn't lie. By doing so, Joshua's book will deepen your understanding of both refactoring and design patterns." Erich Gamma, Eclipse Java Development Tools lead, IBM

"Refactoring to patterns is a revolutionary approach to applying patterns that combines the top-down utility of design patterns with the bottom-up discovery of iterative development and continuous refactoring. Any serious software developer should be using this approach to discover new opportunities to use patterns to improve their code." Bobby Woolf, Consulting I/T Specialist, IBM Software Services for Web- Sphere, and coauthor of Enterprise Integration Patterns (Addison-Wesley) and The Design Patterns Smalltalk Companion (Addison-Wesley).

"With this unique catalog of design-level refactorings Joshua Kerievsky has given refactoring an entirely new dimension. Refactoring to Patterns shows developers how to make design-level improvements that simplify everyday work. This book is an invaluable reference for the refactoring practitioner." Sven Gorts

"This book refactors and restructures GoF, and much more. Refactoring to Patterns takes a subject that has been presented as static and rigid and makes it dynamic and flexible, converting it into a human process with experiments, mistakes, and corrections so you understand that good designs do not occur by turning some series of cranks--they evolve through struggle and reflection. Kerievsky has also restructured the presentation to make it far clearer and easier to assimilate. Indeed, he has solved a number of the organization problems that I have struggled with in Thinking in Patterns. This book is a clear introduction and combination of the disciplines of testing, refactoring, and patterns, and it is filled with easy reading, good sense, and great insights." Bruce Eckel, President of Mindview, Inc., and author of Thinking in Java/Thinking in C++ (Prentice Hall)

"The first time I met Joshua, I was struck by the depth of his passion for understanding, applying, and teaching design patterns. Great teachers care deeply about their subject and how to share it. I think Joshua is a great teacher--and developer--and that we can all benefit from his insight." Craig Larman, Chief Scientist, Valtech, and author of Applying UML and Patterns, Second Edition (Prentice Hall) and Agile and Iterative Development (Addison-Wesley)

"Refactoring to Patterns is important not only because it provides step-by-step instructions on how to improve your code through the methodical introduction of appropriate patterns, but more so because it teaches the principles that underlie the design patterns implemented. This book should be useful for novice and expert designers alike. This is a great book." Kyle Brown, IBM Software Services for WebSphere, and author of Enterprise Java™ Programming with IBM® WebSphere®, Second Edition (Addison-Wesley)

"Mastering a trade means more than just having the right tools--you also need to use them effectively. Refactoring to Patterns explains how to wield industrial-strength design tools with the skills of an artist." Russ Rufer, Silicon Valley Patterns Group

"Josh uses patterns to guide the small steps of refactoring toward larger goals and uses refactoring to introduce patterns into your code as it evolves. You'll learn how to make large improvements to existing code incrementally, rather than trying to force-fit a prefabricated solution. As the code changes you'll go beyond seeing better designs--you'll experience them." Phil Goodwin, Silicon Valley Patterns Group

"Now the connection between software patterns and agile development is finally told." Ward Cunningham

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 importa and effectively.


Product Details

  • File Size: 2760 KB
  • Print Length: 400 pages
  • Simultaneous Device Usage: Up to 5 simultaneous devices, per publisher limits
  • Publisher: Addison-Wesley Professional; 1 edition (August 5, 2004)
  • Sold by: Amazon Digital Services, Inc.
  • Language: English
  • ASIN: B001TKD4RQ
  • Text-to-Speech: Enabled
  • X-Ray:
  • Lending: Not Enabled
  • Amazon Best Sellers Rank: #135,482 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
  •  Would you like to give feedback on images?.


Customer Reviews

Most Helpful Customer Reviews
77 of 81 people found the following review helpful
5.0 out of 5 stars A book I've been waiting for September 5, 2004
Format:Hardcover|Verified Purchase
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.
Read more ›
Comment | 
Was this review helpful to you?
46 of 49 people found the following review helpful
5.0 out of 5 stars Wonderful! Brings patterns into coding, not just designing September 19, 2004
Format:Hardcover
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!
Comment | 
Was this review helpful to you?
58 of 65 people found the following review helpful
3.0 out of 5 stars Over-complicated examples ruin a superb piece of work. November 7, 2004
Format:Hardcover
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.
Was this review helpful to you?
19 of 20 people found the following review helpful
Format:Hardcover
This book goes much further than Martin Fowler's seminal work on refactoring. Indeed, it goes further than the GoF's canonical work on patterns. By combining the two, Kerievsky breaks new ground.

The refactorings are accessible and beautifully presented. As with the GoF book, a lot of the rationale will ring a bell. "Gee, I've seen this before..." The value of these refactorings lie precisely in that corner, where the mechanics of refactoring with a GoF pattern as the goal allow one to improve the readability and maintainability of the code.

Some of the refactorings were less than obvious to me until I read this book. And that's where Kerievsky's mastery shows. He presents fresh ideas (to me, anyway) with solid examples, and thoroughly thought-out steps.

The examples deserve special mention. How many times have you read a "manual" or other technical how-to with toy examples that fail to illustrate the point? Or with examples so narrow that they hardly approach your real-world situation. (I could name names... ;->) OTOH, how many examples are so long and laborious, that gleaning any useful information requires learning the author's example-problem domain before you can get anywhere?

Kerievsky walks the tightrope between toy examples and over-engineered examples with tremendous skill. They're Goldilocks examples: Neither too big, nor too small, his examples are juuust right.

Another area in which some tightrope walking is required is presenting material that's suitable for a tutorial, vs. material that makes for easy access as a reference. Josh somehow manages to balance the two. Reading from begining to end, one is able to appreciate the tutorial nature of the material.
Read more ›
Comment | 
Was this review helpful to you?
Most Recent Customer Reviews
5.0 out of 5 stars It will improve your refactoring skills
I am not done reading this, but so far I really like it. I do a lot of refactoring and I think this will help me improve my techniques.

I recommend this book.
Published 1 month ago by Simon
4.0 out of 5 stars One of the must read books for programmers
This is a very nice book. However I believe that the author could have written it in an easier way for the reader to grasp the issues and their proposed refactoring approaches.
Published 5 months ago by Mahan
5.0 out of 5 stars if you don't use or overuse patterns...
... This is the remedy. This is a great book to put the rubber to the road on how to approach patterns in development.
Published 6 months ago by Winslow VanDevanter
4.0 out of 5 stars a pretty good book after reading other patterns introduction book
I have just finished this book. All i can tell is that this one clearly is the next book you should read after knowing basic pattern design. Read more
Published 9 months ago by Tai G. Huynh
4.0 out of 5 stars I must have for every programmer
This book is a must have for every programmer! It opens your mind to be a good and professional clean coder
Published 10 months ago by Jose R. Guilherme F.
5.0 out of 5 stars Great book for those interested in patterns. very practical.
This book paired with the GOF book is a deadly combination. I think this book is fantastic and has lots of very useful data. I don't believe it will go out of date anytime soon :). Read more
Published 10 months ago by HomeImprovement12
5.0 out of 5 stars Great book
This book was very informative and gave me a great overview of patterns. Having never worked with patterns before this book was a perfect introduction to be used for class.
Published 17 months ago by Brian Kumpf
4.0 out of 5 stars A must have in your Agile bookshelf
The first problem you encounter while adopting Agile methodologies is how to refactor the code in order to make more readable, testable and maintainable. Read more
Published 19 months ago by Raffaele Garofalo
5.0 out of 5 stars Exactly what I wanted, easy to read and understand
This book was exactly what I was looking for. While understanding the GoF Design Patterns is useful, this book goes into sufficient detail to explain them (and online searches for... Read more
Published on January 20, 2012 by K. Jordan
4.0 out of 5 stars a programming book review - to keep it real :)
This book was a timely read for me, because at work I recently ended up having to reinvent someone's medium-sized project because it contained some of the worst structured code... Read more
Published on March 12, 2011 by Lee
Search Customer Reviews
Search these reviews only

More About the Author

Discover books, learn about writers, read author blogs, and more.


Forums

Search Customer Discussions
Search all Amazon discussions

Start a new discussion
Topic:
First post:
Prompts for sign-in
 



Look for Similar Items by Category