Browse Books

Reviewer: Hans J. Schneider

Reynolds presents a broad but unified treatment of the basic principles of programming languages. He convincingly elaborates the idea that a relatively small number of concepts suffice to describe a diversity of languages and to reveal the principles of their design. The concepts discussed include compositional semantics, binding structure, domains, transition systems, and inference rules. The first four chapters introduce most of the basic concepts and apply them to a simple imperative language that is built out of assignment, sequential composition, alternatives, while loops, and variable declarations. Abstract syntax and denotational semantics are given in detail. Then, inference rules to prove both partial and total correctness of programs are introduced using Hoare's notation. Finally, arrays are added to the language. Chapters 5 through 9 augment this simple language step by step. First, failure and input/output commands are considered. The formal treatment of these commands leads to continuation semantics. Transition semantics as devised by Plotkin is introduced both as an alternative approach used to describe semantics formally and as a groundwork for the study of nondeterminism and concurrency. In this context, Reynolds treats guarded commands, presenting Dijkstra's weakest preconditions, shared variable concurrency, and message passing. He also discusses fairness and deadlocks in these contexts. The next five chapters are concerned with untyped functional languages. This part of the book starts with a concise presentation of the lambda calculus, including its semantics and different evaluation strategies. Then a functional language with eager evaluation is formally treated; it permits patterns to generalize the binding occurrences of variables. The next chapter defines a continuation semantics for this language, then considers continuations as values and illustrates how to use them as a programming technique. The author completes the discussion of untyped languages by considering normal-order evaluation. Chapters 15 through 18 introduce a type system for a purely functional language. Type inference rules as well as explicit typing, and extrinsic semantics as well as intrinsic are discussed. Reynolds completes the treatment of types with a concise presentation of subtyping, generic operators, polymorphism, and abstract types. He takes the view that the type of a module is in fact its formal specification. Chapters 13 and 19 are concerned with combining functional and imperative concepts. Chapter 13 adds assignment and state changes to a functional language that uses eager evaluation in an Iswim-like style following Landin's approach, whereas chapter 19 considers Algol-like languages that are based on normal-order evaluation, reflecting Algol's copy rule. The book provides a self-contained introduction to the formal treatment of programming languages for graduate students. It is clearly structured, and in the preface, the author defines some sequences of chapters and sections that may be omitted without impeding an understanding of the remaining text. Although the large amount of formal material requires some time to read, the presentation is clear, and the typesetting often helps the reader to understand the structure of the formulas. Each chapter contains valuable exercises and profound bibliographic notes that can serve as a starting point for further reading. I shall use this excellent textbook in my lectures.