While hardware becomes ever more cost-effective with the passage of time, the production of software continues to be plagued with cost overruns, late deliveries, and incorrect code. One approach to improving programmer productivity employs reusable software. This four-volume series is an example of this approach using Modula-2; other modern languages that allow the same approach are Ada and C++. Volume 1 covers the abstract data types (ADTs): stacks, strings, and sets. Volume 2 covers lists, queues, and deques. Volume 3, which has been reviewed separately (see <CR> Rev. 9005-0362), covers trees and graphs.
The organization of volumes 1 and 2 is roughly the same, except that volume 1 contains more introductory material--a chapter titled “Reusable Software Components” and one on “Generic Items.” The chapter on “Reusable Software Components” gives a brief discussion of ADTs and a scheme for naming the various modules. This scheme uses four major properties of a software component, based on terminology due to Booch [1]:
the degree of (non)concurrency
whether the data structure is bounded
the type of memory management
whether an iterator is provided
For example, SetSBMI stands for Sequential Bounded Managed Iterator Set. Sequential indicates that the semantics of the object are preserved only in the presence of one thread of control. Bounded denotes that an object’s maximum size, once created, remains fixed. Managed means that the component itself provides garbage collection. Although the author gives references on different approaches to define generic reusable modules and states that each technique has its own advantages and disadvantages in terms of such factors as simplicity, safety, and ease of reuse, he does not apprise the reader of his reasons for choosing the particular method used in the series. A brief discussion of the considerations involved in the decision would have been useful and interesting to the reader.
Each volume contains two chapters titled “Specification” and “Module Guide.” These describe a standard specification format due to Liskov and Guttag [2] and cover further properties of a module such as “secrets,” which are hidden by the module. The source code for both definition and implementation modules follows the introductory chapters; the source code chapters are organized hierarchically. For example, a separate chapter covers “The List Abstraction,” followed by chapters on the “Singly-Linked Unbounded List,” the “Doubly-Linked Unbounded List,” and so on. Each chapter ends with a list of references. Since Modula-2 does not support exception handling, the author provides a definition module for the error handling module used throughout the series; he expects users to provide their own corresponding implementation module.
The software components described in these volumes, in both source and object form, will clearly be useful to programmers writing applications in Modula-2. The source code is available on diskettes for both the Macintosh and the IBM PC. I did not have access to source code in this form, however. These volumes can also be used to complement material studied in courses on data structures and algorithms.
