The Handbook of Programming Languages (HPL): Functional, Concurrent and Logic Programming Languages

This book opens with a brief general description of Lisp and devotes a chapter to Emacs Lisp. Sections on Scheme, Guile, and CLOS follow.

The volume wraps up with a long chapter on Prolog--a key logic programming language that is highly expressive and useful for knowledge systems and artificial intelligence development. Though knowledge-based applications still make up only a small portion of the overall programming landscape, there's little doubt that they will play an increasingly important role in the future. This volume chronicles the roots of the evolution of knowledge-based applications. --Stephen Plain

Product Description
Volume IV begins with the Logic Programming group, all descended from John McCarthy's LISP of the late 1960s. The Volume begins with a few pages from the LISP 1.5 Programmer's Manual, a vital token of things to come and moves on to LISP's offspring: LISP, Scheme, Guile, and CLOS. Finally, Jamie Andrews provides a substantial essay on the most important Functional programming language, Prolog. The contributions are designed to enable the programmer to evaluate the languages and to understand the ways in which each works.* Bob Chassell on Emacs LISP,* Brian Harvey on Scheme,* Jim Blandy on Guile,* Jim Veitch on CLOS,* Jamie Andrews on Prolog.

• Unique leaders in the field of functional, concurrent and logic programming provide insightful information about the language that they helped to create
• A complete handbook covering the most widely used functional, concurrent and logic programming languages
• Comprehensive coverage of each language includes history, syntax, variables, tips and traps
• Unique introductory material enables professional programmers to evaluate whether a specific language is appropriate for his or her use

This book is a collection of essays. Point. There is no particular theme nor direction; each essay is independent of the rest of the book. This book is neither a tutorial or a reference work. (although it tries to pass off as one) Its a mix of both.

One common complaint about this book is that its views are biased and not objective in its survey of programming languages. However, we must remember that some of the articles are written by the inventors of the language itself so I don't think is possible for the inventor to be objective about his language. My complaint is that the section on Java is much too brief given its popularity. Also the chapter that introduces OOP is not particularly well written but it is a minor flaw as most the readers of this book are assumed to have a good understanding of OOP concepts.

An interesting and sometimes insightful survery of object programming languages. If you want to sample some of the major OOP languages and how they came to be then this book is an enjoyable read. HPL : OOP is an excellent collection of essays on OOP languages. However, it cannot be considered a reference by any stretch of imagination.


Fair   July 18, 2001
Dr. Lee D. Carlson (Saint Louis, Missouri USA)
2 out of 2 found this review helpful

This book is the second of the series on programming languages and gives an overview of some representative languages that follow the imperative programming paradigm. Specifically, the languages Fortran, C, Pascal, and Icon are discussed in the book, with the largest coverage given to C. There is also a very short part of the book devoted to "intermediate languages", which are essentially used as intermediaries between high- and low-level languages.

The book starts with a discussion of Fortran, and gives a short history of it development. The chapter emphasizes Fortran 95, and the comparisons between it and Fortran 90. Fortran 95 is presented as having an object-oriented flavor, due to its ability to provide derived data types, procedure overloading, and operator definition. It however cannot support operator inheritance. The author of the article lists the Fortran 90 features that were omitted in Fortran 95, and discusses portability issues. The features to be incorporated in Fortran 2000 and the high performance extension, called High Performance Fortran, are discussed, the later emphasizing ease in parallelization of code. A fairly comprehensive summary of the features and syntax of Fortran 95 is given. The author goes over in detail an interesting example of constructing a new data type in Fortran, namely a type definition for big integers.

In part 2 of the book the history of the C language is discussed, and is written by D. M. Ritchie, one of the developers of the language. It is interesting reading for those curious about how C originated and the developed. This is followed by a rather lengthy overview of the language itself, almost 150 pages long. The author gives good advice on how to deal with the potential complexity of C expressions, namely to think of them recursively. His discussion of how to do this, by first using what he calls primary expressions, is the first I have seen in an introductory exposition on C. Since C does support them, "goto" statements are discussed, but thankfully the author admonishes against their use. A good discussion of function calling in C is given, via its "pass by value" function semantics. The author emphasizes that there is only one exception in C to the requirement that a function not alter the values of variables passed to it as arguments, namely the case of arrays, which are called by reference. For those doing programming for embedded systems, there is a fairly decent discussion of low-level addressing.

After a brief discussion of intermediate languages, the rest of the book covers Pascal and Icon. Except for some experience programming in SNOBOL, I do not know these languages and so I cannot comment on the quality of the presentation.