The publication of the nine books reviewed here represents a “second wave” in object-oriented design and development methods and technology (OOT) in general. After an initial period of discovery, enthusiasm, and growth accompanied by the “first wave” contributions of Booch [1],  Rumbaugh  et al. [2], Meyer [3], and Coad and Yourdon [4] (among others), consolidation and regrouping is bound to occur. The first phase was accompanied by the extension of object-oriented methods out of their initial environments of embedded real-time systems (defense and aerospace) and pure research (Smalltalk and Xerox PARC) to bread-and-butter commercial (business) applications. This emergence is demonstrated by the incorporation of such OOT mechanisms as inheritance and user-defined data types in mainstream commercial development tools such as PowerBuilder and the Microsoft SQLServer relational database management system (RDBMS). The natural expectation is that an attempt would be made to consolidate the gains made by the initial breakthrough. That is how one might read the emergence of a variety of OOT texts with “software engineering” in their title or subtitle. In a sense, this second wave of work is derivative, though by no means derivative in quality. This consolidation of object-oriented methods under the banner of “software engineering” implies the search for and claim to attain the status of a formal discipline according to professionally established and agreed-upon standards, methods, and principles. At the same time, consolidation itself generates new challenges and a possible “third wave.” This third wave is represented by another extension of OOT. This extension is in the direction of new (and not so new) problems--concurrent processing, artificial intelligence, and knowledge representation. This is likewise as it should be, since every discipline that is not a dead and fruitless curiosity is striving to test itself against opportunities for new discoveries and applications.

Throughout these books, the central defining features of object-oriented methods remain abstraction, inheritance, and polymorphism of the classes organizing the domain within which object-oriented problem solving methods are applied. The goal of fabricating reusable software components with standard interfaces, rather like the Lego toys of children, remains the vision motivating much of the effort to formalize and define object-oriented software methods today. This remains an eminently practical goal, since reusability would contribute greatly to improved productivity, reduced defect rates, and rationalization of the process of assembling software. Whether the variety of different spins placed upon object-oriented methods is a function of solving different problems, lack of underlying agreement on methods, or both, is a matter of ongoing debate. The debate over whether inheritance undermines information hiding pits a major mechanism of reusability against a fundamental principle of the rational decoupling of components and modularity. The irony of the situation is perhaps that every time software developers approach a consensus or reach a critical mass of components in one area, hardware engineers produce another breakthrough, another quantum leap, in terms of power of computing platforms, and make obsolete in a fundamental way what has been won through software.

Berard

Berard provides an extremely readable series of loosely related essays on object-oriented technology. For me, some of his material was a real eye-opener. For example, one of the essays makes a nice distinction between “information hiding” and “encapsulation”; presents half a dozen candidate definitions from the vast literature for these terms, along with “abstraction”; and presents conclusions (chapter6). A similar approach is taken to disentangling the multiple meanings of “inheritance” (“coupling from underneath,” p.106) in a useful application of the ideas of coupling and cohesion to objects (chapter 7). Other essays engage a variety of topics in a succinct and insightful manner, including understanding OOT in general; motivating OOT software engineering; and applying the system development life cycle (SDLC) to objects, methodologies, documentation, requirements analysis, and design, as well as programming and testing. The reflections on methodologies and the SDLC result in an amusing slogan: “Walking on water and developing software from a specification are easy if they are frozen” (p.46). This statement nicely exemplifies the author’s mixture of realism born of practical experience and thorough familiarity with the vast literature of software engineering. (The bibliographies ending each chapter are a useful resource in spite of some repetitions).

If you are confused by object-oriented terminology, this book will help you to gain clarity. Want to listen to the voice of experience share maxims and principles drawn from practice? Then this is the text for you. Just want a good read, albeit on a specific set of narrow topics? Then check this one out. (My copy is now sandy, because, yes, I did take it to the beach this summer.) The brevity and conciseness of this fine book provide an example of the old saying, “less is more.” Although the essay format presumes a general orientation to the subject, the book can be strongly recommended to a wide variety of developers, analysts, and technical types who wish to explore the scope and limits of basic concepts (without having to read any code).

Blaschek

