Show HN: I wrote a technical history book on Lisp | Hacker News Reader

Show HN: I wrote a technical history book on Lisp

berksoft.ca

252 pointscdegroot100 comments

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.

Open articleView on HN

I felt, like some of the other commenters, that I was close to buying the book, but that the sample on Amazon wasn't helping to support a buying decision.

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

Thanks for sharing that paper, I didn't know about it. It looks really interesting.

And here's an English translation of the History chapter from Stoyan's 1980 book _LISP-Anwendungsgebiete, Grundbegriffe, Geschichte_ [LISP Application, Basic Concepts, History]: https://softwarepreservation.computerhistory.org/LISP/book/S...

Really nice of you to share it, thank you.

I will read them over the weekend.

Thanks. Even though I'm originally from Europe, the book has ended up somewhat focused on what happened on the continent where I now live. It's something I'm planning to fix for a potential second edition.

Soo.... the book has a bit of a history (see the acknowledgements). When I worked with a publisher, "academic" things like a bibliography were somewhat de-emphasized and the tooling was not nearly as nice as, well, BibTeX. So we went for a very short bibliography containing works that were directly quoted. I did read the paper way back when doing research for the first chapters, but over the years the reference got lost and that's the main reason it didn't make it in.

But you're right, it (and many, many, _many_ other things) does belong in the bibliography.

Can i get it in pdf form, or at least, can i get a copy of the epub, instead of being helf hostage to a proprietary reading walled garden like Amazon. Does Nook allow you to download the epub file? But, I’d prefer pdf.

The Kobo version is a DRM free epub, so you can read it wherever you like. I'm still figuring out how/where to sell a PDF, because I really, really, _really_ do not like epub for technical books. It's ok for novels, at best. Tips welcome.

https://berksoft.ca/gol/genius-of-lisp-chapter-8.pdf has a free chapter.

Polar.sh's pretty easy to set up! It was originally built with selling download links in mind (for stuff like OSS software).

Not affiliated, just a happy customer.

I'm gonna check it out, thanks.

Turns out that for me, Shopify was even easier, so that's sorted now. In any case, thanks for pushing me into the right direction.

Yup, you can now. berksoft.ca/gol has a link to a (DRM free) PDF version.

The bibliography contains a typo, namely entry 5 misses an "l" in Allegro.

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

And here's some interesting background info on the late John Allen which I just stumbled upon:

John Allen (1937-2022) and Anatomy of LISP https://mcjones.org/dustydecks/archives/2024/04/11/1249/

excellent. Also cool that Allen wrote TCL Lisp.

And it's worth pointing out here that the book itself is now freely available: https://dl.acm.org/doi/book/10.5555/542865

Maybe I’m missing something, but that webpage only seems to provide a PDF containing the beginning of the book (up through the Preface). Perhaps you need a ACM Digital Library Premium subscription to access the entire book?

Sigh -- they keep changing the rules. I think you have to have a free ACM account. If you send me an email (see my home page in my profile), I'll send you a PDF.

I appreciate your offer, but there’s no need. I subsequently found a copy here:

https://softwarepreservation.computerhistory.org/LISP/book/A...

I should have given this link also: https://softwarepreservation.computerhistory.org/LISP/book/A...

Thanks! I'm getting a lot of references here, I guess a next edition will at the very least come with a longer bibliography :)

It's well worth a read for anyone who wants to implement their own Lisp. I'd say it's the precursor of Lisp In Small Pieces by Christian Queinnec though. I have copies of both.

I agree that John Allen’s book was incredibly useful 40 years ago to explain some of the nitty-gritty of implementing Lisp languages, but I can’t really recommend it today. The Genius of Lisp is fun and entertaining - something that I would recommend for the modern reader who wants material on the essence of Lisp languages with interesting history.

Adding it to the bibliography would be great, I just didn’t like the idea of someone seeing your comment, ordering a used copy of the very old Allen book and not enjoying it.

Thanks for pointing it out. It's on the edits list for the next round :)

I will take a look, it looks really interesting. Thanks for the effort. I'm also interested in Lisp.

I think you might like this: 'The evolution of Lisp' by Guy L. Steele and Richard P. Gabriel. https://doi.org/10.1145/234286.1057818

This one is similar but about Haskell, and is quite interesting as well: 'A history of Haskell: being lazy with class' by Paul Hudak, Simon Peyton Jones et al. https://doi.org/10.1145/1238844.1238856

