This book describes a set of reusable Modula-2 software components using the Logitech compiler system for IBM PC–compatible machines. It gives source code for Modula-2 definition and implementation modules in the form of a disk included with the book. The user of these components is expected to have a working knowledge of Modula-2.

Chapter 1 discusses the advantages and disadvantages of reusable software components. Chapter 2 contains an introduction to data abstraction, some examples of abstract data types, and a discussion of low-level features of Modula-2 that support generic software components. It concludes with four different approaches to generic data abstraction. Chapter 3 covers the implementation of some of the standard abstract data types (stacks, queues, deques, lists, trees, bounded sets, and tables), using two different approaches for generic abstraction. The first approach is type secure but requires recompilation. In the second, strong type checking is not supported but recompilation is not necessary. This chapter also contains the following generic sort programs: selection sort, insertion sort, bubble sort, merge sort, heap sort, and quicksort. Test programs are provided for all these components. Chapter 4 describes a collection of utility routines that are called by the components in chapter 3. These routines include low-level procedures containing in-line assembly code. For example, TERMIO, which writes directly to the bit-mapped memory area, takes the place of the standard module InOut. There are two appendices that give definition modules for all the software components; these listings duplicate what is contained in the supplied disk.

The book will clearly be of most use to those programmers having access to the Logitech compiler. No claims are made that the code can be compiled by any other system without modification. In fact, the supplied programs will not run correctly with version 3 of the Logitech compiler (the low-level code is based on version 2) since the compiler is not downward compatible. However, the publisher will provide a free update of the code for version 3 to readers requesting it. This situation is a good example of the pitfalls of software portability and reuse.

One can quibble with what has been left out of this collection of components. For example, graphs, dynamic strings, and a window package would have been nice. The main value of this book, however, is that it gives a practical illustration of how to write reusable code. In this connection, it should be compared with Booch’s book [1], which provides a much more extensive taxonomy of reusable components together with Ada descriptions (but not in machine-readable form).