Browse Books

Reviewer: David B. Skillicorn

Programmers have taken two approaches to the development of software with proven properties. In the first approach, software is developed using programmers' expertise and experience and then, in a distinct later stage, proven to satisfy a specification. In the second approach, programs are developed from their specifications by transforming them in ways that preserve the properties of interest. Partsch discusses the second approach. The transformational approach to software development has in some ways paralleled the growing interest in functional programming, since referential transparency makes large collections of semantics-preserving rules for transformation possible. Other motivations for the transformational approach include a growing realization that it can reduce the work required to provide correct software because one stage rather than two is used; an appreciation that the first approach does not work well for developing parallel programs since we do not have a repertoire of programming paradigms that can be applied in a vacuum; and an awareness that the transformational approach tends to force consideration of all of the possible implementations of a specification rather than the use of the first one that occurs to the programmer, and does so in such a way that the tradeoffs necessary to make different implementation decisions are cleanly exposed. The transformational approach has mostly been pursued in Europe rather than North America. This book is intended for an audience of junior or senior computer science students, but I doubt if this would work in North America because of both fit with existing curricula and the mathematical background required. The book is a compendious account of what is known about program transformation. The author mentions almost all of the work in the area, making this volume a useful reference for those with any interest in the subject. Its only shortcoming is that it contains little assessment of which ideas are really practical, which are real advances, and so on. Perhaps it is too early to tell, but one cannot escape the feeling, looking at the huge range of derivations, that some work better than others, and it would have been interesting to hear the author's opinions. The first two chapters are introductory. Chapter 1 defines the terms that the book will use, including what is to be understood by “specification” and “transformation.” Chapter 2 is a digression into requirements engineering, which may be intended to suggest how specifications are arrived at. Both of these chapters are collections of material from a wide range of sources, often presented using lists of points or long quotations from other works. As a result, they tend to be choppy and disjointed. Things improve as the author gets to his main subject. Chapter 3 is about finding the right algebraic framework in which to cast specifications. He introduces the concept of a type, or what OBJ would call a theory, as a collection of operations and equations relating them, together with a basic repertoire of functional constructs. Each chapter from this point on concludes with a large set of examples, which increase in complexity throughout the book. Chapter 4 presents the basic applicative transformation rules: the fold and unfold schemes, transformation rules that follow from set theory, and those that follow from algebraic accounts of data types. Chapter 5 introduces more sophisticated transformation rules, whose applicability conditions are complicated enough that human intervention is needed to decide whether they should be used. The material in this chapter is the leading edge, since one would like to know how far the transformational approach can be automated. Rules that seem to be too complex for automation are thus of special interest. The examples in this chapter go well beyond toy problems, with correspondingly more complicated derivations—for example, the recognition problem for context-free languages. Chapter 6 describes a collection of transformations that can be regarded as optimizations—they do not make significant changes in the implementation, but they alter its execution properties. Such changes necessarily require some awareness of the implementation environment, but Partsch points out that optimization can be done more cleanly at the function level than as a late and low-level stage of compilation. Issues addressed in this chapter include tradeoffs between memoizing and recomputing functions, and between precomputing and computing dynamically. Chapter 7 discusses transformations of imperative programs. These techniques have been developed as part of conventional compiler optimization. Chapter 8 may be the most interesting in the book. It discusses the role of data structures in program transformation. No firm conclusions have been reached in this area and a great deal of research is in progress. The central question here is how to represent one data type as another that is more operational, more deterministic, or more efficient. A number of techniques are presented, but it seems fair to say that many questions remain open. Finally, chapter 9 gives four complete examples of derivation from specifications: Warshall's algorithm for finding paths in directed graphs, the majority problem, Boyer-Moore string matching, and a text editor. These examples integrate the material from the book and provide examples of the derivation of nontrivial programs. The literature now contains a fairly large number of derivations of complex programs; it is unsatisfying that, so far as I am aware, no derivation has uncovered a new, nonobvious algorithm. Thus it is never clear to what extent a transformational derivation has been guided by implicit or explicit knowledge about what the final implementation will look like. Finding such derivations should be a major goal of this research community; the credibility of this approach will be much enhanced if some interesting examples can be found. Something should be said about notation. Precision requires notation that can easily become cumbersome. Certainly the notation presented in this book makes some sections very heavy going. Resolving the tension between a notation abstract enough to be handled like ordinary mathematics and one detailed enough to be automated easily should be a priority goal. Forcing humans to work with so detailed a notat ion can only delay the acceptance and practical use of this approach. This book is a complete presentation of what is known about deriving programs from specifications by semantics-preserving transformations. Its weaknesses lie in a lack of assessment of the relative importance of the details presented, and perhaps in an overly complex notation.