The main objective of Blaschek’s book is to explore the role of a new language structure called a prototype in the context of an object-oriented research language, Omega. According to the author, Omega is publicly available in a demo, checkout version (only for the Macintosh) through anonymous ftp on the Internet. The languages that most closely resemble Omega and of which many readers may have heard are Self and Eiffel. This book is engaging because of a clear, concise, and simply written discussion of object-oriented principles. A nice job is done of disentangling messages and procedure calls in terms of mechanisms of dynamic binding (p. 22) and polymorphism. No fan of multiple inheritance, the author states, “When multiple inheritance seems to be inevitable, it is therefore best to consider the basic idea behind the design” (p. 70).

The book also is distinguished by the printing conventions it uses (in addition to its use of acid-free “permanent” paper). Sections are marked with small pictures to the left of the text. These icons call attention to definitions, methods, guidelines, warnings, references, comparison, and the like. For example, a nicely printed yin/yang icon marks advantages and disadvantages of concepts, techniques, or languages. Apparently, the depth of appreciation of the user interface characteristic of the Macintosh computer has been transferred by the author to the delivery of a book as a physical artifact. In this age of often transient electronic media images, this is worth mentioning.

Meanwhile, prototypes are employed in the place of classes for the construction of objects in the Omega language. Among other things, prototypes are an attempt to solve the runtime problem of initializing a complicated network of objects and classes before the actual program can be executed. Prototypes employ the more direct approach of building the necessary data structures, content, and behavior in advance (p. 93). Prototypes are thus always existing objects (p. 298). Given that Blaschek ends his book with the icon of a smiley face and an enigmatic statement (in the spirit of his fellow Austrian, Wittgenstein) that “the world is an object,” please file this one under “Zen and the art of object orientation.”

Agha, Wegner, and Yonezawa

With the increasing availability of massively parallel processors for commercial applications, the extension of object-oriented methods to concurrent processing is timely. Given the way in which objects gather together data and the methods for accessing and transforming them, the next logical step is to try equating objects with actors (the latter used in the formal sense). This is the basic premise of the wide-ranging collection of research vignettes put together by Agha, Wegner, and Yonezawa. Actors, in the sense defined by Agha, add concurrent asynchronous message processing across a distributed space to object orientation. Of course, by becoming “dynamic” objects--“living” objects, if you will--these objects also inherit the classic anomalies and problems of concurrency: deadlocks, indeterminacy, and update anomalies. The definition of such problems is facilitated by deploying formal methods; and the readers of these papers should come equipped with familiarity in deciphering notations such as the logical predicate calculus and C and C++ code and pseudocode.

Additional research topics engaged include network management, intrinsically parallel and distributed applications, replication services, and concurrency control of updates. Apparently, as long as one sticks with procedure calls (whether local or remote), synchronization is guaranteed at the price of serialization. But when asynchronous message passing is allowed, then a form of aggregate actors (meta-actors) and/or meta-guards is required to produce nonserializing data abstractions spanning multiple threads of execution. In addition, a nice discussion of a more traditional and predictable kind on the “orthogonality and interference of object-oriented dimensions” (p. 157) can be found in the paper on “Composing Active Objects” by Oscar Nierstrasz: inheritance versus encapsulation, concurrency versus encapsulation, concurrency versus inheritance, and so on. Finally, these wide-ranging papers consider a concurrent extension to C++ (CC++); concurrency in object-oriented logic programming; and concurrent object-oriented operating systems.

The book I received has at least one major printing or editing error where, in the paper by Andrew Davison, pages 88 to 96 repeat word-for-word the material on pages 80 to 87, but with new incremental, sequential section numbers on paragraphs. Otherwise, the papers are well written and sure to challenge even the most technically astute without necessarily containing a lot of notation. This text is suitable as an advanced text in a graduate course on software engineering where the goal is to cross-fertilize ideas in concurrent programming and object-oriented methods. Beginners beware. It certainly pushes the envelope in new and interesting ways. It delivers what the title promises.

Coad and Nicola

The text aims at providing the practicing programmer with an opportunity to bootstrap herself or himself into Smalltalk and C++ by means of a step-by-step, hand-holding walkthrough of the coding of four separate system examples. The book is accompanied by a diskette of the source code formatted for the PC, which is a nice touch. The examples, according to the authors, can be compiled with any compatible AT&T C++ version 3.0 compiler, and were developed using  Borland  C++. Smalltalk from Objectworks is the version of that language employed. “The majority of the lessons” supposedly also apply to Digitalk’s Smalltalk/V (the latter being the one for which a windowed-PC–based version is available).

