A fundamental premise of the JSP method is that the control structure of a program must reflect the structure of the data upon which it operates. In the Jackson methods, the programs are considered to be, in some sense or another, models of the world. As such, these methods use the notions of concurrency to establish a hierarchy and impose an organization on the solutions to many programming problems. This book provides an enthusiastic introduction to the Jackson methods for program design.

In Chapter 1, an overview of JSP is presented. The author expresses great respect for the method and cites (unreferenced) reports of significant improvements in the programmers’ productivity and reliability (from 25 percent to 100 percent) when they apply the JSP method.

Chapter 2, Drawing Data Structures, gives an elementary presentation to specifying data structures. It is unfortunate that the author does not mention that there are (infinitely) many ways of specifying the structures of given data. The reader, and the novice in particular, would have been reassured to learn that there are, indeed, equivalent structure diagrams for the same problem.

In Chapter 3, Designing Simple Programs, programs that, in the words of the author, process only one data set are considered. This may give the wrong impression that the program has either no input or no output. What the author intends, however, is the design of programs where only one “data set” is worth considering (the others being too trivial).

In Chapter 4, Coding and Testing Programs, coding techniques are classified and discussed with reference to COBOL and BASIC programming languages. In JSP, the coroutine idea is applied extensively to the design and the implementation of programs. Indeed, a basic JSP transformation, known as program inversion, is simply the technique for converting a program (or a procedure) so that it can be considered as a coroutine. (Coroutines are programs that are run quasi-concurrently, and they communicate by shared storage. A coroutine must, therefore, be able to be suspended and resumed at the points of communication. Conventional procedural programming languages, e.g., BASIC and Pascal, don’t support coroutines.) In Pascal, or any similar procedural language, to transform a procedure to a coroutine, all of the control structures (e.g., WHILE, IF-THEN, CASE, etc.) must be recoded in a “linear” manner using GOTOs so that it will be possible (to suspend and) to continue with the execution from the middle of the control structure. The author claims, perhaps inadvertently, that this transformation is not necessary if the language supports a suitable CASE statement. It is not clear why the CASE statement poses no problem while, say, the IF-THEN does. In this chapter the HOST language, a programming design language, is introduced. A preprocessor, called HOSTAGE, which is written by the author, is capable of translating HOST to an executable programming language. This can be a useful facility, and its availability will enhance the practical values of this book.

In Chapter 5, the concept of correspondence is introduced. Loosely @ speaking, an input structure corresponds to an output structure if it is possible to generate the output by a single left-to-right scan of the input. In JSP, a program is constructed if there is a correspondence between its data structures. If there is a lack of correspondence, then the general solution is to construct more than one program, each performing a minor transformation, i.e., to effectively make more than one pass of the input. The author defines correspondence between two data components to mean they must occur the same number of times, in the same order, and under the same circumstances. No attempt is made to provide a (rigorous) justification for this definition. This chapter closes with a discussion of the standard matching (and merging) algorithm of two or more files and some of the limitations of correspondence. In Chapter 6, some of the problems with processing direct-access files are discussed.

Problems for which a correspondence cannot be formulated have been classified into backtracking, ordering clash, interleaving clash, and boundary clash problems. The standard JSP solutions to these problems are discussed in the next three chapters. In particular, in Chapter 8, the problem of inversion is revisited. This is an important chapter since it stresses the importance of concurrency (coroutines, in particular, or inversion, as Jackson calls it) as a method for organizing solutions to many problems. Chapter 10 provides a good overview of JSD (a generalization of JSP).

Overall, the style and the format of presentation is very similar to Jackson’s original book [1]. The book is 339 pages in length, which is too long for the level of its coverage. The list of references is incomplete; e.g., two other similar books on JSP [2,3] are not cited. The book is intended as a tutorial on JSP; as such, it is similar to the ones mentioned. There are many examples and exercises with solutions, most of which, however, are trivial and dk not present a challenge to the reader. The book’s emphasis is purely practical, and perhaps too much so. A reader with a desire for a deeper understanding of the methods will not be fully satisfied until seeing other works, such as [4].