I think it is worth noting that Richard P. Gabriel wrote the forward to the book in question, and he quotes Guy L. Steele in that forward -- from the paper that you are suggesting the author might like.

Yes, so it makes sense that he'll like it, if he did not know the paper already.

Or you mean he'll probably already know about the paper? Yes, I guess that's probably the case...

I did not think about it too much to be honest, I just knew that article and thought that he would really like it if he had not read it. But I can imagine somebody writing a book on the history of Lisp has already read probably all articles around on the topic.

I just did not think about it for too long.

Yup, I know of that paper. The amount of (not or partly acknowledged) reading I've done for the book borders on the insane so I do welcome these suggestions, I've forgotten 80% of what I read and learning what others value helps me put together a "you really should revisit this" list :)

Great endeavour. Land of lisp is still one of my favourite alternative programming books.

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.

> Is there a chance to get a glimpse of a random chapter you like a lot?

+1, I'm this close of ordering the hard-cover version, but really hesitant when there is zero samples, not even a page or two, makes it really hard to have any sort of expectation and figuring out if the price is worth it or not.

Yeah, it's one of the things that I wanted to do and then I was undecided which chapter to pick. But your criticism is valid, I'll pick a chapter and cut it out from the PDF and put it up hopefully later tonight (EST). Watch this space and don't hesitate to prod me :)

https://berksoft.ca/gol/genius-of-lisp-chapter-8.pdf (and of course the stuff that Amazon has in their preview, which amazingly goes all the way through the introductory chapter but yeah, misses something meatier than that).

That's great, thank you so much! Looks like a joy to read, and zero complaints or feedback. Now awaiting the arrival of my copy :)

Yup, https://berksoft.ca/gol/genius-of-lisp-chapter-8.pdf hopefully serves you better.

It does. Great. Thanks for the quick update.

I have some feedbak, nothing major, but I would say that a professional designer could help you improve the book cover. Right now somebody with professional experience in graphic design --or a good eye for design-- can probably see details in it that could be improved. It's a pity if you have worked on this for five years, not to present it in the best possible way.

It's more likely that they focused on the book's content rather than the cover art for 5 years

I have not said that he should spend five years focusing on the cover of the book.

Yup. I'm not happy with the design. Some promised assistance fell through and so I had to scramble last minute. I've seen worse though :)

(Specific tips on improving the current design welcome, most stores allow edits)

Yes, yes, definitely, it's okay. I like the design, actually. :) But it would be nice to have the touch of a professional, if you can.

I would say that your choice of cover design as a whole denotes elegance and taste. Look at the cover design of graphic designer Manuel Estrada:

https://estradadesign.eu/project/alianza-editorial/

Your cover remind me of that kind of style.

There are some details about the typeface, layout, and the photograph that, as somebody with a certain background in graphic design, I can perceive as a little bit off.

The photograph was chosen because I could not find other computer books with that somewhat harsh color scheme, and you gotta stand out :)

That's all right. Focusing on the cover's photo, for example, I think you used a photograph that you had around. A professional designer working on a cover would (hopefully) shoot a flower on a studio, with professional lightning equipment, arranging the light sources in a certain way. I mean to get the final result of the kinds of covers I linked to earlier, which to be honest are exceptionally well designed covers!...

Those are the kinds of details I was referring to. On the other hand, many computer science covers have historically been quite poor in terms of design, and of course that does not mean much about the quality of the book itself. Some poor covers became memorable and iconic. Some covers are really simple and yet effective like the O'Reilly covers which I particularly like.

Sorry this is going on a tangent unrelated to Lisp. I do like the design of the book cover with the elegant white background. Thanks for writing it, I can't wait to read it.

Definitely don't worry too much about it. I did not want to sound negative, it's just the first thing that came to mind as feedback. I haven't had the time to read the book, only had time to look at the cover, haha. :D

When one learns about graphic design, one ends up obsessing about these kinds of things. "These text lines need a tiny little bit more of space"... "Those margins are slighly too small"...

It's just job conditioning... At some point in my life I was playing the game of trying to recognize the fonts I was looking at in the adds and signs as I walking down the street.

I know. And frankly, I'm not even the worst coder when it comes to graphic design. I know enough to see that _something_ is off with the cover, but not enough to figure out what ;-).

