Browse Books

Reviewer: Anne Gunn

Kerievsky is an experienced teacher, a founding member of multiple patterns study groups, and a developer. It shouldn't be surprising, then, that his approach to patterns and refactoring is a useful one. This book is beautifully printed, and bound with the trademark double-ribbon bookmarks of high-end Addison-Wesley computing books. But, it reads like a great workbook: the cheap paperbound volumes that get the real work done in many classrooms. The authors' intention is clearly that you should interact with the text, not just read it. The years Kerievsky has spent working with study groups shows. The book flows in a straightforward way through chapter 3; Kerievsky summarizes the current state of the software design and maintenance arts. He reviews the basic concepts of refactoring (separating code cleanup, done in a methodical and test-driven way, from code change and enhancement), and of patterns (the idea that it is important to be able to identify and recognize recurring problem sets, and to be able to apply known solutions that have already been proven successful). After that, if you're interested and diligent, you'll access most of the rest of the material while working through chapter 4: "Code Smells." Each "smell" is an indicator of one or more potential problems in code. Each smell section refers readers to multiple refactorings that might be used to remove that smell from their code. You should find yourself hopscotching back and forth from the smells to specific refactorings in chapters 6 through 11. The book is also intended to act as a workbook for interacting with two seminal books on patterns and refactoring [1,2]. It is definitely a bit odd to pick up one book and have it insist that you keep two other books at your side while you read it, but, in this case, especially in terms of shedding new light on Design patterns [1], the practice works. I wanted to read this book primarily because the premise seemed a bit odd to me. I'm used to associating patterns with design (work done before coding) and refactoring with maintenance (work done after some code has already been written). I've used refactoring extensively to clean up code: simplifying, removing duplication, improving names, and clarifying flow. I hadn't thought of refactoring as a way to push code toward (or away from) a specific pattern. That was shortsighted of me. After all, the subtitle of Refactoring [2] is "improving the design of existing code." If you were going to be improving the design during maintenance, why wouldn't you use some of the same tools that you (try to) use during initial design__?__ The "try to" is important here. The fact is that many of us, while admiring patterns in the abstract, and knowing we should be using them more, find them difficult to apply in practice. We have trouble finding the right pattern, or understanding how to use the ones we do find. Or, we become what Kerievsky calls "patterns happy," and start over-engineering code, using patterns even when simpler constructs would work better. Kerievsky asserts that "good designers refactor in many directions, always with the goal of reaching a better design...I refactor to, towards, and even away from patterns." In fact, the biggest value of this work to me is its approach to explaining and documenting patterns. Ten years after the publication of Design patterns [1], it shouldn't be a surprise (or be sacrilege to say) that someone has come up with an improvement in how to document and describe patterns. I've read and reread the decorator pattern in Design patterns [1], and have just never been able to get it. But Kerievsky's refactoring, called "move embellishment to decorator," finally made the decorator pattern comprehensible. The refactoring itself is not for the faint-hearted; the author spends 22 pages on it. But the first five pages (which include a unified modeling language (UML) sketch, a motivation, and a sidebar discussion of the uses of decorator versus strategy) are as clear as glass. On the other hand, if you are staring at a codebase of a few thousand lines of untamed old code with no unit tests in place (one that is, perhaps, not even object-oriented), this good book is not going to give you much help beyond inspiration. Kerievsky unapologetically assumes that object orientation and unit tests are already in place. Feathers' new book [3] might serve you better. I'm only part of the way through it, but it is aimed more directly at those of us who are down-in-the-trenches in hand-to-hand-combat with old code. Eventually, I think you'll want to own both books. It's just a question of which to get first. Online Computing Reviews Service

Reviewer: Gonzalo Peralta Villavicencio

An approach to reformulating software designs at a low level, by introducing transformations through design patterns, while preserving original behavior, is offered in this book. The first goal is to formalize the procedures for using design patterns to do composite refactorings. The book is intended for readers who are working on new software systems, or maintaining systems already designed or in production. The text will be a valuable source of information, helping readers to create good designs, and to avoid falling into the recurring trap of over-engineering and under-engineering problems. The ideal audience for the book is designers and object-oriented programmers who are interested in improving their development techniques, in order to produce revolutionary design software. Readers will benefit from knowledge of pattern use, since this will afford them a more agile reading of book. This knowledge is not a requirement, however, thanks to the well-presented real-world examples, using unified modeling language (UML), Java, and useful references to other related books. Kerievsky's broad experience in software development, and his commitment to the emerging areas of extreme programming (XP) and agile programming, have resulted in a book that brings together, in a practical and consistent way, the concepts developed in the seminal works Design patterns [1] and Refactoring [2]. In the first four chapters, the author exposes the foundations of his topic, and his motivations to write the book. Basic concepts are defined, as well as the author's ideas about doing refactoring toward and away from patterns. It's very important that readers understand the discussion of code smells in chapter 4, since these reflect signs of a system needing improvements, and are mentioned in the examples later in the book. Chapter 5 introduces a catalog of refactorings to patterns, and defines a common dynamic for their presentation. In spite of the variable need for the application of refactoring, the author recommends a study sequence for better understanding. His catalog includes topics in creation, simplification, generalization, protection, and accumulation, presenting a total of 21 refactorings. Finally, he presents an extra utility topic, including six more useful refactorings. Refactorings with regard to smells during object creation are addressed in chapter 6. Throughout the book, the presentation of each refactoring includes a name section that identifies it; a summary describing the design transformations; a discussion of motivation, explaining why anyone would like to use it; its mechanics, detailing the instructions for applying it; an example, including a real-world case; and variations, mentioning possible mutations. Chapter 7 discusses looking for simplify methods, state transitions, and tree structures by means of simplification. A useful resource to help readers assimilate the purpose of all refactorings is a sidebar in the motivation section, which lists the benefits and liabilities of its application. The author presents a concrete, but at the same time eloquent, summary section, describing the refactoring textually and diagrammatically using UML, and offering the reader a fast vision of what the refactoring does without having to read all of the following sections. In chapter 8, the author presents refactorings with regard to generalization, like the form template method. These refactorings are related to the transformation of specific code to general purpose code. Chapter 9 covers the protection of code. Topics studied include limiting instantiation with singletons, and introducing null objects. Developers using frameworks like adaptive communication environment (ACE) (http://www.cs.wustl.edu/~schmidt/ACE.html) will be quickly comfortable with chapters 7, 8, and 9, gaining an understanding of the motivations designers have to incorporate patterns like template methods, strategy, singleton, observer, and null object into the implementation of a framework. The topic of accumulation is addressed in chapter 10. The primary objective of accumulation is to optimize the code that accumulates information within an object, or across several objects. It isn't necessary to read the book sequentially; it's possible to find references to refactorings in chapters other than the ones in which they are introduced. Some refactorings act like low-level constructions to others that are more sophisticated. All refactorings presented in chapter 11 have this utility. The text seeks to standardize a vocabulary of refactorings, with the goal of producing better software designs, and maintainable code. It would be interesting to see the refactoring approach applied to pattern-oriented software architectures, like those addressed in the Pattern Oriented Software Architectures (POSA) [3,4] series. Online Computing Reviews Service