Guy Steele. Common Lisp: The Language. Digital Press. ISBN 1-55558-041-6. 1990.

The reference manual for Common Lisp, also available online in its entirety. This is very much a reference manual and not a tutorial, but having said that it’s a lot more accessible than many such documents.

It’s remarkable that Common Lisp’s standard has been stable for over thirty years, despite enormous advances in Lisp practices in that time. It shows the care that went into the original standardisation process, but also the effects of some detailed technical choices and (especially) the use of macros in preference to new core mechanisms.

However, it has to be said that the standard also fixed in place certain choices that now seem questionable. It’s a matter of opinion, of course, but personally I think the questionable set includes at least: multiple-value returns and binds, which are unnecessary when you can return lists and destructure them and that impinge on the minimalism of the core language; and allowing symbols to be bound simultaneously to values and functions, which unnecessarily treats the two differently (and for which reason it was removed from Scheme).

Harold Abelson and Gerald Jay Sussman. Structure and Interpretation of Computer Programs. MIT Press. 1985.

A book once described (by me, actually) as “the only computer science book worth reading twice”, and which was the foundational text for teaching programming at MIT for decades.

There are many reasons that this book is so popular and long-lived. It’s resolutely an introductory text, but it treats topics that are uncommon in introductions, and does so to a depth that’s quite astonishing – although it has to be said that the authors avoid the more complex constructions like conditions and the complexities of macros, (They do deal with continuations, however, which are essential for good Scheme programming.)

But what other introduction to programming includes a complete meta-linguistic re-implementation of the language itself? – and in two different styles! It can do this because Scheme is so regular and so simple – homoiconic (one representation for programs and data), (although they don’t use that term).

https://learnxinyminutes.com/docs/common-lisp/

A one-web-page introduction to Common Lisp covering pretty much all the language in enough detail to at least start writing simple command-line programs (and understanding those of others). Includes macros and CLOS. Quite an achievement to make it all so readable.

Peter Seibel. Practical Common Lisp. Apress. ISBN 978-1-4302-0017-8. 2005.

The classic, very thorough and hands-on tutorial introduction that doesn’t skip the hard parts like the condition system and non-local blocks and exists (and the relationship between the two). It’s also got good chapters on CLOS.

The text is complemented by a set of modern examples, for web services, database, and binary file parsers: quite a long way removed from the examples in many introductory texts. It doesn’t make much use of macro programming in these examples, which is a shame, so follow with On Lisp or Let over Lambda once the structure of the language is clear.

Today I learned about feedle, a search engine focused on searching blogs and podcasts – web sites that export an RSS feed, in other words. And the search results are themselves RSS feed that can be subscribed to live.

This feels like a quite a big thing for accessing content without resort to the internet giants, and for the IndieWeb in general. It means that search can prefer syndicated and typically small-scale content rather than being influenced by search engine optimisation (SEO) or sponsorship affecting the link rankings.

Of course this also need management, and feedle is a curated source: you have to submit your RSS feed to it for review and (hopefully) inclusion. I’ve done that for this site’s feed.