Why Dijkstra Didn't Like Lisp?

Kazimir Majorinc
November 16th, 2013.

Although sometimes ambiguous, it appears that Edsger W. Dijkstra's attitude toward Lisp was more critical than enthusiastic. Dijkstra complimented Lisp on indirect way, like "it inspired many programmers". However, he wrote more directly that "LISP's syntax is so atrocious that I never understood its popularity" and "Lisp 1.5 was extremely poor language."[1]

It appears that Dijkstra had issue with main Lisp's specificity: code is data. His primary target is not Lisp or McCarthy, but whole concept and its 'father', John von Neumann. Dijkstra insisted on clarity and emphasized correctness of the programs. He believed that programs shouldn't be just debugged, but their correctness should be proven. According to Dijkstra's experience, described in chapter "The problem of next permutation" of "A Discipline of Programming", the separation of code and data is essential for clarity. Dijkstra affirmed usual practice of compiling first, and executing compiled code, without any change. He wrote many times about that, and frequently criticized von Neumann, but he never discussed the issue thoroughly.

I prepared two short Dijkstra's quotes and one short McCarthy's quote to demonstrate how differences between these two positions are irreconcilable.

"I myself added another mistake to the list of those for which most probably John von Neumann has to be blamed. Flowcharts and the idea that programs must be able to modify their own instructions — a sickening pun! — were already on that list, the use of anthropomorphic terminology in computing science has now been added. I got more than once the distinct impression that that unfortunate use of language can be traced fairly directly to von Neumann's linguistic habits. I made this suggestion in my talk and no one denied it, on the contrary: afterwards I was even shown corroborating evidence.

(EWD 572, Trip Report...)

For many years it has been thought one of the essential virtues of the von Neumann type code that a program could modify its own instructions. In the mean time we have discovered that exactly this facility is to a great extent responsible for the lack of clarity in machine code programs. Simultaneously its indispensability has been questioned: all algebraic compilers I know produce an object program that remains constant during its entire execution phase.

(EWD 517, Programming Considered as a Human Activity)
Dijkstra
Edsger W. Dijkstra
John McCarthy
John McCarthy

It seems to me that LISP will probably be superseded for many purposes by a language that does to LISP what LISP does to machine language. Namely it will be a higher level language than LISP that, like LISP and machine language, can refer to its own programs. (However, a higher level language than LISP might have such a large declarative component that its texts may not correspond to programs. If what replaces the interpreter is smart enough, then the text written by a user will be more like a declarative description of the facts about a goal and the means available for attaining it than a program per se.)

(Lisp — Notes on its past and future, 1980.)

If you want more texts, you can check EWD 692 and EWD 123, as well as mentioned chapter in Dijkstra's "Discipline...", but as said, there is no detailed discussion there.

References

  1. Kazimir Majorinc (edited), Edsger W. Dijkstra on Lisp, 2013.
  2. John McCarthy, Lisp — Notes on its past and future, Proceedings of the 1980 ACM conference on LISP and functional programming, 1980.