This book is seriously flawed in several ways. Each class of flaw makes the book useless for a different set of potential readers. On the back cover the book claims to be useful for two types of beginners: those learning their first programming language, and those who are familiar with other programming languages but who are unfamiliar with FORTH. Both of these claims are certainly incorrect. There are too many technical terms used without definition, or with definitions appearing many pages after the point where they would be needed. There are too many meaningless or poorly chosen examples where meaningful ones could have been used. A number of these problems can be illustrated with the first line of FORTH in the book:

FORGET HOUR <Return> :0UOK:9F:Y

It is obvious from context that FORGET and HOUR are FORTH “words,” but it is not explained until several pages later that <Return> designates the pressing of a “return key” of a terminal, and that :0UOK designates a reply from the FORTH interpreter. In fact, it is not clear for many pages that there is an interpreter and that the examples show what happens if they are typed in as commands to the interpreter.

If a novice typed the examples into a FORTH interpreter, they often would not work as shown because many examples depend upon other words that have not been defined yet. Furthermore, if the examples were tested by the authors, the typesetting process must have introduced a number of errors. The most subtle ones for beginners are blanks within FORTH words where they should not be. The blank is the only delimiter in the language.

There are also some obvious errors. For example, multiplication and addition were used in some definitions as logical operators] The book seems to claim that they are traditionally used as Boolean operators in FORTH, which is certainly incorrect. One example, a definition of XOR, is inefficient and unclear and would fail if the operands sum to zero. A better example would have been to define a bitwise XOR in terms of the bitwise logical operators of FORTH.

I suspect that the “claim” about logical operators is really the result of poor translation from the original French. The authors may have meant to say that they were using the arithmetic operators to carry out the traditional Boolean operations. If the operands were small nonnegative numbers, this would work, since zero is Boolean FALSE in FORTH, and all nonzero integers are treated as TRUE. There are many examples throughout the book of incorrect or unusual choices of English words or phrases, as if the translator did not know which of several nontechnical synonyms would be appropriate along with the technical terms. Computer technical terms were chosen correctly.

A final difficulty for either type of beginner is that there are many excursions into technical details that distract the person trying to learn the essentials. It is difficult to know what is immediately important to learn and what can be left for later. The technical underpinnings of the language and system are exposed too early and too often for beginners.

The first four chapters introduce the FORTH language. Chapter One is a small introduction and historical overview. Chapter Two presents the concepts of FORTH words, vocabularies, stacks, and reverse Polish notation. This chapter is difficult for a beginner to computing since little of FORTH itself is actually described. Chapter Three describes enough of the language so that the user may see how things are done, and may try them out. Arithmetic and stack operators, as well as conditional and loop statements, are all introduced. Chapter Four discusses vocabularies again, and goes into detail about the editor vocabulary. With this, it is possible to edit and store program source, instead of typing statements to the interpreter.

The next three chapters are mainly about the underpinnings of the FORTH language and system. Chapter Five describes a typical memory layout for FORTH, the dictionary organization, the format of words, and the operation of the interpreter. Chapter Six goes into considerable detail about compilation and words that may be used to define other words. The user who wishes to extend the compiler will find this of interest. Such extension is a programming technique that is not available except in very limited ways in most languages. Chapter Seven again discusses vocabularies, now to show how they work inside. There is a brief discussion of recursion. There is a section on top-down and bottom-up programming and FORTH program organization.

Chapter Eight describes some computing problems, and suggests some ways in which they may be programmed with FORTH. Sections A1 and A2 of the Appendix describe two editors. There are exercises for Chapters Two, Three, and Six, for which answers are provided in Appendix section A3.

Is the book useful for those who already know FORTH? It is certainly not very useful for the advanced FORTH programmer; it does not go into the workings of FORTH deeply enough. If the reader is already familiar enough with FORTH to program in it, but has not learned how FORTH works inside, then this book might be useful as an intermediate text if the typographical errors and the nonstandard technical English do not distract too much. Nevertheless, I would recommend that a search be made for other books that could serve as intermediate texts. There are a number of them in English. Specifically, I can recommend [1] for an excellent introductory text for both types of beginners. It also covers almost all of the advanced information covered by the book being reviewed here. An excellent advanced book that emphasizes the style of programming that is most effective for FORTH is [2]. One book that gets deeply into the insides of the language is [3].

In summary, there is some potential for this book to be a useful intermediate text on how FORTH works. However, it will need considerable rewriting, editing, and proofreading before that potential can be reached.