Browse Books

Reviewer: James W. Moore

Most of the great advances in software construction have been the result of theoretical insights reduced to practical guidance. Examples include structured programming, information hiding, structured design, strong typing, and relational databases. In each case, gifted programmers recognized them as techniques they had already intuitively applied, while average programmers benefited from the reduction to institutionalized procedures. Those of us engaged in the profession for decades have grown to expect that future advances will have the same nature—simple mathematical principles explained and applied in practical terms. Of course, the infinitely complex and chaotic phenomenon known as the real world may not conform to this attractive model. Perhaps we have only solved the problems that admit to the simplest of solutions. Future advances in the discipline might not be characterized by the beautiful mathematical elegance of structured programming, but might instead seem complicated, messy, and ad hoc in comparison. Arguably, the search for practical software reuse is one of these instances. For more than a decade, the gurus of reuse have groped for pervasive principles, producing powerful solutions while staving off demands for results with the palliative that “the primary barriers to reuse are management, not technical”—in effect, labeling effective but inelegant methods as mere management techniques. Bassett's book is about a reuse method, “frames,” that has been effectively practiced, he says, in more than 150 organizations for as long as 16 years, reducing development costs by as much as 84 percent and time-to-market by similar amounts. Purists may dismiss the method as a mere macro language for preprocessing higher-order languages, but the results argue for paying closer attention. Along with a list of references, a glossary, and an index, the text contains 29 chapters organized into four parts: an executive overview, a description of the frames method, a section on the iterative development cycle, and a section on technology transition. There are figures, but they generally remind one of a presentation rather than a text. Like a medieval manuscript illumination, they decorate the author's words rather than providing graphical information. A reminder of the crucial differences between runtime issues and construction-time issues is the book's mantra (and rightly so, for repetition is appropriate for helping readers to grasp the broad consequences). As a corollary, the author makes a persuasive case that object-oriented techniques do not solve the reuse problem; subtle problems in the use of inheritance handicap object-oriented design as a construction-time technique for customization and parameterization. The sections providing management and technical transition advice are clear and readable, showing the author's experience as a consultant. The chapter on domain analysis is usable, whether or not one chooses to use frame technology; it provides good heuristics for identifying components of the domain. On the other hand, the terminology throughout the text is ad hoc, and there are few unifying metaphors—perhaps an inevitable consequence of work derived from practice rather than from history. Regrettably, the book is boosterish in tone. A more serious problem is that the chapter that actually specifies the macro language is terse, a problem compounded by the author's selling when he should be explaining. Otherwise, the book is generally well written and a worthwhile addition to the shelf of any engineer or manager interested in introducing reuse to an organization.