According to the preface, “The basic purpose of this book is to examine the analysis and design methodologies relevant to user-oriented (user-friendly) computer language systems and consistent with some fifth- and sixth-generation computer concepts for very high-level languages. This book also analyzes some conventional programming languages to illustrate the aspects that can be regarded as user-friendly and those that are antithetical to that concept.” Technically, these words are probably accurate, but the book was not at all what I expected it to be. The author’s primary interest is in two-dimensional languages. Such a language permits the following type of statement (Figure 8.4) as part of the syntax and semantics:

print₀∫¹ x ² - 2 x + 3 d x .end

The first seven chapters of the book take the reader through the basic concepts found in most comparative programming language texts. They cover topics such as criteria for language design, BNF, assignment statements, control structures, I/O, declarations, types, scopes, procedures, parameter passing, iteration, and recursion. This discussion covers most of the main points, but far more thorough treatments of this material can be found in any number of other texts. In analyzing existing language features, the author rarely expresses positive reactions; however, he repeatedly makes forward references to chapter 8 regarding his “better way” of doing things.

The unusual aspect of Klerer’s exposition in chapters 1 through 7 is the heavy use of strong opinions, often conveyed as if they were facts. In many cases I had serious disagreements with his views. For example, in talking about integer versus real in FORTRAN, Klerer states,

If one is concerned with execution efficiency, that is, the minimization of the running time of a program for a particular machine, then one can make arguments to support the distinction among integers, real numbers, and floating point representations. But from the point of view of the user and the language designer who wishes to accommodate the user, it is not clear that any real advantage is gained from such a categorical division and separate numerical representations into integer, fixed point, and floating point by requiring rigid type declarations of names. For modern processors, even the efficiency gain is minimal if an effective optimizing compiler is used.

While I partially agree with this perspective, I find the last sentence outrageous, particularly since the accuracy of many scientific programs varies dramatically just between 32- and 64-bit arithmetic. As one last example, in talking about a language designer’s use of various parenthesis pairs, such as (), [], and {}, Klerer indicates that the choice is usually made for “implementation reasons in the hope that the lexical phase of compilation or interpretation will be more efficient.… Language designers historically have overestimated the difficulties associated with implementation and thus have tended to select language designs that they (mistakenly) assume will simplify implementation. Because of that, programmers/users have been passive receptors of the most obtuse computer-language artifacts.” I find this view to be an unacceptable generalization that is unsupported by facts.

Chapters 8 and 9 promote the AUTOMATED PROGRAMMER, a user-oriented automatic programming system of which Klerer is a co-developer. This work argues that by using the basic mathematical notation and relying on compilers to do the translation, the code is essentially self-documenting. The emphasis in the book is on a far more robust interface for user ease. Indeed, many of the examples illustrate a large code expansion in going from this notation to standard C or FORTRAN source code. In my opinion, when combined with a substantial backend processor like Macsyma or Mathematica, this style of user interface can have significant value.

Overall, my impressions of this book are negative. The book’s biggest weakness is a total lack of discussion of algorithms and the role they play. From the text, it would appear that all a user need do is write an integral sign or a differential equation and let the computer do the rest. We are nowhere near that level of sophistication, particularly for the scientific, engineering, and mathematical applications that this text purports to address. The emphasis on two-dimensional programming, while having substantial merit, falls far short of my definition of very high-level languages. Finally, I dislike the author’s plodding and pedantic writing style. I tended to disagree often with Klerer’s opinions and perceptions. They are inconsistent with my experiences related to scientific computing. In a classroom setting, I would prefer to cover this material by using some other recommended text for the study of programming languages and augmenting the material with a research paper or two on two-dimensional languages.