Show HN: I wrote a technical history book on Lisp (berksoft.ca)
The book page links to a blog post that explains how I got about it (and
has a link to sample content), but the TL&DR is that I could not find
a lot of books that were on "our" history _and_ were larded with technical
details. So I set about writing one, and some five years later I'm happy
to share the result. I think it's one of the few "computer history" books that has tons of code, but correct me if I'm wrong (I wrote this both to tell a story and to learn :-)).
My favorite languages are Smalltalk and Lisp, but as an Emacs user, I've been using the latter for much longer and for my current projects, Common Lisp is a better fit, so I call myself "a Lisp-er" these days. If people like what I did, I do have plans to write some more (but probably only after I retire, writing next to a full-time job is heard). Maybe on Smalltalk, maybe on computer networks - two topics close to my heart.
And a shout-out to Dick Gabriel, he contributed some great personal memories about the man who started it all, John McCarthy.
34 comments
[ 3.8 ms ] story [ 65.3 ms ] threadI think you might like this: 'The evolution of Lisp' by Guy L. Steele and Richard P. Gabriel. https://doi.org/10.1145/234286.1057818
The back blurb hints that expert systems might be mentioned, but how much? No one ever seems to go much into their implementation or usage.[0] It also mentions writing some JS, which I guess is part of chapter 5, I wonder if that was a publisher request. (My favorite take on that subject in recent years is https://github.com/jart/sectorlisp)
Would it be fair to say this is mainly a history told through the lens of AI and PL research?
Amusingly I think part of me is already setting myself up for some disappointment -- it seems too short with too few references! But it's good to have a Lisp history book like this looks to be and I'm sure I'll learn things from it, and the promise of more RPG writings inside is enticing. Besides, any complete telling would take multiple books. (There's so much of historical interest locked up in proprietary applications and companies with their own histories, and so many papers published, there's also so much that can be dug through in the standardization mailing list (and other lists, like emacs) archives[1], the SAIL archives[2], the Xerox PARC archives[3], the CMU archives[4], and the many undigitized things sitting in boxes at the computer history museum...[5])
[0] Norvig's PAIP gives a small taste, one of the files: https://github.com/norvig/paip-lisp/blob/main/lisp/mycin-r.l... And a book about a particular system, MYCIN: https://www.shortliffe.net/Buchanan-Shortliffe-1984/MYCIN%20... And a short video: https://youtube.com/watch?v=a65uwr_O7mM
[1] http://ml.cddddr.org/ and http://cl-su-ai.lisp.se/
[2] https://www.saildart.org/
[3] The url I had before is down... I made a local copy but https://archive.org/details/2014.01.ftp.parc.xerox.com might be the same content
[4] https://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/...
[5] Even in the earliest Lisp reports like https://www.researchgate.net/publication/42766480_Artificial... there are interesting things mentioned like a two-move checkmate program or "Other projects on which work continues include the Advice Taker, visual pattern recognition, and an artificial hand." Multiple times I've tried to track down those sorts of things mentioned in really old papers only to hit dead-ends on so many of them. Sometimes things were embellished, or were abandoned, or were just lost to time, and sometimes there's an undigit...
One thing about the sample. Is there a chance to get a glimpse of a random chapter you like a lot? Most of it seems to be foreword/acknowledgement and a bit on "what is lisp" which I suspect most who are attracted might already know.
That can be said about quite a few languages, Forth included. The most powerful != easy to use and/or comprehend.
But thankfully the bibliography is given on the book's Web site in full, so I just checked if the most important paper on the history of early LISP [1] was cited or not. It wasn't, so I'm going to pass on ordering the book's first edition.
[1] https://dl.acm.org/doi/abs/10.1145/800055.802047
Have you seen Behind the Parentheses, by Mark Jones Lorenzo? It goes into quite a lot of technical details about how things like eval/apply were implemented for example, and the larger academic and business contexts eg FORTRAN and earlier language development.
I’m a Lisp newbie (and mostly here for the Emacs Lisp) so a fair amount was beyond me, but I still found it quite readable and interesting.
And a book, which I'd call "an Oldie but Goldie" could be added: John Allen's "Anatomy of Lisp" (1978) which still is an excellent read for those who want to dive deep into Lisp's interna. One might also call it a precursor of SICP, as it covers a number of introductory topics too.
Abstract: https://dl.acm.org/doi/10.5555/542865
I will revisit our discussion here in a day or two after I finish reading this book.
Using an accumulation parameter with tail recursion was per Wikipedia introduced in one of the LTU papers, sometime before Scheme. So the description in the chapter is at best imprecise. But, I would want to look further back historically to see whether any Algol compilers used the technique.
Overall the book looks readable as an intro to Lisp and Lisp implementation, but in a history book I'd like to see more precision and depth, careful citations, etc.
It would be awesome to have a comprehensive Lisp history bibliography perhaps built around user contributions, something like Richard Jones's garbage collection bibliography https://www.cs.kent.ac.uk/people/staff/rej/gcbib/ .
Of course people who experienced things firsthand often have interesting personal as well as technical insight. CHM's oral histories often provide a combination of both. I also always enjoy:
https://www.folklore.org/Busy_Being_Born.html
Always loved actors, but unfortunately scheme didn't champion them.
W.r.t. actors and scheme: the whole thing is that Sussman and Steele started Scheme to figure out actors, did some hacking to do async stuff on top of Maclisp, essentially, and then found out that their stuff and (Hewitt-style) actors were the same. So I guess Scheme took "the same but a different" path early on, pretty much how Erlang and Golang are pretty much similarly powerful systems, expressing the same functionality in different ways.
The other thing, which it shares with Smalltalk and which I've seen pretty much nowhere else (Erlang comes very close) is the interactivity. You code inside a running system. Yes, other languages have things they call "the REPL", but they can't deal with classes changing shape, reloading code, etc. It makes the coding cycle much shorter, quicker feedback is better feedback, so you end up going faster (and iterating through complex stuff like that macro that will really nail how clean your top level code is will be much more doable)
When I mentor coders, I often talk about malleable code, like the clay on a potter's table. As soon as you stop working it, things start solidifying and your code turns into something unchangeable and brittle. I think Lisp's traits (which I otherwise only found in Smalltalk) help you push back that point, maybe indefinitely.