Refactoring to Patterns (Addison-Wesley Signature Series)

Rating:
Summary: A High Quality Reference for Agile Developers
Review: A high quality reference for those that want to gain some direction to their refactoring. That's what Joshua Kerievsky has managed to create with this book. This book assumes that you already know about refactoring and even states clearly that this book is best read with Martin Fowler's "Refactorings" as a reference. With that prerequisite in mind, this text does an excellent job of introducing the process of using refactorings to fix code problems by introducing patterns into your design.

Some of the strongest points include: editing, organization, and clarity. My hat goes off to the editor(s) of this book as I found very few errors even though this book contains a lot of "real world" code. Organizationally, this book does an excellent job of making itself useful as a "read-through" book for those that want to immerse themselves in the topic and as a reference book that can sit on your shelf until you need it.

One word of caution about this book is that it originally started as a paper and grew from there. Especially throughout the first few chapters of the book, this is very evident. Constant references to works done by other authors and numerous footnotes can, at times, become a bit distracting from the overall message.

Overall, this is an excellent book and, if you're into extreme programming and refactoring, it's one that you're going to want to have on your shelf.

Rating:
Summary: Wonderful! Brings patterns into coding, not just designing
Review: 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!

Rating:
Summary: Excellent Book
Review: Code Complete, Design Patterns, Refactoring, Extreme Programming Explained, Design Patterns, Refactoring to Patterns, Code Complete... you get the idea.

Rating:
Summary: simply the best refactoring book arround
Review: i just finnished reading this book and i was very suprised about the simplicity and especially everything i could read between the lines. it's very funny if you recognize yourself inside his stories about real world anti patterns. (yes, i'm pattern happy ;D) i liked it more than fowler's book, which was to basic, as i read many research papers before, anyway both are nice to have. i look in this book before taking design decisions,as a brainstorming partner if i develop alone. excellent work, buy it right now!

Rating:
Summary: A Must Read for All Programmers
Review: Kerievsky has written a very useful book and I recommend that all programmers read it. The unification of the two worlds of "patterns" and "refactoring" makes perfect sense, and I find this book an excellent companion to the GOF Design Patterns book. While the original Design Patterns is a classic, it's presentation of finished patterns made it difficult for programmers to relate these abstract concepts to their own everyday experience. Kerievsky addresses precisely that problem, and my only criticism would be that the source code associated with each refactoring is not available online. Hoewever, even in the absence of digital copies of the source code the book is extremely useful, especially for the legions of programmers who must maintain legacy code from earlier systems. An issue that every programmer faces on a daily basis to a greater or lesser degree.

Rating:
Summary: Brings practicality to Patterns
Review: Patterns have always been the domain of the 'architect type'. This book turns that around. It provides practical insight at the code level in how to improve code structure using patterns. What's more it provides these insights on existing code bases. Most of us don't start projects, we extend existing projects. This book tells us how to refactor this existing code in practical ways that will end up making the code more maintainable and reliable.

I can't hold the GoF responsible for the architectural bias in patterns. The original Design Patterns book was very practical in nature. Design patterns just had better penetration in the architecture world. With this book Kerievsky brings patterns back to the front line implementers.

I recommend this book for any software engineer. Thank you Joshua! Great job.

Rating:
Summary: Well written, easy to read, and genuinely useful
Review: Refactoring To Patterns brings together the Patterns movement, and the practice of Refactoring commonplace in the Agile community. Whereas the original Gang of Four book told us what patterns were, what sort of problems they solved, and how the code might be structured, Refactoring To Patterns illustrates how, why and when to introduce patterns into an existing codebase.

The opening chapters cover the background, introducing both refactoring and design patterns, and the context in which the book was written. This gives the reader a clear overview of what is involved in Refactoring to Patterns, and paves the way for the refactoring catalogue which makes up the bulk of the book.

The catalogue is divided into chapters based on the type of change required --- is this a refactoring to simplify code, generalize code, or increase encapsulation and protection? Each chapter has an introduction which gives an overview of the refactorings contained within that chapter, followed by the refactorings themselves. These introductions clearly illustrate the principles and choices which would lead one to follow the refactorings that follow.

Each refactoring starts with a brief one sentence summary, and before and after structure diagrams with reference to the structure diagrams for the relevant pattern in the Design Patterns book. The sections that follow then cover the Motivation for using this refactoring, step-by-step Mechanics, and a worked Example, relating back to the steps given for the Mechanics. Finally, some of the refactorings finish with Variations on the same theme. The examples are all pulled from a small sample of projects, which are introduced at the beginning of the catalogue section, and help illuminate the instructions given in the Mechanics section. The mechanics themselves are generally clear, and broken down into small steps --- sometimes smaller steps than I might take in practice, but I think this is probably wise, as large steps can easily confuse. Finally, the Motivation sections do a good job of explaining why one would choose to do a particular refactoring, and any pitfalls to doing so --- the "Benefits and Liabilities" tables provide a useful summary.

This book is well written, easy to read, and genuinely useful. It has helped me put some of the refactorings I do into a larger context, and given me insight into how I can integrate patterns with existing code, rather than designing them in up front. As John Brant and Don Roberts highlight in their Afterword, this is a book to study, the real benefit comes not from knowing the mechanics, but by understanding the motivation, and the process, so that one may apply the same thinking to other scenarios not covered by this book. If you are serious about software development, buy this book, inwardly digest it, and keep it by your side.

Highly Recommended.

Rating:
Summary: Over-complicated examples ruin a superb piece of work.
Review: 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.

Rating:
Summary: nice sequel to Fowler's Refactoring
Review: This is a recent book in Martin Fowler's series of computing texts. The series begins with his classic Refactoring text. Now Kerievsky takes us into a sequel. Because you can imagine this as a suitable extension of the previous book. Where now the author has us look for patterns during the refactoring process. The style of the book closely follows Fowler's book. And, like that book, the code examples are in Java.

But what if you program in C++ or C#? If you are experienced enough, you should be able to apply many of these ideas in your language. The examples are meant to give flesh to general patterns. And the patterns should be able to be implemented in any object oriented language.

Actually, if you have already been looking for patterns, or designing to them, then much of this book may be no surprise. Because one virtue of the book is that it binds together a set of commonly encountered refactorings. But even in this case, a few hours reading may be profitable for you, if it just exposes you to a few hitherto unfamiliar patterns.

Rating:
Summary: The other reviews say it all, really.
Review: To sum it up nicely, this is a good book, very good. I could have lived without all the XML/DOM, though, but still the kind of quality you can usually expect from Addison Wesley publishing.