Browse Books

Reviewer: Hans J. Schneider

Scott explains how programming languages work. He considers high-level constructs as well as implementation aspects, including some compiling techniques and assembly-level architecture, and does not avoid theoretical background. Chapter 1 is an introduction, mainly restricted to stating the problem and emphasizing the need for studying this field. Chapter 2 introduces the principal techniques used to formally define syntax and briefly reviews scanner and parser techniques. Chapters 3 (on names), 6 (on control flow), 7 (on types), 8 (on subroutines), and 10 (on objects) cover the fundamental issues of imperative languages. Chapter 3 is concerned with scope rules and binding. It discusses the difference between visibility and lifetime, the overloading of identifiers, and the referential environment, as well as storage management techniques and the structure of symbol tables. Chapter 6 surveys the principles of control flow: sequencing, selection, iteration, recursion (including applicative-order versus normal-order evaluation), and nondeterminacy. The author points out the evolution of control constructs, driven by semantic clarity and program safety. (Unfortunately, the instructive table comparing the precedence rules of different languages does not contain the comparisons in the Pascal column, and in the C++ column, the first line is wrong.) Chapter 7 considers data types. Before reviewing records, arrays, pointers, lists, and such, the author introduces the general concept of a type system and discusses type equivalence, coercion, and type inference. Therefore, the reader comes to know the principles of the sophisticated type system of ML before seeing the traditional arrays of Fortran. The implementation-oriented sections of this chapter are concerned with storing arrays and recursive data structures, and with garbage collection. Calling sequences, different modes of parameter passing, and the influence of subroutines on the runtime stack are extensively examined in the following chapter. Further topics included in chapter 8 are the design and implementation of generic subroutines, coroutines (including iterators), and exception handling, very nicely illustrated by the phrase-level recovery in a recursive-descent parser. Chapter 10 describes the step from data abstraction to object-oriented programming. First, the author identifies the characteristic concepts: encapsulation, inheritance, and dynamic method binding. Furthermore, special attention is given to the implementation of virtual methods and of single as well as multiple inheritance, including how to translate method binding in both cases. The fourth chapter discusses semantic analysis using attributed context-free grammars to decorate parse trees or syntax trees. Whereas this chapter affects intermediate-code level, the next proceeds to assembly-level architecture. Scott begins this discussion with an overview of a simple workstation, then considers the hierarchical organization of memory, the formats of data, and the instructions used to manipulate them. Particular emphasis is given to the hardware aspects influencing the compiler, such as the differences between CISC and RISC machines, pipelining, and register structure. Chapter 9 turns to the back end of the compiler and is concerned with intermediate code generation (DIANA, RTL), some aspects of machine-independent code improvement, target-code generation, register allocation, and instruction scheduling. Address space organization leads to a discussion of the task of a linker. Finally, chapter 13 takes a look at code improvement as a whole. It starts with a more detailed view of the compiler structure, illustrating at which stage different optimization techniques may be applied. The author addresses local and global redundancy elimination, loop improvement, and peephole optimization. Chapter 11 focuses on functional and logic programming languages. Discussion of Scheme as a representative of a functional language addresses first-class and higher-order functions, polymorphism, evaluation order, and support for list-based data. Prolog is considered in the logic programming section, along with a deeper discussion of unification and of the problems of control flow. Concurrency is treated in chapter 12, presenting communication and synchronization primitives such as semaphores, monitors, conditional critical regions, message parsing, and remote procedure call. Overall, this book fulfills its purpose of introducing both the design and implementation of programming languages in an undergraduate course. In a traditional course on programming languages, some chapters may be omitted. On the other hand, the book encourages students to take additional courses in such areas as formal semantics and compiler construction. Some of the chapters contain special sections on theoretical foundations. Each chapter is bracketed by an introduction and summary that link the material to the overall context. Bibliographic notes refer to historical material as well as to introductions to the state of the art. Many review questions and exercises are included.