Browse Books

Reviewer: Randal P. Leavitt

This clearly written review of the fundamental ideas that underlie interpreted programming languages devotes a chapter each to LISP, APL, Scheme, SASL, CLU, Smalltalk, and Prolog. The discussion moves smoothly through the evolution of language design, highlighting the improvements introduced by each new language. LISP uses large data values called S-expressions and recursive function definitions. APL demonstrates how matrix operators combined with reduction and compression can eliminate most of the need for iteration and recursion. Scheme shows how functions can be first-class values and demonstrates the importance of static scope rules. SASL provides new expressive power based on lazy evaluation. CLU illustrates how strong type checking can be combined with encapsulated type definitions to improve the verifiability of programs. Smalltalk brings the reader up to the present with examples of message-passing and objects, class protocols, methods, class hierarchies, inheritance, and dynamic binding. Prolog gives us a taste of something completely different as a logic programming language that relies on unification and backtracking to search for logical sequences in a collection of Horn clauses. The last two chapters of the book discuss implementation issues: compilation and memory management. Along the way the author provides a few interesting diversions with brief but accurate overviews of ML, lambda calculus, Ada, and C++. BASIC, the world's most widely used interpreted language, is never mentioned. The source code for a rudimentary interpreter written in Pascal appears in Appendix B of the book and is available via electronic mail. Many of the exercises require the student to work with the source code. Each chapter begins with a discussion of the new language's key ideas and then explains how the interpreter can be modified to provide these features. Several exercises take the student a bit further by specifying other extensions and variations, while other exercises ask the student to apply the modified interpreter to solve problems using the new capabilities. As the author states, this book is a suitable text for an applied course in programming language concepts that emphasizes interpretation as opposed to compilation. Its intended audience includes those who have at least an elementary understanding of programming and a working familiarity with Pascal. Many of the exercises require access to a Pascal compiler and interactive use of a computer to run the interpretation programs developed as solutions. Using this approach, this book is clear enough to be a self-study guide for anyone interested in programming language fundamentals. Many practicing software professionals would find the chapter exercises interesting. This book fulfills its basic purpose well. Its length is about right for a semester course. The material is a bit challenging but not inaccessible. The author amplifies each new idea with several examples that help to make the abstract points concrete. Appropriate references for further reading close out each chapter, along with a concise summary of the chapter's material and a glossary giving precise definitions of the important terms introduced. The book would not work, however, as a text for students interested specifically in the languages reviewed. The author only presents some of the features of these languages and shows how these facilities can be provided by an interpreter. The book teaches the student something about APL; it does not teach APL directly. Given an appreciation of this distinction, this book could serve as a senior course text. The best feature of this book is its organization. It contains a comprehensive index and bibliography. Every chapter builds on the previous material in a very natural manner. New concepts unfold as extensions or improvements of the capabilities presented earlier. Each chapter describes how to extend the interpreter to provide these features, giving several examples of how the new features work, and a subsection reviews the language under discussion as it really is. The further reading notes are up-to-date and selective, focusing on the landmarks in the programming language literature. The author briefly describes each reference to help the student navigate through this material. Complete and accurate reference sections such as these are not easy to put together. This attention to relevance, detail, and completeness can be seen throughout the book. An instructor using this text should be aware of a few minor presentation problems. The book is divided into six parts but the part titles do not appear in the table of contents. Another issue is the use of the letter l and the digit one. The author often uses the variable name l in examples that also increment counters by one. The difficulty of distinguishing between l and one when reading these examples for the first time is disconcerting. The binding is sturdy, and the type is small but clear on high quality, low glare paper. I did not find any typographical errors. Chapter headings and subheadings appear on every page, making it easy to find sections quickly. The notation used is clear with a minimum of special symbols. Overall, this work is excellent. It is a well-organized, informative, up-to-date book that I have already recommended to others with an interest in this field.