Browse Books

Reviewer: Fernando Berzal

Martin has distilled his knowledge and experience in this excellent book, using the peculiar style that characterizes his craftsman's columns in Software Development magazine. The book could be considered a software design book, or just an object-oriented programming book, but, as Jack Reeves' reprinted paper [1] points out in one of the book appendices, the source code is the design, and engineers produce designs, so this book is actually about software engineering. As the book's subtitle suggests, it covers practices, principles, and patterns that have been demonstrated to be useful in software development. It does so by presenting examples, with plenty of source code. This is one of the book's strongest points, since programmers can immediately learn how to apply well-known design patterns in programming languages such as C++ or Java. Moreover, code reading is a usually neglected activity in a software developer's education. Such activity, however, is a suitable tool for transferring programming expertise, as well as the proper way to illustrate the importance of the practices and principles discussed in the text. The book starts with the manifesto of the so-called agile movement. Basically, agile development emphasizes the fact that people are the most important factor of success in software development, a statement present in almost every software development book since the word peopleware was coined. Among its principles, agile development promotes simplicity as "the art of maximizing the amount of work not done" in order to maximize the business value of software development. Once the stage for agile development is set, the book presents the set of extreme programming practices, and devotes a few chapters to describing some of them in greater detail (the planning game, test-first design, and refactoring). Apart from the aforementioned development practices, the book includes two sections devoted to design principles. The first of them addresses class design problems, while the second covers package design. Using an analogy that compares software designers to surgeons, the author makes it clear that a design must remain clean. In order to achieve that licit goal, which boils down to improving cohesion and decreasing coupling, several design principles are studied. For instance, with regard to class design, inheritance use and abuse is regulated by the Liskov Substitution Principle ("subtypes must be substitutable for their base types"). With respect to package design, in my opinion the best section of the book, Martin explains how to avoid undesirable dependencies between packages, why they are not desirable, and how they can be detected using software metrics. The book also presents a good overview of some of the most well-known software design patterns. Martin groups them according to their applications, and discusses them in the chapters that precede each one of the three main case studies included in the book. The first case study illustrates how quick analysis and design sessions lead to unit tests, which in turn are used to implement actual applications, where interfaces are clearly separated from implementation details. The second case study shows how a system design evolves over time, and how design patterns are incorporated into it as they are needed. Finally, the last big case study describes the decisions that lead to the construction of a software framework for big applications. These case studies include literally thousands of lines of C++ and Java source code, which let the reader grasp how practices, principles, and patterns are used in the real world. Finally, the book's appendices include clear-cut explanations of the unified modeling language (UML) notations, a satire of two antagonistic software development approaches, and a reprint of the article mentioned in the first paragraph of this review. The parody of the development companies is overstretched, but enlightening; it describes common situations that would arise in a bureaucracy-driven management environment (namely, a strict waterfall development model), and it underscores the best qualities of agile development (namely, fluid communication among project stakeholders, and value maximization through feature prioritization and incremental development). In short, Martin has done an excellent job of writing an entertaining and instructive "bible of agile practices and design concepts." No wonder this book received the Software Development 13th Jolt Product Excellence Award. Its 30 chapters and four appendices contain a mix of textual explanations, dialogues, and code listings that make it stand out over other books in its category. Online Computing Reviews Service

Reviewer: Diomidis Spinellis

Agile software development can be described as an uprising against the tyranny of excessively structured software processes. According to its manifesto, it values individuals and interaction over processes and tools, working software over comprehensive documentation, customer collaboration over contract negotiation, and response to change over a strict adherence to a plan. The importance that agile software development principles place on the fluid and fleeting parts of the development process, like human interactions, changing requirements, working software, and customer satisfaction, makes one wonder how these aspects can be documented and communicated in a concrete way, to software professionals looking for hands-on advice. Robert C. Martin (Uncle Bob, as he is affectionately known in the object-oriented programmer community) succeeds brilliantly in this task, thanks to his more than 30 years of software development experience. This book can be roughly divided into three parts. The first, "Agile Development," provides an overview of the agile alliance and extreme programming (XP) practices. Separate chapters address the most important elements of agile development: planning, testing, and refactoring. This part ends with a case study of a bowling game score calculator, developed following XP practices. Interestingly, the case study is presented in the form of a dialogue between the author and a colleague, working as a pair-programming team. We are thus able to witness programmer interactions, design, mistakes, testing, refactoring, and coding as the project evolves toward its final form. The book's second part addresses agile design. Agile software development practices abhor the creation of grand and detailed designs before a single line of code is written, advocating instead the practice of always having the code comprising the system structured in the best possible way. Martin, taking the lead from a paper by Jack Reeves, provided in an appendix, argues convincingly that the only software documentation that actually satisfies the criteria of engineering design, as most disciplines understand it, is the system's source code. To improve a software project's design, one has to recognize symptoms of poor design: rigidity, fragility, needless complexity and repetition, immobility, viscosity, and opacity. Martin illustrates five important principles of agile design, using code examples, and clear unified modeling language (UML) diagrams. The book's last part illustrates the coding practices of agile development, by means of three case studies: a payroll system, a weather station, and excerpts from a real-life project (the automation of an educational testing service). Each of the three allows Martin to examine different aspects of software development using agile methods: data-driven systems, embedded systems, and life cycle issues. More importantly, the case studies are used as a backdrop to illustrate important design patterns. The pattern names can be bewildering: command, active object, template method, strategy, facade, mediator, singleton, monostate, null object, factory, composite, observer, abstract server, adapter, bridge, proxy, stairway to heaven, visitor, and state. However, any experienced developer working on object-oriented artifacts will, deliberately or by accident, have used or encountered at least one of them. The text's interweaving of the pattern descriptions with the development of the actual code makes learning the patterns a pleasure. Traditionally organized design pattern catalogues are useful, but can be tiresome to read. I readily admit that I never succeeded in completing more than a couple of chapters in a single "pattern catalogue" reading session; with Martin's exposition, I found myself going through more than five patterns before I could put the book down. The book is chock-full of UML diagrams, illustrating design principles and patterns. For those not yet well versed in UML notation, two to-the-point appendices describing the most important diagram elements are included, to bring readers up to speed. On the other hand, all readers will benefit from seeing UML used in the context of concrete case studies, together with code; some nitpickers may wonder why a generalization instead of a realization relationship is sometimes used to denote the implementation of an interface, or a navigable association relationship is used in places one would expect to see a dependency. None of these problems, however, obfuscates the presentation, or distracts the reader. The only important shortcoming of the book is its presentation. A small text font, laid out as a single column on an unusually wide page, makes following the lines a challenge. Then again, the wide pages allow for the faithful presentation of the numerous C++ and Java code samples and UML diagrams. Agile software development favors working software over comprehensive documentation, so the decision to make space for the code appears to follow the book's spirit. Online Computing Reviews Service