I’ve been reading a Lisp math paper by the creator of Lisp which describes Lisp in mathematical terms and then describes how Lisp can be used to produce a Lisp interpreter in very few lines of “code”/“math”

and first of all I definitely think that there’s something beautiful about a language that can be explained “simply” (very relatively speaking) in terms of itself, but that is also so powerful that it can be built up from those basic building blocks into a full-featured programming language

it is a very dense read, and I find it funny how the creator of Lisp himself is apologetic about the syntax of Lisp lol. at the time of writing this it seems like he was interested in finding a better syntax but was limited by the BCDIC character set of the IBM computers he worked on

I feel like the creator did his best to explain things clearly but definitely could have done better, and I noticed a few syntax errors in his handwritten Lisp code and/or math syntax which I find kinda funny. even the creator of Lisp gets his parenthesis mixed up. some of those threw me for a loop for a while and I’m still not 100% sure if certain things are mistakes or if I’m just misunderstanding something

but idk reading through this paper has definitely given me a deeper appreciation for Lisp as a mathematical model of computation, and as a language. I can definitely see the beauty of a language whose entire core feature-set can be explained in a 35-page math paper. and which could presumably be explained in a longer article that’s designed to be more accessible for laypeople and has the mistakes fixed

also, I really wonder how close something like Common Lisp or Scheme is to the conceptual simplicity of the Lisp presented in this paper. I feel like Common Lisp has had a lot of… things added to it over the years, and I wonder if these languages still boil down to basic operations like car and cdr, maybe some arithmetic operations, etc. or if the list of mathematical primitives that they boil down to has gotten large and messy. unfortunately “large and messy” is the impression that I get of most Lisps, except for maybe Fennel and Janet

I feel like my ideal Lisp would be:

• the simplest core language possible (this is not necessarily the implementation. what I mean is that the entire language can be modeled as just the features of this core language) (also by “simplest” I’m talking about conceptual simplicity and not necessarily simplicity to implement)
• everything else is defined in terms of the core language. for example (cadar X) is defined as (car (cdr (car x))). every single function that isn’t part of the core language has a section of the documentation that gives a definition like this. these functions can be implemented in a different way as long as they behave identically to the implementation given in the documentation
• build layers outwards, so that semi-core features are defined in terms of core features, and semi-semi-core features are defined in terms of {semi-core features and possibly also core features}, etc.
• eventually build things up to the point that the language has as much expressiveness as Python and a similarly full-featured standard library

but anyway yeah this paper has given me a much deeper appreciation for Lisp. not the Lisp implementations that exist today but the pure Lisp presented in the paper