Browse Books

Reviewer: Hans J. Schneider

This textbook is intended to give students a better understanding of different programming languages, and of the programming techniques associated with various language features. Readers are expected to have some knowledge of basic programming in a procedural language. Four parts make up the book: foundations, including functions; structuring control flow and data management; modularity; and concurrency and logic programming. It is mainly organized in a concept-oriented way, though, in a few chapters, Mitchell prefers a language-based approach. After a short introduction and a concise summary of computability, the author starts by presenting the main concepts of Lisp. He not only explains that Lisp is based on recursive functions, but also introduces the concepts of an abstract machine and of garbage collection. Chapter 4 provides some background material, including a discussion of the structure of compilers, and of the Backus-Naur form. The main part of this chapter, however, is concerned with lambda calculus and denotational semantics. The chapter concludes with a discussion of pragmatic differences between functional and imperative languages. Chapters 5 through 8 are devoted to procedures, types, memory management, and control. First, the author draws attention to the Algol-like languages, the most prominent representatives of which are Pascal and C. He then explains the concepts in more detail, in light of ML. Chapter 6 considers the importance of types in programming, not only in static type checking, but also with respect to polymorphism and type inference. Block structured declarations of functions and activation records are then considered in chapter 7. This chapter also discusses the implementation of high-order functions, and return functions from nested scopes. The last chapter of this part is concerned with structured control. The traditional control statements are mentioned only briefly, but Mitchell deals with exceptions and continuations in great detail, as structuring techniques. He compares exception handling in C++ and ML, and provides valuable examples of how to use and implement continuations. Finally, he considers the explicit realization of call-by-need by the delay and force constructs. Object-orientation is the main subject of the next part. Chapter 9 reviews structured programming and abstract data types as the forerunners to this topic. The author, however, restricts his discussion to milestones: stepwise refinement, information hiding, and visibility. Chapter 10 surveys the typical concepts of object-oriented languages, such as dynamic lookup, the object-oriented variation of abstraction, subtyping, and inheritance. The next chapter examines the origins of object-oriented programming in Simula, and the first development of a purely object-oriented paradigm in Smalltalk. Chapters 12 and 13 are concerned with the object-oriented languages currently in wide use: C++ and Java. In the chapter on C++, the author illustrates the object-oriented features added to C by rewriting a Smalltalk example. Special emphasis is also given to the implementation of multiple inheritance. The chapter on Java starts by pointing out that the Java system is not only a language, but also includes the virtual machine and an extensive library. Special topics are the package concept, the exception class hierarchy, and subtype polymorphism. Two sections deal with the Java system architecture, and with security features. Two chapters comprise the last part of the book. First, Mitchell considers concurrency. He starts with mutual exclusion, semaphores, and monitors. The actor model is considered in detail. These concepts are then illustrated with a discussion of how they are realized in concurrent ML (CML) and Java. CML is well suited to considering channels and events as typed objects. In the Java section, the emphasis is on synchronized methods and remote method invocation. The last chapter, written by Apt, is on the logic programming paradigm and Prolog. Apt stresses three points: computing takes place on the domain of terms; values are assigned to variables by unification; and control is provided by backtracking. After introducing the basic concepts, such as terms, substitution, and unification, the author illustrates the differences between logic programming and imperative programming, by analyzing some simple sets of clauses. Finally, he demonstrates, by example, some situations in which non-logic features, such as the cut, may be used. The book is characterized by its overall approach of explaining traditional concepts, such as static type checking, in the context of a rather modern and untraditional language. It shows students that today¿s languages do not start from scratch, and may encourage them to look at the roots of the field and at its pioneers, some pictures of whom are included in the book. The exercises are carefully prepared, and help the reader to go into additional details. Overall, this book fulfills its purpose of explaining the concepts that appear in modern languages, of tracing them back to why and where they were introduced, and of relating them to program development. Online Computing Reviews Service