Browse Books

Reviewer: James W. Moore

As a colleague recently commented to me, “In this business, it's not hard to write a book about bad practices.” So perhaps it is not surprising when a book about bad practices turns out to be self-referential. Consider the irony of the following two passages: A goal for this book is to end the perpetual circle of hype and disillusionment that characterizes software technology (p. 5). AntiPatterns represents the latest concept in a series of revolutionary changes in computer science and software engineering technology (p. 3). The executive summary promises that “this book will help you identify and overcome prevalent, recurring roadblocks to successful software development.” The presentation is based on a currently popular design concept known as “patterns,” a technique for capturing and articulating intangible attributes formerly regarded as simply the result of applying “judgment” or “experience.” The authors say that a pattern becomes an antipattern when it causes more problems than it solves. In general, the antipatterns are described in a common format that enumerates the problem, causes, symptoms, consequences, and solution. Although the authors make no specific assertion, the book seems to be oriented toward management and senior technical staff. Following 25 pages of front matter and four chapters of introduction, the authors devote individual chapters to antipatterns related to software development, software architecture, and software project management. Four appendices provide a synopsis of the antipatterns, terminology, acronyms, and a bibliography. An index is also included. In all, 18 anti patterns are fully described; another 23 are described in abbreviated form. The value of the text probably lies in a systematic arrangement of material that many experienced practitioners would regard as common sense. Considered from this viewpoint, there are some problems, though. The schema of nearly 20 sections for describing antipatterns seems overly elaborate, including, for example, an item attributing each problem to sins like “sloth” and “avarice.” The introductory material is tedious, repetitive, and probably unnecessary—the antipattern descriptions are not difficult to understand on their own. The aids provided for finding and referencing half-remembered material are inadequate. The treatment is uneven: for example, a treatise on architecture is folded into the description of the solution of one of the antipatterns. In addition, the book includes too many references to the authors' own works and some unfortunate disparagement of particular technologies. All things considered, the treatment may be too specific to the Object Management Group's Common Object Request Broker Architecture (CORBA) technology, since it seems to suggest the CORBA Interface Description Language (IDL) as the solution to too many problems. My overall reaction to the book is mixed. Occasionally, the antipattern descriptions helped me to recognize and explain a problem about which I had previously had only a vague feeling. On the other hand, too many of the descriptions—such as “mushroom management”—are simply trite caricatures of problems that are well known. It is hard to take material like that seriously. On the other hand, maybe it is not meant to be taken seriously: page xxv says “you will find that AntiPatterns are fun to learn and discuss with colleagues.”