The four-way partitioning of the automation challenge (with which readers of the Coad and Yourdon method will be familiar) is deployed in the interest of a gesture in the direction of analysis and design: the problem domain, human interaction, task management, and data management dimensions are distinguished and discussed. The four  examples  range from an elementary counting class, to a simple vending machine, a medium-sized customer information and order entry system, and a real-time traffic control system.

The book is written is such a style that the reader is invited to code the examples along with the authors, so it is really addressed to the self-study audience rather than to the traditional classroom audience. Except for the fact that the entire text is an assignment, no exercises in the usual sense are included. One of the most interesting things about it is the way in which a complete parallelism is demonstrated by examples between Smalltalk and C++ in the delivery of these four systems. Another nice feature of the authors’ approach is the deploying of simple, humorously stated design principles. For example, the design of small domain-based human interaction containers that communicate and collaborate via mailboxes is called the “mail dominance” principle (p. 386). The text also features significant numbers of low-level object and class interaction diagrams just slightly more general than the code that immediately follows them (passim). Except for the sheer size of the book and the modest amount of technology required to follow along, one could accept a claim that this book makes learning object-oriented programming “quick and easy.”

Firesmith

This book is a version of the documentation for version 3 of ADM (ASTF Development Method, ASTF being the vendor name), a product in the public domain. Like Rumbaugh before him, Firesmith believes that a good model or set of models of the problem goes a long way toward raising the art of software development from the status of craft practiced by an individual to a collaborative team effort capable of producing predictable and repeatable results. Rumbaugh’s object, control, and dynamic models are appropriated, modified, and expanded in a potentially useful way into six structures. We now have the assembly, object, class, state, control, and timing models. The transition from high-level design to implementation is further facilitated by an object-oriented specification and design language (OOSDL). This is laid out in about 50 pages of tight definitions and Ada-like pseudocode. The substantial appendix gives the syntax of 11 diagrams, including context, assembly, general semantic nets, interaction, composition, classification, state transition, control flow, event timing, module, and submodule diagrams. The reader cannot help but feel this is an example of the opposite of the above-cited maxim, and here more is less. Since automated CASE tool support, code, and document generation “is envisioned” (p.323), that implies it did not exist at the time of the author’s writing.

The author’s background in Ada-based development shows in the spin he places on the “inheritance versus information hiding” debate. He comes down on the side of parameterization (generics) as a partial substitute for inheritance. “Inheritance…unfortunately increases coupling between classes in a way that is unique to OOD” (p. 27). “Because of these risks and limitations, other software engineers consider inheritance to be of limited value and dangerous if misused” (p.90). In addition to being trivially true--anything can be dangerous if misused--the author’s background in Ada (rather than Smalltalk, for example) shows through here. Equally problematic is the reproach sometimes leveled against  Rumbaugh  (who is not explicitly named), that seeing the connection between so many disparate diagrams and putting them back together again is challenging. Finally, in spite of the claim that his method is scalable for large projects (and given the amount of detail provided, this claim is credible), the author’s only two major examples are of a digital thermostat system and an automotive dashboard. These examples are by no means simple--but are they large in any standard commercial (business) sense? Evidently, the background and continuing significant interest here is in subassembly structures and real-time systems.

Coleman et al.

The fusion method presented by Coleman and his colleagues from Hewlett-Packard is a pragmatic, pluralistic approach to designing and implementing systems using object-oriented methods. At the same time, it aims at plugging the real or imagined “gap” between design and delivery of the tested system by deploying aspects of formal methods of proof of design to demonstrate in advance the consistency and coherence of the product. This text explicitly and consciously draws on a “who’s who” of “best of breed” approaches to software design and development. Object interaction graphs are taken back beyond Wirfs-Brock’s responsibility-driven design to the pioneering work of K. Beck and W.  Cunningham  [5] in deploying class-responsibility-collaboration (CRC) cards. Much of the material on visibility graphs draws on the work of Booch in describing communication paths; and class/subclass structures make good use of  Rumbaugh’s  team’s object modeling techniques (OMT). Formal methods (“proof of concept”) draw on Meyer’s material on axioms, invariants, and the “semantics” requiring descendant classes to be consistent with the invariants of the ancestor classes.