One thing you could to do the cover to immediately improve it is add margins to the title text, especially to the top. The subtitle is also too long, "ever created" is superfluous. And you shouldn't capitalise the H in history; either make the whole thing title case, or normal sentence case (we don't capitalise nouns or use capitalisation for emphasis in English).

Disclaimer: I'm not a professional, but you did ask ;)

The cover design is nice enough IMO, but it definitely looks like a self-help book or something rather than a technical monograph.

The image on the site has incorrect capitalization ("A History of..."), though the one on Amazon appears to be corrected.

It's the eBook cover for Kobo which I used there. Thanks, I'll go and fix it tonight.

Sounds very cool. I've dabbled with Lisp on and off since the mid-80's, starting with a text adventure in LISP-80 on a Kaypro 4, and though I've never written a serious project in Lisp I've learned a great deal from it. (Wrote a lot of TCL code once upon a time; I've always thought of TCL as a Lisp in which you do a lot of things backwards.)

I think "minimalistic" languages like Tcl, and Lua, took a good look at Lisp before starting off.

People requested more sample material than Amazon provides, and that's a perfectly understandable request. Chapter 8, about Scheme, it is. https://berksoft.ca/gol/genius-of-lisp-chapter-8.pdf is where you can read it.

I always buy every Lisp related book I see. I bought this book on Kobo as an eBook. So far, I have spent less than an hour looking through a few sections; fun stuff! I like the wide variety of code snippets mixed with background and history.

I will revisit our discussion here in a day or two after I finish reading this book.

I skimmed the index but… no Clojure? My impression is that it is by far the most used current Lisp. This said, I’d love to read the book - definitely interesting.

There's a whole chapter on Clojure, don't worry :) (that's probably why it didn't make the index)

chapter 13 covers Clojure

Thank you, looks great!

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.

Ok I looked at the bibliography. Best I can say is that this book might be ok for a cross-section of Lisp history but I'd like to see something much more thorough, especially regarding early Lisp, and with more of a PLT perspective. Why all those citations of Gödel but nothing(?) about typed lambda calculus or the Kleene-Rosser paradox (that Church's untyped lambda calculus is logically inconsistent)? Do you have anything about Lisp 2? About significant Lisp applications like Macsyma, that drove the language's development?

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/ .

When writing a book, you can't make everybody happy. I wrote this for a somewhat general techie audience and already had debates about the amount of math material in the lead-up to LISP I :-). Especially here on HN, there's a better-than-average chance that people will want more, something more encyclopedic, and I get that but "ok for a cross-section of Lisp history" already fills a book, I had to stop somewhere. Too much for some, not enough for others, hopefully "mostly ok" for most readers, it's all I can aim for.

And +1 on a comprehensive Lisp history bibliography, that's a great idea.

> When writing a book, you can't make everybody happy.

The usual reason a reader might be unhappy is that something they wanted to see isn't there. So the solution is put in as much as you possibly can ;). Maybe future editions can be bigger and more comprehensive. OTOH there seems to be quite a lot of what amounts to implementation tutorials. Maybe that's not needed in a history book. In a history book I'm more interested in sources than narrative. Although, some interviews with important Lispers would also be cool.

I can understand not wanting to put in too much math and theory and that's fine. I can't really tell what is there and what isn't beyond getting some hints from the bibliography entries.

This (by McCarthy) showed up immediately when I searched for something unrelated, some articles by Jeff Barnett about Lisp 2: http://jmc.stanford.edu/articles/lisp/lisp.pdf

This is a link dump about Lisp 2: https://softwarepreservation.computerhistory.org/LISP/lisp2_...

I have been wanting to look into Lisp 2 because it had supposedly had an interesting trick in its GC. It was a compacting mark/sweep GC but had an antecedent of generational GC where it usually wouldn't bother trying to reclaim memory that had already survived compaction once. I've been interested in re-implementing that trick in some modern implementations for small MCUs.

The link dump includes scans of the source code and a link to this free-to-read paper on the history of the Lisp 2 project: https://ieeexplore.ieee.org/document/8267589 (I’m the author).

Didn't know about the planned GC tricks (I mostly treat LISP 2 in passing so it most salient superficial points: the syntax and the fact it never happened), interesting!

