Refactoring to Patterns Hardcover – 5 August 2004
Enhance your purchase
Frequently bought together
From the Back Cover
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.
- 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.
About the Author
Joshua Kerievsky is the founder of Industrial Logic (http://industriallogic.com), a company specializing in Extreme Programming. Since 1988, Joshua has been a professional software developer, coach, and instructor for clients such as Bankers Trust, MTV, MBNA, Ansys, MDS Sciex, Nielsen Media Research, and Sun Microsystems. He speaks regularly at conferences, has written numerous articles, and contributed chapters to Extreme Programming Explored (Addison-Wesley, 2001) and Extreme Programming Perspectives (Addison-Wesley, 2002). Joshua lives with his wife and daughters in Berkeley, California.
- Publisher : Addison Wesley; 1st edition (5 August 2004)
- Language : English
- Hardcover : 400 pages
- ISBN-10 : 0321213351
- ISBN-13 : 978-0321213358
- Dimensions : 18.42 x 3.18 x 24.13 cm
- Best Sellers Rank: 473,357 in Books (See Top 100 in Books)
- Customer Reviews:
Review this product
Top reviews from other countries
The book, as its title implies, deals with evolving programs, and does it very well. The bulk of the book takes a relatively small number of patterns and, using real world examples, gives a step by step analysis, with Java code, of how to refactor into the pattern. As long as readers do treat these as examples, rather than something set in stone, they will find learn a lot about the arts of identifying patterns and the nitty gritty of refactoring.
I also liked the pragmatism of the author. Unlike some pattern freaks, he freely admits that there are times when using a specific pattern is overkill, especially where the problem is simple. Most people, myself included, when the idea of patterns are first grasped, tend to see patterns in everything and immediately implement them. This is frequently inappropriate, and rather than making the program structure clearer, muddies the waters. There are a number of warnings in the book against this approach.
I was very impressed by this book. In fact it is one of a small number of books that has made it to my work desk, where it fits in, both intellectually and literally, between the Gang of Four's Design Patterns, and Martin Fowler's Refactoring!
Over the years, I have read many books on refactoring techniques and they were boring and filled with unrealistic examples.
Importantly, try practicing some if not all.
Where I diverge slightly with the other reviewers is that I did find that parts of the books were very badly written, this didn't stop it being an excellent book but it was annoying. I also thought that full before/after source code would have made it much more readable, particularly for people like me who aren't used to reading densely packed Java code.
I also thought this book was a good partner to "Agile Software Development" by Robert C. Martin.