Browse Books

Reviewer: Fernando Berzal

For most people, legacy code is "difficult-to-change code that we do not understand." In practice, Feathers translates this definition into "code without tests." If we had automated unit tests for the code we have to modify, we could change the code quickly and verifiably. Even if we might not understand it completely, test failures would immediately warn us about potential problems in our modifications. The problem is that it is not easy to get tests in place. Even though good designs should always be testable, many actual designs are so convoluted that system dependencies make individual components almost impossible to test separately. Fortunately, Feathers shows us a handful of useful techniques that can help our maintenance nightmares disappear. As Robert C. Martin states in the foreword, this book is about "taking a tangled, opaque, convoluted system and . . . turning it into a simple, nicely structured, well-designed system" in as safe a way as possible. The mechanics of change in software systems are presented in five introductory chapters. Since change is always risky, preserving existing behavior is key in software maintenance. Hence, refactoring is a fundamental skill for the maintenance of software systems. However, the old-style "edit and pray" modification of source code is clearly insufficient. Feathers advocates for "cover and modify," an incarnation of test-driven development for software maintenance. Here, unit testing frameworks like xUnit, the application of dependency-breaking techniques, and the use of fake objects are a must. The core of this book deals with practical techniques for changing software. Nineteen chapters describe typical problems software maintainers must face, using an original frequently asked questions (FAQ) format. This format makes chapter titles lengthy and rather whimsical, but they also convert this book into a useful guide to have at hand when dealing with legacy code. You will discover techniques for changing the way that code is organized to make builds (and, hence, testing) easier. You will also learn how to add features to code being tested using test-driven development and programming by difference. Plenty of examples, mostly in Java and C++, will show you how to get tests into place. Easy to understand effect-analysis techniques, such as effect and feature sketches, will lead you to the places where you should test the behavior of your legacy code, also known as "pinch points." Simple techniques will help you uncover and communicate the architecture of large systems. But, most of all, all of the practical advice in this book is given without forgetting the rationale behind your decisions, such as when to sacrifice object encapsulation in order to improve unit testability and, more importantly, your understanding. The sections in this book are heavily cross-referenced for easier navigation, and a catalog of dependency-breaking techniques completes this landmark volume. This catalog includes 24 conservative refactorings to make a system testable, and it is completed by a final appendix where the classical "extract method" refactoring is explained. Most development environments will probably include support for such refactorings in the future, although, in the meantime, this catalog constitutes a valuable resource for those who want to untangle the dependencies that make a piece of code hard to understand, test, and modify. In summary, this is an outstanding book that fills an important gap in the existing literature. Since not all development projects are "green field" projects, and software maintenance eats up a considerable amount of software development resources, an applied book such as this was clearly needed. It is an excellent complement to existing books on testing, refactoring, and design patterns, even though only a few references to other books are provided in this book. If you are a software maintainer, this well-written book might make your job more productive and enjoyable. Even if you are not, you should not discard this "legacy code" title too quickly. As a developer, when you follow any iterative development process, most of the time you are maintaining (and hopefully enhancing) an existing system. Online Computing Reviews Service

Reviewer: Diomidis Spinellis

In the 1980s, Lehman and Belady observed that programs used in real-world environments must continuously evolve to remain useful, and, more importantly, as evolving programs change, their structure becomes more complex unless active efforts are made to avoid this decay. Valuable code that one generation of developers passes on to the next is often termed legacy code, and, more often than not, this code through its evolution suffers from a complex structure, outdated development methods, and useless documentation. Feathers' book tackles the problem head on, providing valuable practical advice for bringing such code under control. Feathers idiosyncratically defines legacy code as code that is lacking tests, and by tests he typically means unit tests that developers can swiftly execute after a change to ensure that they didn't break anything. While this definition does provide a clarity of purpose, it steers the subject's treatment toward directions that are neither widely accepted, nor universally practical. For example, a large part of the book discusses object-oriented programs and techniques, whereas legacy code is much more likely to be in procedural languages like Cobol, Fortran, and C. Furthermore, although many modern development approaches espousing unit testing have demonstrated encouraging results, we currently lack empirical evidence regarding the risks and practicality of retrofitting unit tests onto legacy code. The book is divided into three parts: an introductory part discussing the high-level mechanics of program change, a sequence of chapters offering answers to commonly encountered maintenance challenges (for example, "How Do I Add A Feature" or "I Need to Make a Change, but I Don't Know What Tests to Write"), and a final part detailing 24 different refactorings that developers can use for breaking dependencies. All material is extensively cross-referenced, but the organization of the book's chapters could be improved by adopting a more consistent narrative structure. The book ends with a small glossary and an index, but lacks a separate bibliography or list of references. The technical advice contained in the book is excellent. Feathers obviously has a deep understanding of object-oriented design and development techniques, and a rich experience in applying them in practice. The advice spans both design and coding techniques, and, where appropriate, references how changes can be automated by using refactoring tools. The writing is clear, although, unsurprisingly, many examples of legacy code require significant effort to comprehend. Clear unified modeling language (UML) diagrams are extensively used to illustrate the code's structure. In summary, Feathers is to be commended for addressing the vitally important subject of legacy code maintenance. As object-oriented code ages, this book will become increasingly relevant to the practitioners working with it. Online Computing Reviews Service