This work represents an attempt to form a truly original synthesis (fusion) of existing ideas. The amount of material that has to be mastered to produce the result is formidable but consistent with the development of a software engineering discipline. The material is indeed well-integrated. The result is impressive. Nevertheless, critics have complained that the development process is itself not well-defined enough to be completely formalizable and that the semantics are still weak (see Dodani [6]). The transition from design to implementation is still incomplete. Be that as it may, the authors have made a well-presented and significant contribution, even if results are arguably not always complete.

Lorenz

Lorenz’s short work finds its inspiration and intellectual roots in Ivar Jacobsen’s “use cases” [7]. The use case approach is effective in providing scenarios as to how the system looks to the customer or user. This can be a powerful (and useful) method of extracting the requirements, but is it really object oriented, or just a successful part of the heritage of functional decomposition? More in the mainstream of object-oriented methods, his definition of class is drawn from Booch, and for the idea of a contract between the requester of a service (client) and the provider (server), the reader is referred to Meyer [3] and Wirfs-Brock [8].

In certain respects, this text reads like an IBM marketing presentation--nice graphics, pithy advice, high-level generalities that are hard to dispute, and several different ways of saying the same thing. This approach has its strengths, and this text might be suitable for a busy professional and beginner requiring an overview. On the other hand, a truly outstanding beginner’s text is already available (see  Taylor  [9]). A significant part of the work of this text occurs in the extensive appendices, which occupy almost half the total number of pages. The sections on metrics, coding standards, and new roles on the project (reuse library manager and class programmer) are worth considering. A short list of methodology and implementation tools (with phone numbers) might provide the practitioner with a place to start. At the same time, one cannot help but be left with a sense of disappointment that “design, code, and test” are still being cross-referenced with the imperative to “iterate” phases. An additional step--packaging--is added under the assumption that the product will be brought to market. An example of packaging, as well as a nice touch, is that each chapter begins with a short maxim. For example, “The doctor can bury his mistakes but an architect can only advise his clients to plant vines” (p. 59) must refer to the systems architect. Presumably “screen scrapping,” a quick way of redesigning the user interface, would be the technical analog. In the final analysis, while lacking in obvious defects, this short text is an example of an instance where less really is less.

Paepcke

The intended audience for the collection on CLOS (Common Lisp Object System) is those readers interested in understanding what is behind the language, how it can be used, its relation to other object-oriented languages, and its impact on object-oriented design and programming. The text is divided into five parts. The first part provides the reader, who might otherwise be unfamiliar with CLOS, with enough background to get through the remaining sections. The second part addresses the CLOS Metaobject Protocol, which not only combines features of a trace facility and debugger (spy), but actually exposes essential structures of the implementation strategy of CLOS to modification and adjustment. This is an amazing feature. This second level describes CLOS itself as an object-oriented program. “It specifies the classes, methods and generic functions which implement CLOS”  (p. 121). 

The third part, which compares CLOS to other object-oriented languages (C++, Smalltalk, Eiffel, and Sather), is also most interesting. Engaging material on tradeoffs and tensions between abstract data types and inheritance, between subtypes and inheritance, and between static typing and dynamic dispatch is deployed in detail. The fourth and fifth sections consider application-level and system-level implementations of CLOS. Interesting execution-time features--method dispatch on more than one argument, runtime redefinition of classes, and generic function dispatch--are described and discussed. While much (if not all) of this material seems quite academic to the uninitiated, recall that in 1981 so did the Xerox Star personal computer system, the graphical user interface, and a curious research tool called Smalltalk (all of which were first researched at Xerox PARC in Palo Alto, whose ranks are well represented in the long list of contributing researchers featured in this book). Of course, within a decade, the face of computing had been completely transformed by these technologies. With that humbling fact in mind, this text might be suitable supplementary reading for a graduate-level course in artificial intelligence or knowledge representation in formal systems.

Montgomery

