[Ed. Note: This review is part of a series of reviews covering the recent updates to Donald Knuth’s seminal work, The art of computer programming. Please click the links at the end of the review to be taken to the reviews of the other volumes/fascicles.]

When, over three decades ago, Donald Knuth began to produce the work that became a foundation of computer science, he (ironically) called it The art of computer programming. I say ironically, because what he actually did was turn computer programming into computer science. This small volume shows well what this statement really means. This fascicle deals with fundamental algorithms. This volume updates the simulated machine that he invented for the books, MIX. It is now called MMIX, or 2009. Knuth is one of those rare writers who can take material that ought to be really dry and difficult, and, with a combination of humor and vibrancy, turn it to something that is a pleasure to read. This volume is another one of those successes.

It is appropriate to discuss why it might be necessary to still discuss assembly language or even its concepts. A minority of people need to understand machine language. Essentially, everyone else can do anything in third- or fourth-generation languages, without really knowing anything about the underlying processor instruction sets. However, these books are not written for everyone; they are written for people with a real need to understand computers. As such, there are good reasons to understand machine operations, though there are also excellent reasons to avoid using assembly whenever possible, which is almost always. Knuth gives five reasons why he chose this route. These books focus on “timeless truths,” while third- and fourth-generation languages are timely. These books are for people with a need to understand. “Computer science is largely concerned with an understanding of how low-level details make it possible to achieve high-level goals.” He also discusses debugging programs, an art form that is insufficiently taught.

A fascinating section of the book is 1.4.3, “Interpretive Routines.” It is interesting and (perhaps) doubly instructive that he chose to treat this critical subject here. One of the most important tools in any professional programmer’s (mental) backpack is the ability to write a good parser/interpreter of input. This can frequently improve many computer systems; albeit to my chagrin, it is too infrequently used. Knuth’s discussion of them is instructive and very well done. However, from this section, we also see one of Knuth’s limitations. In any human work, there are always boundaries. Knuth’s is that he is essentially a person who thinks in terms of mathematics. Most original computer scientists were such. However, many, if not most, software engineers today are not mathematicians, but are people with practical engineering backgrounds. Many of the examples Knuth uses in this section, and in fact in all of his books, are difficult for software engineers to push through because of this. As brilliant as his writing is, and as good as his explanations are (and they are both very good), the reader will be well served to understand that this is a constraint.

Introduction

Review of Volume 4, Fascicle 2

Review of Volume 4, Fascicle 3

Review of Volume 4, Fascicle 4