Few books deal with the development of real-time systems. Such books present specific methodologies; no book dealing generally with “engineering real-time systems” exists yet. This book does not break this barrier: despite the generality of the title, it does not deal generally with the problem of engineering real-time systems, but presents a specific methodology (as indicated by the subtitle, an object-oriented methodology using SDL). Nevertheless, at least two features distinguish this book from similar publications on real-time engineering, and make it worth reading. First, the methodology presented in this book is based on a set of formal languages built around SDL, a CCITT standard specification language that is widely used in the telecommunications community. Second, all phases of the software life cycle are covered reasonably well (with the exception of management issues), while similar books either cover a few specific phases or only pretend to cover all phases without giving full coverage.

Formal aspects and SDL are some of the most interesting aspects of the book. The book is written mainly for practitioners; the authors never give excessively tedious formal discussions, but they do not underestimate the importance of a formal approach. The whole presentation, including the most formal aspects, such as the detailed discussion of reachability analysis, can be understood with reasonable effort by readers without a specific background (although some background in programming and developing real-time systems is desirable). The brilliant incremental presentation of SDL through a working example (almost half of the book) makes the book suitable for readers who are only interested in learning about SDL as well. On the other hand, this book is not for managers: management implications are deliberately ignored. It is not a textbook either: it would be of interest only for specific courses on SDL and its use in developing real-time systems.

The book is organized in four parts. Part 1, “Understanding Real-time Systems,” describes the overall development cycle, identifying the main phases: analysis of requirements, design, and implementation. This part introduces some notations for describing functional requirements: the SOON notation, an object-oriented notation for functional requirements that combines the advantages of entity-relationship and dataflow diagrams, message sequence charts, and transition charts, which are used to describe the interplay of messages or transitions. Part 1 also justifies the proposed approach and introduces an example (an access control system) used throughout the book to illustrate the approach. The chosen example does not present the strong real-time constraints needed to clearly illustrate real-time engineering, however. The main weaknesses of this part are the references to the “traditional life cycle” and the example. What is referred to as the “traditional software development approach” is actually a terrible view of how software is currently developed. The authors’ position on the possibility of improving software development by promoting formal techniques and new methodologies can find much agreement in the scientific and industrial communities; I doubt many people will agree with their analysis of the current level of maturity of software development. Time and real-time constraints play a marginal role throughout the book, not only because the authors attempt to isolate timing problems, but because of the marginality of real-time constraints in the example.

Part 2, “Specifications,” introduces SDL and describes its use for functional requirements. The presentation is clear and complete, and never annoys the reader. The notation is introduced incrementally through the access control system example. The differences between SDL’88, SDL’92, and the object-oriented approach proposed, as well as problems and limitations in the use of SDL, are clearly and honestly identified. The rules describing the suggested methodology highlight the correct use of the notation and the differences between it and other notations and approaches.

Part 3, “Design and Implementation,” focuses on the transition from SDL specifications to object-oriented code. Many problems are highlighted well, but this section is less effective than Part 2: the investigation is less formal and complete. Chapter 11, on C++ coding, stresses the authors’ attention to software engineering practice, but the results are tedious and sometimes difficult to follow. On the other hand, chapter 12, “Verification and Validation,” clearly discusses techniques to verify and validate the final product. The whole book keeps an eye on quality, and this section clearly surveys the main techniques for verifying the final product.

Part 4, “Evolution,” contains a general discussion of problems related to reuse and maintenance. This is the weakest part of the book: it contains only a preliminary discussion. The main goal of this part is to identify problems that can arise once a good standard of software development has been achieved.

A good index and an ordinary bibliography complete the book. The bibliography is good in referencing specific areas, such as SDL literature, but does not reference the literature of the field adequately: books and papers on engineering real-time systems are almost ignored.

The best features of this book are a great presentation of SDL, a good focus on formal techniques and quality, the attempt to cover the whole software life cycle, the use of a working example, and a nice presentation that seldom becomes hard to read. Less impressive features of this book are the focus on a specific methodology rather than on the general topic of engineering real-time systems; the not-always-brilliant discussion of the design and implementation phases; and the bibliography. This book will undoubtedly interest practitioners seeking a complete overview of SDL-based technologies; it can also be of interest for professionals working in real-time engineering.