Maarten van Emden, a computer scientist, writes about the history of programming, Prolog, logic, recursion, and Edsger Dijkstra.
HN commenters cite it for its history of recursion in Algol and Lisp and the "Who Killed Prolog?" series, which one reader found fascinating.
I got into Prolog last year, I really love it. I came across the fascinating article "Who Killed Prolog?" (2010), from Maarten van Emden's blog A Programmer's Place.
"Compared to these three [Fortran, Lisp, Smalltalk], Prolog has fallen far behind. This was not the case in the early 1980’s, when Prolog had caught up with Lisp in capturing mindshare of what you could call non-IBM computing (to avoid the vexed term “AI”). Hence the title of this article. As culprit (or benefactor, depending on how you look at it) I identify the Japanese “Fifth-Generation Computer System” project, which existed from 1982 to 1992.
Even for those who were aware of the project at the time, it is now worth reviewing its fascinating history in the context of its time. This article is such a review as well as a theory of how Prolog was killed and how Lisp was saved from this fate."
Richard Grigonis commented in 2014 (incorporated in a Postscript to the article):
"The funny thing about this is that, in 1982, as I recall, Fifth-Generation Computer Systems project director, Kazuhiro Fuchi, came to Columbia University in New York, along with Edward Feigenbaum, to give a speech and answer questions of students. Feigenbaum was railing about how the Japanese were going to take over AI and the world, and we should better fund AI researchers in America or we would all be left behind in the dust. It was as if he was using Fuchi as a prop to get more excitement in America for AI. ...
When the…
The first author of this is John Alan Robinson, inventor of the first unification algorithm and thus the first practical resolution theorem proving algorithm, on which Prolog was developed.
I remember reading a history of Prolog, I think by Kowalski, which mentioned that Robinson always preferred Lisp to Prolog, despite it being built on his ideas. I’ll try and dig out a reference.
Edit: I found the article I was thinking of [1], on Maarten van Emden’s blog. Here is the quote:
> A few years later some excited evangelists brought Robinson the news that resolution had led to a new programming language. Robinson was delighted to see some sample programs and an explanation of how resolution was used to execute them. The evangelists took it for granted that henceforth Robinson would program in Prolog. They were disappointed to learn that no, for Robinson Lisp was the one and only programming language and that it could not even be displaced by an elegant embodiment of his own brain child.
[1]: https://vanemden.wordpress.com/2017/09/08/conceptual-integrity-why-it-matters-and-how-to-get-it/
> So no function calls?
No recursive ones. If you forbid (direct or indirect) recursion, then a function's local variables can all be static rather than stack-allocated. Similarly, each function could have a hidden, static "return address" variable (since all parameters are static, it's really just a hidden parameter) that is set behind the scenes when a procedure is invoked and jumped to when it exits.
edit: I was just guessing how you'd do return addresses, but it looks like that is how they used to work. From Wikipedia: "Machines before the mid 1960s—such as the UNIVAC I, the PDP-1, and the IBM 1130—typically use a calling convention which saved the instruction counter in the first memory location of the called subroutine. This allows arbitrarily deep levels of subroutine nesting, but does not support recursive subroutines."
Ancient Fortran also didn't support recursive procedures, and they were only sneaked into Algol 60: https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-programming-a-comedy-of-errors-3/
It turns out that there is a lot of discourse out there about "semantic newlines", under a few different names. So far the names I've seen are:
- One Sentence Per Line (OSPL) - Semantic Line Breaks (SemBr) - Semantic Linefeeds - Ventilated Prose - Semantic newlines
Reading through the pages below was helpful in getting a better idea of what language people use to discuss this. They're mostly historical retrospectives or arguments for the merit of semantic newlines.
https://rhodesmill.org/brandon/2012/one-sentence-per-line https://ramshankar.org/blog/posts/2019/semantic-line-breaks https://vanemden.wordpress.com/2009/01/01/ventilated-prose https://discuss.python.org/t/semantic-line-breaks/13874 https://discuss.python.org/t/one-sentence-per-line-for-peps-and-more/13920 https://sembr.org https://asciidoctor.org/docs/asciidoc-recommended-practices/#one-sentence-per-line
(Actually I think one-sentence-per-line denotes something slightly different from semantic-line-breaks, not that I know what that difference is).
There are vast archives of his writing here: http://www.cs.utexas.edu/users/EWD/
A paper describing THE: http://www.cs.virginia.edu/~zaher/classes/CS656/p341-dijkstra.pdf
This paper here http://www.tomandmaria.com/tom/Writing/DijkstrasCrisis_LeidenDRAFT.pdf has a worthwhile quote:
Dijkstra’s crisis was rather more idiosyncratic than has generally been acknowledged. He took up the
language of crisis to convey the need to replace “Chinese armies” of badly trained and mediocre
programmers with an elite corps of “mathematical engineers” modeled on himself.
Here is an article of personal reflections about a correspondence with Dijkstra: http://vanemden.wordpress.com/2008/05/06/i-remember-edsger-dijkstra-1930-2002/.
Folks today don't seem to read much Dijkstra. I think the growing security industry is one side effect of that.
Indeed, Lisp contributed to why Algol 60 has recursion. Quoting https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-programming-a-comedy-of-errors-3/
> McCarthy, fresh from the success of his Lisp project, was enthusiastic about recursion as an elegant way to get computers to do what they are best at: repeat execution of the same code with suitable modification each time around. In fact, the first Lisp had no iteration, so that the only way to add all elements of a linear list was to write a recursively defined function. As a member of the Algol committee he proposed making the possibility of recursion a feature of the new language. The proposal was crowded out by more pressing concerns. The result was that in the early months of 1960, when the report was to be finalized, there was no consensus on recursion.