By “information engineering,” we refer to the definition and structuring of data--usually for a corporate enterprise as a whole--in terms of entities, attributes, and their relations. Many have felt a continuity and homogeneity between the analysis of entities, attributes, and relations and that of objects, attributes, and messaging hierarchies. Montgomery’s book is at least a partial vindication of those who have had this intuition, provided that the additional step is taken of hiding the data behind the methods of accessing and transforming it. (This latter step, however, is not trivial.) Those who feel the need for more material by way of an introduction to OOT and who have come out of the 1980s with their share of case orientation and data analysis could do worse than to start with this text. In this case, more is simply more.

Basic definitions of object-oriented terms are followed by chapters on object modeling, object behavior, object interactions, and model validation (consistency checks). Additional chapters are provided on re-engineering, programming languages, object-oriented databases, client/server systems, and object-oriented architecture. This material is really only enough to give the reader a taste of these things, and the extent to which they are integrated in an overall argument is questionable. On the other hand, what might be needed is a kind of Cliff’s Notes on OOT. If this idea sounds attractive to you, then you will love this book. On the other hand, a spoon-feeding approach tends to cause the author to speak with authority, as if results were at hand, whereas matters are either still unsettled or even controversial. For example, although object-oriented database management systems (OODBMSs) were thought to be overtaking RDBMSs, relational technologies are starting to incorporate the object-oriented features (support for things like user-defined data types and binary large objects) that made OODBMSs attractive in the first place. Only RDBMSs can directly and efficiently offer the inquiry and data manipulation ease of SQL. The author’s statement that OODBMSs will supplant RDBMSs as if this were some kind of fact is questionable at best.

Likewise, the treatment of business process re-engineering (BPR) is naive in the extreme. While many technologies have been oversold, BPR is not one of those. It is hard, expensive, and takes a long time to complete. The reader would be better served by being given a clue of what she or he is getting into. Still, the information engineering sections are accurate and clearly written, and will provide support to those with such a background in bootstrapping themselves into OOT.

Comparison

All the texts covered in this review represent one of two tension-laden impulses, toward consolidation of OOT under the title of software engineering or further expansion of research horizons to new domains. Coleman et al.,  Firesmith,  Lorenz, and Montgomery clearly are candidates for the consolidation phase. All of these are second-wave books in the specific sense that they see further by standing on the shoulders of those who came before them. One of the challenges of covering all of these books is the sheer number of backward references, citations of the work of other experts, and footnotes that must be chased in order to determine content and accuracy. Of these, Coleman et al. on the fusion method was the one that taught me the most, seemed most on target, and was the best integrated (no easy task given the number of co-authors) and the most readable.

The Coad and Nicola and the Blaschek book contained the most actual program code by volume, although comparing them is unfair to both, since they are so different. Both show the limitations of treating code in text and skillfully employ auxiliary, extra-textual mechanisms--in one case an accompanying diskette and in the other access through the Internet--to make up for the limitations of the written word. At least Coad and Nicola provide a second-wave contribution. In the first case (Coad) relative to his own first wave, in the other case (Blaschek) through the research paradigm of exploring the program structure of prototypes, both are third-wave, expansion contributions. The books are nicely done in both cases.

Also belonging to the possible next expansion phase of OOT are the contributions by Agha, Wegner, and Yonezawa, as well as Paepcke. The concurrent processing paradigm is receiving extensive coverage in the computing press, and the first text provides the formal conceptual mechanisms required to tackle this material with depth and rigor. This material is not simple, nor is it suited for beginners. Meanwhile, the practical applications for CLOS are even less obvious at this time. Yet the history of Xerox PARC and the number of contributors in Paepcke who have passed through there should give pause to anyone wishing to dismiss this material as merely academic. The CLOS metalanguage may well provide a paradigm for future self-referential computing environments that make possible advanced knowledge representation and expert support systems.

Last, but not least, is the contribution by Berard. In terms of the distinctions with which this comparative review began, this text belongs to the back-end of the first wave. In other words, he keeps company with Booch, Meyer, and Rumbaugh, except that the publication date is a bit later and the abstraction and formalization processes were allowed to proceed further. Although comparing all these texts directly is perhaps not fair to some, for my money, this is the best book of all of those covered here. Well written, incisive, and accurate, it has much to teach the professional software developer as well as the technical manager. If the reader could get only one, then this should be it.