Donald E. Knuth

Like any of Donald Knuth’s books, this work constitutes a classic of computer science. Knuth attempts to integrate the art of writing good literature with the art of writing computer code. Using a series of papers and articles published between 1974 and 1989, he illustrates the historical genesis of writing more understandable code. Although modern programmers will find many constructs to be dated, the historical and conceptual value of these writings cannot be underestimated. Without such show more understanding of the past, modern programmers will merely spin their wheels in older problems instead of inventing the future.

This work starts out with an old debate (1970s) on the “goto” statement’s use. The conclusion Knuth reaches is the conclusion the rest of the community ended up maintaining – that the goto statement obscures rather than clarifies readable code. It’s interesting to see, even if just at a scanning glance, how ideas come together in one context and inspire further conversation in later contexts (i.e., the rest of the book). This introduction, though lengthy, climaxes in an important question: What exactly is readable code?

The author develops a system called WEB to address this problem. WEB combines markup text in the TEX markup language with Pascal code. As such, each approach is described twice in code, once in human language and another in computer language. This provides obvious benefit to programmers seeking to maintain code – a challenge far more difficult in today’s context thirty years hence. Although present-day languages are different, many approaches still use the basic kernel of this book’s ideas by combining coding and documentation (e.g., JavaDoc and PHPDoc). These are more than comments; they are systematic documentation for a pre-processor to parse and produce compiled, printable literature.

Obviously, this work is a historical gem to those interested in the history of computing. Advanced programmers and those interested in the theoretical and historical underpinnings of modern technologies will be most interested. Even those working with programmers might find some benefit. Studying the thought processes behind innovation is a helpful process for speeding modern development. This is a really good case study in such approaches over 16 years of written conversations.

Beginning and even intermediate programmers may not be interested in this work as much as I am. However, such programmers should still familiarize themselves with the author’s name Donald Knuth. He is perhaps the greatest founder of computer programming. At the time of my writing (2021), he is still alive. He helped with several advances, including the LaTEX markup language, which is partially described in this book. Literate Programming is often described as a fourth work added to Knuth’s trilogy (his magnum opus) on computer algorithms. It’s always fun and beneficial for me to wrestle with good minds; this book provides plenty of fodder for that. show less

Donald E. Knuth is an emeritus professor of computer science at Stanford. Perhaps computer scientists know him best for his 3-volume _The Art of Computer Programming_, which is allegedly a classic in their field. In my field of mathematics, Knuth is best known for having written the program TeX, which is used by almost all mathematicians to typeset their mathematical writings. His other activities make it not unusual for his name to be mentioned in the same breath as the names of Martin show more Gardner, Douglas Hofstadter, Ron Graham, John Conway, etc.

In 1997, I attended a professional conference at Stanford and saw Knuth in person when he gave a plenary address. His talk didn't stick with me, but I won't soon forget the unusual shirt he was wearing, which made him look like a devotee of some eastern religion. Well, he isn't. It turns out that Knuth is a lifelong Lutheran, that unusual shirt was made for him by one of his co-parishoners, and this book is Knuth's attempt to explain his faith and to relate it to his profession.

This book is a quick and easy read. It's based on a series of 6 talks Knuth gave in a seminar on God and Computer Science at MIT. Much of the book is devoted to a discussion of Knuth's creation of the book 3:16 several years ago. That book dealt with the bible verses Genesis 3:16, Exodus 3:16, . . ., John 3:16, . . ., Revelation 3:16. With no knowledge of Hebrew, Greek, or Aramaic, Knuth came up with his own translation of each of these verses (using Strong's Concordance and similar tools), had a different world-class calligrapher write out each one, and then gave a 4 page analysis of each verse, based on his reading of every commentary he could get his hands on.

In the course of discussing his 3:16 work, Knuth spends a chapter talking about language translation, which ties into Hofstadter's Le Ton Beau De Marot. In fact, in the Q&A session following the MIT lecture
corresponding to this chapter, someone asked Knuth about Hofstadter's book, and he replied that he wasn't familiar with it (even though he apparently knows Hofstadter personally and Hofstadter's book had been in print for about 2 years at the time of the lecture). I think Knuth's decision not to be familiar with Le Ton Beau may have been a wise one!

This book confirms my previous impression of Knuth as an eccentric. His choice of topics seems a bit unusual for a book ostensibly on science and religion. Several of his questioners at the MIT lectures seemed to share my mild disappointment. For example, one questioner after the final lecture asked "What do all these issues of computational complexity, infinity, and the positing of God have to do with good, bad, and purpose?"

When he does open up, Knuth is revealed as a humble and devout Christian, with views leaning toward the liberal side of the spectrum. (It seems like he quotes Tillich--and Harvard's Peter Gomes--an awful lot.) show less

At one point, I wrote C++ code using CWEB. The experience (which I found rather positive) convinced me that almost no other developer I knew would find it positive. (The approach of writing discursive text and code in parallel, although highly conducive to good code, is also extremely demanding.)

This collection of papers, centred on WEB and on related issues -- the article on "The Errors of TeX" should be required reading in any CS course of study -- remains both enlightening and relevant show more thirty-plus years on, although the overall approaches of most software practitioners (IDEs, automated refactoring tools, etc.) make the application of the disciplines described less likely than ever. show less

This latest volume has the cloth cover and sewn binding of the other volumes, which is nice in this day and age of shoddy bookmaking workmanship. A few pages in my copy seem to have gotten too much ink, but I guess that's the price you pay to have a book printed using real ink rather than toner.

The "Mathematical Preliminaries Redux" section talks about countable probability spaces but then talks about nontrivial random processes (of infinite length) that are apparently supported on such show more spaces. In the standard formulation, such a process would be a function with an uncountable range but a countable domain, which I find puzzling. I passed my concerns on to Dr. Knuth, but I wasn't able to convince him that there was an issue. It was an honor to get a hand-written reply from an icon anyway.

At the time of this book's release, Dr. Knuth is 84 and has plans for writing Volumes 5, 6, and 7. May it be! show less