Byrne wrote this book to disseminate his techniques for designing large Ada systems. The intended audience is the growing collection of project managers and system engineers who fact this challenge for the first time. The book presents several issues that make the software design process difficult, and then outlines an approach to solving these problems. Unfortunately, the approach will not work. Its tedious, complex, yet incomplete diagram conventions will not improve designer productivity. Several Ada feature descriptions are wrong, and the attempt to show how to use Ada for object-oriented design misses the mark completely. Ada does not have the flexibility of object-oriented languages, and forcing it into this domain is always awkward and ill-advised.

The book’s organization and presentation are excellent. It has four parts:

• Large Software Systems and Design

• Basic Design Considerations

• Design Steps for Programs and Software Systems

• The Relationship of Design to Risk, Implementation Issues, and Life Cycle Costs.

Part 1 reviews the impact of bulk and complexity on modern software systems and contrasts large and small program development. Many managers and system engineers have been through small software development projects, so this comparison highlights the characteristics of large projects. The author emphasizes the importance of good design for reducing the costs and risks of large projects.

Part 2 discusses the basic ideas that support the author’s design strategy. These include designing for flexibility to support future change, designing for concurrent execution, and designing with data abstractions. The problematic recommendations about using Ada to support an object-oriented methodology appear here.

Part 3 specifies the author’s design approach. It consists of a series of steps used to design programs as collections of parts, and systems as sets of concurrent programs. The diagram notation, referred to as SMART, is defined here. Lengthy examples of program and system design conclude this section.

Part 4 moves on to more general concerns such as project risks and life cycle costs. The author argues that his design techniques will help in these areas. The COCOMO cost estimation model, as applied in the author’s examples, shows how cost reductions result from properly partitioned projects. The author also outlines some inappropriate ways of using Ada and cautions the reader to be aware of these issues.

We thus have a well-written, nicely organized book that fails to achieve its basic purpose. The general issues are clearly presented in Part 1. If the author’s design methods were workable, the rationale given in Part 4 would be a convincing conclusion. Unfortunately, Parts 2 and 3 contain too many errors, omissions, and impractical suggestions.

All the author’s design mechanisms have direct Ada language counterparts. This limits the designer’s repertoire. Byrne provides no mechanisms to broadcast a message to many tasks simultaneously because Ada does not directly support this. Coding in pictures is not equivalent to diagramming a system design.

Timing analysis is not mentioned as a design activity. This book does not address deadlock, starvation, or memory management. Designers cannot use methodologies that do not cope with these problems.

The SMART diagram notation used to show a generic unit procedure parameter is similar to the figure used to show a program unit reference in a context clause. Ada uses the single keyword with to mark these two completely different elements. The author has not understood this distinction. Consequently, his explanation of Ada generic units is a hopeless tangle of errors. The code examples are not compilable.

In a floating point type declaration such as “type f is digits 5;” the author claims that the “5” indicates the number of digits that follow the decimal point when the number is printed. This is not correct. The 5 actually specifies the minimum number of significant decimal digits required in the mantissa of type f values. The author repeats this misunderstanding several times, and even brings it up in one of the exercises.

I noted more than 20 errors and deficiencies like those listed above. This book is not worth reading. I will not add it to my list of recommendable Ada books. It lists and analyzes some interesting design problems, but it does not provide any useful answers. Also, books with incorrect Ada code do not help.