This 341-page book provides relatively comprehensive coverage of programming language concepts, a core topic in the ACM model computer science curriculum and a required topic for ABET accreditation of a computer science program. As such the book is appropriately aimed at senior students in an undergraduate curriculum. Across its 14 chapters, the book introduces the functional, imperative, and object-oriented paradigms through the discussion of key concepts and the associated implementation details. F#, a pure functional language, is used throughout the book as the vehicle to explain the concepts. An appendix provides a crash course in F#. There is a website associated with the textbook, and the reader is expected to download various files to accompany each chapter. The files are helpful to students as they learn the material. Lecture slides for instructors are also available. These support materials serve to increase the value of the textbook.

The book is well written and easy to read. It is organized in a clear and logical fashion with the reader starting with an introduction to the expressions as well as syntax and semantics (chapter 1). The basics of interpreters and compilers are addressed in chapter 2, in which concepts such as scope, bound, and free variables are discussed. A stack-based machine is introduced for expression evaluation, and an implementation of an abstract machine in Java is covered.

Chapter 3 covers concrete syntax to abstract syntax. It opens with some preparatory reading and refers the reader to a number of sections of Mogensen’s book [1]. This approach devalued the book immensely because it cannot be assumed that this preparatory reading is readily available to every student and reader. This chapter also expects the reader to be familiar with regular expressions and grammars. This chapter’s focus is lexers and parsers using F#.

First-order functional languages are the topic of chapter 4. The concept of a closure is introduced as well as the differences between static scope and dynamic scope, and the differences between static typing and dynamic typing.

This naturally progresses to chapter 5, which examines higher-order functional languages. Higher-order functions in F#, Java, C#, and Google’s MapReduce are examined before discussing eager and lazy evaluation, and then introducing lambda calculus.

Chapter 6 focuses on polymorphic types. Generic types in Java and C# are discussed as well as type inference in ML. Co-variance and contra-variance conclude the chapter.

Chapter 7 is devoted to imperative languages. C and Micro-C are the vehicles used in this discussion, which addresses pointers and arrays. Chapter 8 covers the development of a compiler for Micro-C, and chapter 9 examines real-world abstract machines including the Java Virtual Machine (JVM).

Chapter 10 addresses garbage collection in programming languages and covers a number of garbage collection techniques in use. Memory leaks are also addressed before the chapter closes with a discussion of the implementation of a garbage collector in C.

Continuations is the focus of chapter 11, which also discusses exception handling on a stack-based machine. Chapter 12 examines compiler optimizations before chapter 13 discusses the actual implementation of a compiler for a small language: Micro-SML. Chapter 14 concludes the book with an examination of real-world machine code focusing on the x86 processor family.

What is missing? The book does not cover some basic programming language theory. Little is said about the Chomsky hierarchy, and regular expressions and grammars are not addressed at all. The argument is that this material is well covered in the literature. However, knowledge of these concepts is necessary to the reader. Knowledge of grammars is necessary even in the introduction. From a personal perspective, I would have preferred to see these topics addressed, as well as those topics to which the reader is referred to other textbooks as preparatory reading, so that this book would more completely cover the topic and permit an instructor to utilize a single textbook in a course without the need for supplementary material.

The book’s coverage of the topics selected is thorough. However, logic programming languages are not covered at all, with the exception of one paragraph that merely notes that some programming languages support backtracking. The increasingly important topic of programming language support for parallel and distributed systems is also omitted.

More reviews about this item: Amazon