Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Search
Hierarchical object-oriented design
Robinson P., Prentice-Hall, Inc., Upper Saddle River, NJ, 1992. Type: Book (9780133908169)
Date Reviewed: May 1 1994

Many people are interested in applying the principles of object-oriented development to Ada software, particularly for real-time and mission-critical applications. The HOOD (Hierarchical Object-Oriented Design) method was commissioned in 1987 by the European Space Agency for precisely this purpose. Use in various European programs has stimulated the development of tool sets to assist in automating the method. Although the principles of classes and inheritance were omitted from the original method, they have been added in recent revisions, along with mappings to other programming languages.

In order to provide a view of HOOD that is more complete than that available from reference manuals, Robinson has written this text based on previously developed course material. The book comprises ten chapters and ten appendices including the index, bibliography, glossary, and large examples. Portions of the text are cross-referenced to the HOOD reference manual issue 3.1.1.

Chapter 1 provides a history of HOOD along with a description of its objectives and a rationale for the approach selected. An overview of the method is given in chapter 2, and the following chapter details how objects and operations are found. Chapter 4 introduces the diagrams that are characteristic of HOOD.

At this point, the book seems to shift gears from overview and insight to detail and reference. Chapter 5 describes the Object Description Skeleton, which provides the transition between the HOOD diagram and the Ada code. Class hierarchies and their related instance objects are described in chapter 6. Real-time design and distributed design are discussed in chapters 7 and 9, respectively, while chapter 8 maps HOOD designs to Ada code. Chapter 10 wraps up topics such as the relationship of HOOD to the software life cycle and the role of tools in the use of HOOD. The most notable appendix is an extended example of a HOOD design.

The first four chapters introduce the HOOD method. The techniques for selecting objects make intuitive sense (HOOD acknowledges its debt to Grady Booch here), and the diagrams have more formality and rigor than those of many alternative techniques. The text uses HOOD diagrams extensively and well to provide a readable and insightful overview while frankly discussing some of HOOD’s weaknesses compared to alternative techniques.

Unfortunately, from chapter 5 onward, the book’s approach changes. The text becomes more of a reference manual than a tutorial. It contains too many pointers to other chapters, particularly forward pointers, when brief explanations would be preferable. To compound the problem, the pointers are occasionally incorrect. Worst of all, needed pointers are sometimes omitted entirely, leaving the reader with only the index as a tool for understanding a new concept. This part of the book sorely needs additional examples. Reference is often made to the design examples in the appendices, but the relevant portions of the examples are seldom extracted and highlighted in the text of the chapters. On the other hand, the utility of the design examples in the appendices is hampered because the requirements and other motivating material are buried in unreferenced portions of the text. Lack of a distinct typeface for code is annoying and occasionally confusing.

HOOD seems to introduce new terminology for otherwise familiar Ada concepts. Unfortunately, the book’s descriptions of these key design concepts are too often superficial and imprecise. The result is frustrating; one struggles to learn imprecisely described new concepts only to discover much later in the book that they are intended to map to well-known Ada concepts. Why doesn’t HOOD just use the Ada terminology in the first place, or more to the point, why doesn’t the text use Ada terminology to explain the HOOD concepts?

The most important shortcoming is fundamental. The book simply fails to make the case that the HOOD mechanism for expressing detailed design, the Object Description Skeleton, is superior in any way (readability, for example) to the use of annotated Ada code. Furthermore, the book does not demonstrate that designing in terms of HOOD constructs is superior to designing in terms of Ada constructs. Although the HOOD diagrams are attractive, the reader is left to wonder why one should not simply proceed directly from the diagrams to the Ada code.

The book seems useful primarily as a supplement to reference materials in a situation where HOOD has already been selected as a design method. The shortcomings of the text compromise its utility as a general tutorial on HOOD.

Reviewer:  J. Moore Review #: CR115587
Bookmark and Share
 
Methodologies (D.2.10 ... )
 
 
Ada (D.3.2 ... )
 
 
Real-Time And Embedded Systems (C.3 ... )
 
 
Object-Oriented Programming (D.1.5 )
 
Would you recommend this review?
yes
no
Other reviews under "Methodologies": Date
Software design
Stephens W., Prentice Hall International (UK) Ltd., Hertfordshire, UK, 1991. Type: Book (9780138202422)
Jun 1 1992
Rapid application development
Martin J. (ed), Macmillan Publishing Co., Inc., Indianapolis, IN, 1991. Type: Book (9780023767753)
Jun 1 1992
Literate programming
Knuth D., Center for Study of Lang. and Info., Stanford, CA, 1992. Type: Book (9780937073803)
Oct 1 1992
more...

E-Mail This Printer-Friendly
Send Your Comments
Contact Us
Reproduction in whole or in part without permission is prohibited.   Copyright 1999-2024 ThinkLoud®
Terms of Use
| Privacy Policy