W.r.t. tutorials: the most code-rich chapter is the one about "the Maxwell equations of software". As a Smalltalker, I'm well aware of Kay's label of the code in the LISP 1.5 manual. It's a good exercise, especially for non-Lispers, but dare I say also for most Lispers, to implement this stuff to both see how powerful simple ideas can be and to see how this magic works in its bare essence (stripped of "noise" like parsers, etc). The rest is basically illustrations of concepts, and that's on purpose; I wanted to write a history book primarily aimed at techies, so code had to be there.

Other reasons are:

- what they want is there but not explained or presented in a way that clicks for them

- something is there that they don't want

The latter would be a "WONTFIX". The former is a major difficulty because presenting the same ideas in umpteen ways adds bulk without significant content. If you have the same ideas from every possible angle, it becomes search problem for the reader quickly turning into a TL;DR.

Here are some bibliographies, including an extensive (but old) one by Herbert Stoyan. Apologies for the rough formatting of them: https://softwarepreservation.computerhistory.org/LISP/resour...

Technical history or "internal history" is great. Regular historians writing "external history" of computing tend to focus on certain topics, such as business and economic issues, politics, personalities, or occasionally social impact, while omitting the details of the technology itself - which are often of great interest to practitioners, and which help us understand why things happen to work the way they do.

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

Positive feedback: really nice that this is available in Rakuten Kobo (as a Kobo user).

I'm Canadian. Need to support what little we have here we call "tech industry" even when it's Japanese owned these days :)

Chapter 8 sample pdf has a typo(?) in the first paragraph. Carl Hewitt's last name is spelled both Hewitt and "Hewitz", maybe even in the same sentence.

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.

Darn, I had his name wrong and fixed it, but somewhere an undo button must have been hit. Thanks for pointing it out.

I'm more than happy to add corrections to an already "longer than zero" list of errata. I'll give the Scheme chapter and Wikipedia a once-over to see where I went off the rails.

There's also an issue where Hewitt's actors were more like Erlang processes, i.e. unlike Scheme closures, they could run independently of each other. Maybe call/cc can simulate something like that. I remember the footnote in SICP claiming that Scheme was developed partly to understand what Hewitt was talking about, but I think that might not have been serious. It could be worth trying to talk to Steele or Sussman about this history.

Yup, and the book mentions that, including the surprising result that (Hewitt-style) actors - which are not completely like Erlang processes - and Scheme's closures were the same.

It's Cees de Groot! Or "Carpe Grootem" as my brain has called him for years. I remember his contributions to the Squeak community from back in the day.

These days it's all "I am Groot" :-)

_waves a branch_

I saw your GitHub profile pic.

A while back I reported to a guy with the first name Jean-Luc. His avatar picture in HipChat (which was still a thing back then) was, of course, Picard...

Great work. I've put it on my to read list for this year. I currently use Haskell and OCaml/ReScript (with Emacs!), but I always enjoy reading Lisp books and imagine my self building systems in Lisp and exploring code in the REPL. Could you talk about some of your experiences of building software in Lisp?

It's... "different". I think there are two big things going on: one is the fact that "refactoring" never ends, as you can mold the language around your problem. Ultimately that level of expressiveness makes the hard parts of your code more concise, more readable (as the code ends up being closer to the domain at hand), and therefore more maintainable.

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.

Great book, I will definitely buy it, thanks for your work! The history is very important, as you’ve said in your blog post, but companies and universities don’t care much about such things unfortunately. I see there is a chapter on Clojure, so just wondering if you had the chance to interview Rich Hickey for the book?

No, I didn't. I probably should have, but the sheer magnitude of the project ran off with all my good ideas :). There's already a bunch of things I want to add in a second edition, if that ever happens, there are just so many stories to tell and only so much time. .

"arguably the most powerful programming language in the history of computing"

That can be said about quite a few languages, Forth included. The most powerful != easy to use and/or comprehend.

That's why I said "arguably", of course.

