Maarten van Emden

cf https://vanemden.wordpress.com/2009/01/01/ventilated-prose/ (one of the early hints that Donald Knuth was of the tribe which would become known as "geek" is that as a schoolchild he loved diagramming sentences)

Indeed, Lisp contributed to why Algol 60 has recursion. Quoting https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-progr… > 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.

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-19… Folks today don't seem to read much Dijkstra. I think the growing security industry is one side effect of that.

A few followups: A elaboration from van Emden, which describes part of the problem as Prolog being pushed by Lispers who had only recently become enamored with Prolog: http://vanemden.wordpress.com/2010/08/31/the-fatal-choice/ A different take that blames "technological and cognitive issues" at least in part, especially debugging: http://synthese.wordpress.com/2010/08/21/prologs-death/ A different take that blames competition from more specialized declarative-programming languages: http://www.kmjn.org/notes/prolog_lost_steam.html

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…

This seems related to "ventilated prose", as invented by Buckminster Fuller: https://vanemden.wordpress.com/2009/01/01/ventilated-prose/ I can confirm that while this technique feels odd at first, it does prove very useful when you need to edit or shorten a "wall of text", or express something very concisely. Somehow, the relevant/irrelevant parts of a sentence or thought stand out better this way. IIRC, I even wrote a simple Vimscript function back in the day to join a "ventilated" secton back into a traditional, coherent sentence.

Getting recursive functions into ALGOL turns out to have been a controversial move that made for a fun story: https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-progr…

My condolences and may he dwell in peace. And thank you for the link. I lazily clicked on the first (his last article’s) link* and hours later my mind is still engaged with his words. He zeroed in on a matter (kinds of intelligence) that’s been a recent preoccupation of mine; his hypothesis of partial ordering of intelligence hits the precisely correct distinguishing note in my opinion. Since you were friends, would be interested to know his thoughts on the full scope of Polanyi’s tacit knowledge (that he mentioned in his remarks on “AI”) which included metaphysical aspects. ~ * (this really should be a top level post.) “AI” : what’s in a name? | Maarten van Emden | 2019 https://vanemden.wordpress.com/2019/10/20/ai-whats-in-a-name/

> How is that difficult? Most text editors support word wrapping and syntax highlighting. To add to this, I personally prefer using semantic linefeeds — adding a newline after each sentence or clause (as in e.g. [0] [1]). I find this works exceptionally well with LaTeX, since I get the benefit of the newlines as I write and edit, while the typeset version is formatted nicely into paragraphs for me. (Not that this is unique to LaTeX, of course; Markdown would be no different. The technique works well with all such tools.) [0] https://vanemden.wordpress.com/2009/01/01/ventilated-prose/ [1] https://sembr.org/

I'm surprised no one has mentioned ventilated prose, which is like this but even moreso: https://vanemden.wordpress.com/2009/01/01/ventilated-prose/

There was an interesting controversy surrounding the Algol-60 report. It seems many members of the committee wanted to be able to create implementations of the language that used only static allocations for activation records, but in the "Amsterdam plot," they sneaked into the report the possibility for recursive procedure definitions which require dynamically allocated activation records (not all machines had efficient stacks!). I don't remember where I first learned about this, it might have been this https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-progr…

There is an interesting write-up about Algol 60's recursion [0] that was discussed here before [1]. [0] https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-progr… [1] https://news.ycombinator.com/item?id=10131664

Also see: Early History and Perspectives ofAutomated Deduction (reference mentioned in the interview): http://www.intellektik.de/resources/OsnabrueckBuchfassung.pdf And: Interview with Alan Robinson, inventor of resolution logic (Emde interviewing Robinson on Emde's blog): https://vanemden.wordpress.com/2010/06/08/interview-with-alan-robinson…

How Recursion Got into Programming (2014) https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-progr…

Some previous blog posts on this topic, from a few years ago: "Who Killed Prolog?" by Maarten van Emden. https://vanemden.wordpress.com/2010/08/21/who-killed-prolog/ Posits that the huge hype put into it by the Japanese Fifth Generation Computing Project, which it failed to live up to, essentially killed off interest in the language, which it never recovered from. "Why did Prolog lose steam?", a sort-of reply I wrote. http://www.kmjn.org/notes/prolog_lost_steam.html Posits instead that much of the low-hanging declarative fruit has been picked off by other, more specialized languages, ranging from SQL to production-rule systems to even LINQ, so Prolog no longer is the default go-to declarative programming language.

CPUs had registers back when C was invented too :) The reason C doesn't expose registers is because the flat memory model is more universal and more uniform between CPUs than the registers, which often have a lot of special-case behavior, especially on non-RISC CPUs: https://vanemden.wordpress.com/2016/03/15/why-does-c-not-have-an-expon… Besides, C has a "register" keyword, although it's probably ignored by almost all compilers today in favor of their own optimizations, which are usually better (and if they're not, you're usually gonna go to assembly for maximum performance anyway).

Peter Naur was editor of the Algol 60 report, and with foresight, cunning, and a bit of trickery, he is responsible for getting recursion into a mainstream programming language. https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-progr…

Also Naur did have a good deal of the responsibility for getting support for recursion into Algol 60: https://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-progr… Just think how the programming language landscape might look today if recursion had never gotten into mainstream languages, or maybe only had begun to become the norm recently.

some related and well-reasoned, well-written essays: http://monasandnomos.org/2012/12/05/the-idea-of-a-characteristica-univ… http://vanemden.wordpress.com/2012/04/08/flowcharts-the-once-and-futur…

This reminds me of Dijkstra's wordprocessor[1]. He had a pencil dangling from a string with a sign pointing to it saying "Word Processor". [1] http://vanemden.wordpress.com/2008/05/06/i-remember-edsger-dijkstra-19…

http://vanemden.wordpress.com/2009/01/01/ventilated-prose/ 'Ventilated Prose' was a term used by Buckminster Fuller. The blog author linked above is drafting rapidly, then adding line breaks after each sentence/clause as an editing aid. He mentions Vi and the use of dif http://lists.canonical.org/pipermail/kragen-discuss/2008-March/001086.… Found in the comments to the blog post linked above. Just parking these for the inevitable return of this topic.

There was an article posted here on HN not too long ago about Japan's 5th generation computer project. It was more about what killed logic programming but this China+supercomputing thing reminds me of this a little. Here's the article: http://vanemden.wordpress.com/2010/08/21/who-killed-prolog/ EDIT: Wikipedia page about the project: http://en.wikipedia.org/wiki/Fifth_generation_computer

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/1… https://sembr.org https://asciidoctor.org/docs/asciidoc-recommended-practices/#one-sente… (Actually I think one-sentence-per-line denotes something slightly different from semantic-line-breaks, not that I know what that difference is).

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-…

> 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-progr…