The authors present an extension to the Object Modeling Technique (OMT), introducing some additional notation to treat with real-time aspects. The first two chapters survey the topic. The main part, consisting of chapters 3 through 8, systematically describes the OCTOPUS method in detail. (The name is not an acronym; it was chosen because an octopus resembles an embedded system with a number of interfaces operating concurrently and because the word has two O’s.) Then, two case studies demonstrate OCTOPUS’s applicability. The last chapter is a reference manual summarizing the notation.

The introduction (chapter 1) reviews the main characteristics of real-time systems and object-oriented methods. The authors give special attention to concurrency, both in real-time systems and on different levels in object-oriented models. The chapter concludes by briefly introducing the case studies used as running examples, the complete solutions of which are given at the end of the book. The second chapter outlines the major aspects of the OCTOPUS method. Clear diagrams describe the structure of the development process and summarize roadmap information. Then, insight into the activities of the different phases is given. The concepts of OCTOPUS are illustrated well by small parts of the running examples.

The main part of the book follows the classic organizational mode for software projects. Chapter 3 is concerned with requirements specification. A problem in designing embedded systems is that software is only part of the final product, and although it is expected to provide the required functionality, the product requirements specification usually does not refer to it explicitly. The software requirements specifications must be derived from the product specification. The authors propose use cases to do this, and they introduce hierarchically structured use cases, which may share sub-use cases such as exceptions.

Chapter 4 is concerned with modular system architecture. OCTOPUS isolates the hardware behind a special software layer called a hardware wrapper, because hardware design is often controlled by nonfunctional arguments such as costs or the reuse of previously developed components. Special points involve the development of a family of products, incremental development, and the definition of interfaces. The goal of the analysis phase (covered in chapter 5) is to document the problem. OCTOPUS uses the same high-level structure as OMT: object model, functional model, and dynamic model. Whereas the object model is closely related to OMT, the functional model adopts the operation sheets of the Fusion method, and the dynamic model describes real-time, reactive aspects by using statecharts, significance tables, and scenarios.

Chapter 6 discusses the design phase. The goal is to systematically develop a description of how the system will work at a level of abstraction above that required by programming languages. Based on the object-oriented paradigm, the authors describe designing objects, gradually expanding class outlines, and defining interactions of objects in terms of event threads. Since they are interested in developing real-time systems, they emphasize the controlled transition from implicit to explicit concurrency. Process priorities and timing are examined in a short chapter. The last chapter of the main part treats the transition from design to implementation. This step is straightforward, since most important decisions have been made in the design phase and are carefully recorded in the outlines, which follow the syntax of C++. The detailed description resembles a recipe and is easy to look through.

The first case study (chapter 9) is a subscriber line tester in a remote digital transmission system. The authors present a complete solution to this problem; only the hardware wrapper is left as an exercise for the reader. The chapter starts with the very first problem statement and guides the reader step by step to C++ code. The second case study (chapter 10) is a cruise control system for a car. In this example, the solution is restricted to the software subproject. It includes analysis and design of the hardware wrapper, however. Although both case studies decompose system architecture into only one application subsystem, they are not trivial and comprise about 100 pages.

The book fulfills its intention to be both a guide for software engineers and a textbook for courses at the advanced undergraduate level. I have benefited from it.