But, to be honest: Forth is great, but... well... there's no "easy mode" Forth. Whereas there is "easy mode" Scheme - even SICP starts with a very simple and gentle up ramp - so I'd argue to give the honours to Lisp (I'm putting Smalltalk in second place). But that's my personal opinion, I get to put it on my book cover, that's all :-)

This is amazing. I’m tempted to read it backwards just to see the Lisp I know get more and more alien, until we reach the Benjamin Button stage of m-expressions.

The book goes back a bit more, so you'd end at Church :-)

what's the print like on amazon ones (.de)? I ordered two books once from lulu and woved never to do that again. Print was unreadable, and I'm not _that_ picky. They blamed it on the authors prep and offered a refund though. I was so mad, and still am that it turned me away from them completely though, unless someone tells me they worked at least some QA in their process.

I would expect it to be good - it's typeset with LaTeX and shipped as a regular (vector) PDF, the rest is on Lulu/Amazon but I don't expect issues there. To be completely honest, I'm still waiting for the author copy from Lulu, which I'm using as a final check before allowing wider distribution (channels that don't allow quick fixes). But I've ordered several books from Lulu in the past, and they were fine, to my (amateur) eyes looked the same as something from a regular publisher (the modern ones likely use the same/similar print-on-demand hardware).

I've found Lulu to be decent quality, much better than other print on demand books like Lightning Source (used by O'Reilly). But they are only a printer/binder and can't correct typesetting problems (well, I suppose they could help or reject them, but I guess they don't).

Yup. They have a lot of resources available on how to do it but what gets printed is 100% the author's (or publisher's) responsibility.

Cees: typo in chapter 8. "specifically on recursrive".

Always loved actors, but unfortunately scheme didn't champion them.

Thanks. An initial list of errata will appear this weekend (probably tomorrow). I think I'll add a RSS feed for it :)

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.

Is this book written with AI? I see some indicators but it's not a sure thing.

Absolutely not. I created every mistake painstakingly by hand ;-)

Having some personal memories about John McCarthy included in the book is amazing.

Yeah, you can't imagine how happy I was when first RPG sent me some of that material to help me out with background and then said yes when I asked him for permission to include them verbatim in my book. He's such a good writer.

This is a nice and unexpected release, thanks for writing it. Getting a RPG endorsement is great. I just finished reading his foreword and skimming the table of contents and bibliography from the preview. I'd have liked to see a sample of a middle chapter to really see how technical and deep it gets (e.g. Land of Lisp gives its chapter 8 as a sample which I think is very representative for that book). But I plan to get this book regardless -- just not right now.

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 undigitized box at the museum that might contain printouts etc. (There might be MYCIN source code, even.)

Yes, the book doesn't do Lisp justice, it is too short. But at the current volume, I had something at least passing muster; I'm toying with extending it but that depends on feedback/success/etc. There are a lot of Lisp implementations I haven't mentioned (or dealt with in the depth they deserve), there is a lot more to say about the sort of AI work that was (and, I think, is) done with Lisp, etc. And I have written it with a "general techie" audience in mind more than "I'm already a hardcore Lisper", I will probably disappoint the latter group with a lack of depth. I haven't aspired to LOL or PAIP or similar great works.

It's a history through a lens, but if there is one I'd say "MIT/Stanford" as a central axis rather than a field of reesarch.

And Javascript? My own choice. The amount of "language" I needed was very small and I actually like the very minimalistic (lisp-y?) sort of Javascript you can write these days if you just ignore most of its history. It's accessible, that was more important to me than anything else - one of the few concessions where I wanted to make things digestible to as wide an audience as possible in a language that was good for the problem at hand. Strangely enough, it worked very well (I think).

I heard your (and others') request for a better sample chapter than the intro that Amazon shows, I'll put it on the site as soon as possible.

> And Javascript? My own choice.

That choice absolutely makes sense, once you recall that Brendan Eich was initially hired to write a Scheme! Business and Netscape being what they are, it ended up with Javascript, but there are some lispy roots.

See eg. https://brendaneich.com/2008/04/popularity/

I went for the somewhat humbler reasons of "I can assume that my reader will know it at least a bit" and "simple to obtain" - a bunch of the examples will run in the browser :-)

But yes, JS' dynamic/LISP-y roots did make my examples simple to implement and thus simple to follow. No trickery was needed, it was all pretty straightforward.

(JS is a much maligned language and for very good reasons, it had a shaky past and still is too full of warts that should be excised at some point. But modern JS with the help of modern IDEs isn't actually _that_ terrible and traits like it being prototype-based make some otherwise complicated things easy)

https://berksoft.ca/gol/genius-of-lisp-chapter-8.pdf is the chapter on Scheme, now on the book's site as a free sample. Hope you like it.

There's now a list of errata which I'll keep working on, https://berksoft.ca/gol/errata_1.html

Reply on news.ycombinator.com