Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Objects and systems
Zeigler B. (ed), Springer-Verlag New York, Inc., New York, NY, 1997. Type: Book (9780387947815)
Date Reviewed: Feb 1 1998

The specification of complex systems is an important aspect of software engineering. This book highlights the need for the precise and concise specification of software systems. It goes on to introduce object orientation and illustrate the usefulness of the approach in the specification of a hierarchy of fundamental object classes. The book is meant for undergraduate students who have just learned to program in C++ or Java, paving the way for advanced software engineering methodologies. The author has carefully (and properly) called the design process a “principled approach,” to avoid discussing the complex mathematical problems associated with the algebraic approach to state-based systems.

Zeigler has done the right thing in introducing a formal approach to software specification. This is what software engineering is really about. Software developers should have the necessary mathematically based toolkit in hand before attacking object-oriented development using the popular graphical methods. The need for precise and unambiguous specifications is explained in the book. This leads naturally to the use of an algebraic specification language that will not be subject to different interpretations by different members of the project team. In this way, software engineers can dissociate themselves from artisans who learn only from pure experience. The concepts and techniques in the book should be strongly recommended to students who wish to become genuine software professionals.

The book is divided into 13 chapters. The first 5 chapters introduce the basic concepts. Chapter 1 is about object orientation and states; chapter 2 covers the behavioral specification of objects; chapter 3 is on the use of lists as a specification model; and chapter 4 explores further object-oriented concepts, such as inheritance hierarchies. The concept of containers, which is more fundamental than sets or lists, is introduced in chapter 5 so that more advanced object classes, such as bags, sets, relations, and functions, can be specified.

These concepts and specifications are applied throughout the subsequent chapters. For example, a C++ implementation of the class library is presented in chapter 6. The need for the testing of specifications is discussed in chapter 7. The use of the formal language in the book makes it easier for software developers to verify and validate the systems.

The construction of the inheritance class hierarchy is explained in chapter 8; it is followed by an implementation based on ensemble methods, in chapter 9. An example of the implementation of ordered containers is given in chapter 10. The specifications of the predicate logic primitives “for all” and “there exists,” leading to set-theoretic equivalence concepts, are presented in chapter 11. Further design examples based on hierarchical decomposition and ensemble methods are given in chapter 12. Finally, chapter 13 introduces the features of Java and discusses its application to threads in the container example.

Unfortunately, the author has obviously not followed his own advice on precision. I have identified no fewer than 50 errors in the specifications throughout the book, and numerous other typos in the text. Although most of the specification errors are only syntactic, some of them are actually semantic problems that may mislead the implementer in the programming and testing phases. It would be difficult for undergraduate students to learn from a book with so many errors; this problem is especially acute in a case such as this one, where the subject requires a high degree of accuracy.

The author should verify the syntax of the specifications using the software developed by his two Master’s degree students, and he should validate the behaviors using the testing techniques recommended in chapter 7. A corrected version of the book should be published; it might be worth redrawing the diagrams in the new edition to make it look more like a textbook and less like lecture notes.

Reviewer:  T.H. Tse Review #: CR120932 (9802-0028)
Bookmark and Share
Design (D.2.10 )
C++ (D.3.2 ... )
Java (D.3.2 ... )
Object-Oriented Programming (D.1.5 )
Requirements/ Specifications (D.2.1 )
Would you recommend this review?
Other reviews under "Design": Date
Software design techniques for large Ada systems
Byrne W., Digital Press, Newton, MA, 1991. Type: Book (9781555580537)
Jun 1 1992
Software specification and design
Keller M., Shumate K. (ed), John Wiley & Sons, Inc., New York, NY, 1992. Type: Book (9780471532965)
Sep 1 1992
An automated software design methodology using CAPO
Karimi J. Library Hi Tech News(33): 71-100, 1986. Type: Article
Feb 1 1988

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