What McIlroy could have examined -- and chose not to at the time -- is whether awk, sed, tr, and friends could themselves be written in a literate style, and whether such a rewrite would have achieved the goals that Knuth was setting out for LP.
Knuth could have chosen to break his monolith into multiple, loosely-coupled programs, and then written then all in an LP style. But would that have really made the demonstration any more effective?
I would say yes. Clearly loose-coupling isn't necessary for a program that small. And no, it isn't always optimal.
But I have clear memories of being asked to re-do an intro CS assignment three times because it wasn't in a properly object-oriented style. Modularity is not a necessity all of the time, but it is important sometimes. Demonstrating the potential to write reusable code seems just as important as demonstrating anything else. (If the conclusion is "LP helps clarity, but you can't write libraries", is that even positive?)
As far as I can tell, "this code has only one useful point of entry" was a key part of the anti-LP argument leveled by McIlroy. After all, isn't the goal to demonstrate that LP works for people who aren't Donald Knuth?
My own critique of LP is really more about the act of writing itself. Many people, programmers included, just aren't skilled at it! Knuth's literate programs are interesting because he's got something interesting to day, and his writing style is engaging. But I wouldn't enjoy having to read (or maintain!) a literate program that was written by a poor writer in a dull, meandering style.
Also, Knuth seems to think that the literate style ought to make us into better programmers, simply because we're writing prose along with the code -- that the combination somehow unlocks a better understanding of the problem, how to solve it, and how to explain it to others. That sounds inspiring, but I'm not sure it's really true in the general case. Perhaps more research is needed to find out. :)
Not really.
Knuth focused on maintainability. McIlroy focused on reuse of existing code. These are very different, though both laudable, goals.
As an example consider the widely used program for mathematical typesetting, TeX. Knuth started work on it in 1978. Since 1988 it has only received bug fixes. Despite it being widely used, there have been no bug fixes needed since 2014. I cannot think of another program so widely used with such a good maintenance record.
However TeX itself reuses almost nothing.
No code that Doug McIlroy wrote has a maintenance record to match. But McIlroy was the original author of widely used programs including diff, echo, tr, and join. The combined works of Knuth are unlikely to have been reused in more ways by more people than diff alone.
That wasn't the goal of the exercise. So how is that a key question?
The exercise was: Demonstrate WEB and literate programming with this particular problem. Knuth did that. The question, then, is whether the method demonstrated literate programming and WEB.
If you want to know whether the approach or tools work for creating reusable code and less monolothic code, then that question should be posed and a new exercise performed. The question shouldn't be posed to an exercise where that wasn't a concern, it's dishonest.
See paragraphs 5 & 7.
He would have been rejected as a job applicant immediately as soon as the paragraphs were read.
The meaningful criticism leveled at Knuth's code was that it was monolithic. It's true that it was long because he wrote it from scratch, but that's not enough to force you to be tightly coupled.
Did Knuth try to make his code reusable? Was it reusable? I think those are the key questions.