Browse Books

Reviewer: Markus Wolf

This ambitious book introduces complete metric spaces for treating the semantics of no less than 27 programming languages and concepts. It is encyclopedic in content and can be a textbook for graduate students. A brief introduction explains the main ideas of operational and denotational semantics on a simple language of regular expressions and elaborates the notion of control flow. The main body of the book is then divided into four parts and an appendix. Each part is subdivided into chapters; each chapter treats a major programming concept by introducing the concept, presenting the mathematical tools necessary to model its semantics, giving operational and denotational semantics for the constructs, and proving the equality of these semantics. Most chapters close with a discussion of alternatives, some exercises, and an overview of the subject's historical development and the relevant literature. Part 1 treats the control flow notions of recursion and nondeterminism and, most important, introduces the main mathematical tools for modeling their semantics. The first chapter elaborates on recursion and iteration and introduces techniques for describing operational semantics with (labeled) transition systems. Complete metric spaces, contractive maps, and the Banach theorem are introduced next, and it is shown how these mathematical tools can be used to give denotational semantics to a simple recursive language. The chapter contains a detailed development of a proof of equivalence between an operational semantics and a denotational semantics. An important technique in this proof is the systematic use of continuations and a syntactic counterpart, called resumptions. This technique is used extensively in later chapters and makes the development in those chapters flow smoothly. The second chapter discusses the topological notions of the Hausdorff metric, compact sets, their properties, and the compact powerdomain. These tools are then used to provide operational and denotational semantics of a language containing a nondeterministic choice construct. The last chapter of this part presents variations: a form of a guarded command language and a language with goto statements. The second part of the book, “Linear Models,” treats semantics that are ultimately based on sequences or traces of actions. No major new mathematical tools are introduced in this part, but a lot of previously untreated programming constructs are discussed. Chapter 4 treats a parallel composition operator and models its semantics in the interleaving manner. Chapter 5 introduces unbounded nondeterminism and discusses image-finite transition systems and the closed power domain. Chapter 6 treats locality in the sense of local variables and procedures with parameters. The next chapter introduces nonuniform parallelism in the sense of adding parallel composition to a while-programming language, resulting in shared variables and side effects. Chapter 8 revisits recursion and presents the &mgr;-calculus. The last chapter in this part (chapter 9) introduces the notions of backtracking and failure. This chapter is quite interesting, because the development of semantics manages, by introducing more complex notions of resumptions (nested resumptions), to follow the common scheme used throughout the book. These concepts are then used to model processes, viewed as stream transformers with dedicated input/output channels, together with a fork construct. Part 3 introduces new mathematical tools and more advanced concurrent programming concepts, such as deadlock, synchronization, and value-passing communication. The first chapter of this part (chapter 10) discusses tools needed for this development: domain equations (domains in this case are complete metric spaces) and how to solve them in order to treat the denotational semantics, and bisimulation between (labeled) transition systems in order to treat the operational semantics. The next chapter is devoted to branching domains, that is, domains that have a tree-like structure, and their use in modeling deadlock and synchronization. Chapter 12 is devoted to advanced topics in nonuniform parallelism, treating suspension (used, for example, in concurrent constraint languages) and value passing along communication channels. Chapter 13 discusses the treatment of processes with an encapsulated state that communicate via messages, that is, concurrent objects. This chapter is particularly interesting because the use of resumptions to model operational semantics is refined to cope with these concepts. The last chapter in this part presents semantic techniques for modeling atomization, commit, and action refinement. The last part of the book intends to show connections to other areas where the techniques developed in the first three parts can be useful. Chapter 15 discusses applications of the techniques to the control flow of logic programming by viewing Horn logic as a form of parallel programming language. Chapter 16 investigates issues of “true concurrency” (in contrast to the interleaving view taken throughout most of the book). Chapter 17 is devoted to the concept of full abstractness, that is, that the denotational semantics does not distinguish terms that are not distinguishable in every context in the operational semantics. The last chapter treats second-order assignments. The appendix is devoted to proofs and concepts that are too technical to be incorporated into the main body of the book. The first chapter of the appendix presents proofs of some of the topological theorems used in the first part of the book. The next chapter sheds light on some issues of operational semantics generated by finitely branching transition systems that had not been proven in chapters 2 and 5. The third chapter elaborates on the solving of domain equations and supplies some missing proofs. The last chapter of the appendix lists a few of the most important textbooks on semantics, programming logics, and functional programming. This book is important because it presents a nearly complete view of what metric techniques can accomplish for denotational semantics, without pretending that everything can be adequately modeled with complete metric spaces (although the staggering number of programming concepts might suggest this). It nearly succeeds in its ambitious aims, being a good textbook and a good reference work. There are a lot of pointers to the literature and well-chosen exercises, especially in Part 1. After studying the first part, most chapters are relatively self-contained and invite browsing. However, there are a few flaws. The index is much too short for a reference work. Most annoying, at least to me, is the fact that, although 27 different languages are defined, there is no appendix summarizing the syntax rules and labeled transition system for each language. Furthermore, neither syntax rules nor the transition systems are boxed in the text and, due to the compact definition styles, it is sometimes difficult to find the syntax rules or operational semantics. Such summaries, one for each language, would have made the book much easier to use. Maybe this flaw can be corrected in a second edition.