Handbook of Programming Language

Rating:
Summary: This set sucks
Review: I am very disappointed by this set.

The first volume, Object-Oriented Programming, is the largest of the four. It has some interesting articles on Smalltalk and C++, but it also has some filler, including a useless article on CORBA, and devotes (in my opinion) too much time to static OO languages. It would have been nicer to see articles on Self, or on Objective-C, rather than say on Modula-3.

The second volume, Imperative Languages, doesn't have much to recommend it, either. The section on C regurgitates Kernighan and Ritche. The section on Icon was interesting, but I question its usefullness. How many people actually use Icon ?

Both the Little Languages and Functional and Logic Programming Languages are marred by typographical errors and omissions, which make it difficult to see the author's intent. The Little Languages book is probably my favorite out of the four volumes. I enjoyed the articles on Tcl and Python, and found the material on troff and eqn to be interesting as well.

The Functional and Logic volume devotes all of its functional languages discussion to Lisp and its offspring. This is really pathetic. Haskell and ML are both mentioned in the forward. Why couldn't one of them get an article ?

All in all, the set is not worth the money. The books don't seem very focused. Some articles are basically languages references, while others present histories of the languages, and offer basic intro material. I'm not sure what the reader is supposed to get out of this. It would have been better to include language comparisions, and have more discussion of language features and examples of real-world usage.

I think that the average person would be better off buying Tim Budd's book on OOP, and references on the imperative, scripting and functional languages of their choice.

Rating:
Summary: Fair
Review: 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.