This softcover book has six chapters, with an index and a bibliography. Chapter 1, What is Real-Time Program Design? presents characteristics of real-time systems, formal design languages, program complexity factors, and reasons why design should be studied.

Chapter 2, The Hardware Substrate, begins with a generic description of processors and follows with a more detailed description of the Intel 8086 microprocessor and its assembly language. This is followed by a brief discussion of memory (including RAM, ROM, and EPROM). Peripheral devices are described, using counter/timer and parallel-to-serial interface components as representative devices. More detail is provided on the latter. Some 8086 code is provided to illustrate how these peripheral devices can be used.

Chapter 3, Design Languages, discusses four high-level, diagrammatic design languages: flowcharts, structure charts, data flow diagrams, and state diagrams. Advantages and examples are presented for each language, but disadvantages are presented for all except the data flow diagrams. The author states “Data flow diagrams most closely capture the flavor of real-time systems."

Chapter 4, Implementing the Data Flow Diagram, covers the concepts of circular queues and their implementation in 8086 assembly language code. This is followed by a brief discussion of virtual machines and multiple processes, including the implementation and fine tuning of multiple processes on the 8086 processor. The implementations include code, flowcharts, and figures of the data structures.

Chapter 5, A Detailed Example, applies the theory from the previous chapters. The real-time application is a microprocessor-controlled intelligent keyboard. Data flow diagrams and flowcharts are used extensively to illustrate the design, followed by the 8086 assembly language code that implements the design.

Chapter 6, Improving Performance, the Real-Time Railroad, and Goodbye, briefly discusses generic coding and process execution techniques for improving system efficiency, which include using the register, using online code, and calling critical processes more frequently.

The bibliography includes nine technical books and one novel, with the newest book published in 1982. This book was published in 1987. The index contains a mixture of entries: hardware devices and features, diagrams, real-time systems (dishwasher, Pacman), people, and characters.

The stated purpose of the book is to teach techniques to engineers faced with real-time programming assignments, with software engineers as the implied audience. However, the book appears to be aimed at programmers new to the 8086. It fails in its purpose, as it only briefly shows techniques and does not teach them.

The book also fails in its purpose because it is too short to cover real-time design and because the author could not make up his mind whether to address software design or Intel 8086 programming. Because he tries both, neither is explained clearly and fully, leaving the reader a little confused on each subject and thirsting for more and fully-detailed explanations.

Eighty-five illustrations are included, but there are no captions on the figures and illustrations. There is no table listing that would help in locating these figures and illustrations. However, the figures and illustrations are helpful in understanding the design or code.

Because of the superficial treatment of software design and the 8086 processor, this book falls flat in terms of both parts of its title. Also, the author’s bias towards data flow diagrams (no disadvantages presented) weakens the value to people who are interested in software design, whether real-time or non-real-time; and his bias to the 8086 weakens the value to non-8086 programmers.

In addition, each chapter uses different examples with no similarity. This requires the reader to make a conceptual readjustment in order to identify what problem is being solved by the design. It would have been better to present parts of the same problem in each chapter, with the consolidated solution in the final chapter(s).

Good software design is supposed to facilitate implementation and maintainability. Yet maintainability is mentioned in passing, even though half of a software program’s cost through its lifetime is spent in maintenance. The design should be maintainable and flexible, or else changing environments may break both the program and design beyond all repair.

An essential part of a design is a data dictionary, where each variable, data record, and flag is identified, described, and specified. This includes format, valid value ranges, conditions, and who sets or uses it. Without this, the implementation of a design is more error prone, and the maintenance of the design and the program becomes considerably more difficult. Yet, data dictionaries are not even mentioned.

In summary, I cannot recommend this book because it is superficial, it does not know what its subject should be, and it incompletely covers the subjects it does address.