Update 20250727: The code for QWAK Lisp (“Qlosure With A K”) is finally public! So you can now actually go and download the stuff I’m writing about, and try it out, or maybe even use it! Code is currently further ahead than the files here, but I’m catching up.

This is the third time that I rewrite the lisp page of my website from scratch. The first version was pretty good and fleshed out, but I felt it failed to convey why exactly I find a language that’s half a century old by now so exciting. I tried to fix that in the second version, narrating some of the historical background and listing its progeny, yet that felt closer to an excited rant than a meaningful argument (also, I never finished it). So, I try again.

Lisp is a programming language. It was first conceived in 1959, and implemented quickly afterwards. It is thus considered the second high-level language after FORTRAN. It is often called a ‘metaprogramming language’, because while it does very little, most of what it does is to make it easily extensible to solve any problem. Thus, it pioneered a lot of concepts that are now fundamental to how we use computers, and spawned a lot of projects that ended up shaping how we use technology. Listing the properties of the language is difficult, because it predates most technical terms that are in use to describe languages - in fact, many of them emerged specifically to distinguish different implementations. Because of this difficulty, I will use ‘Lisp’ interchangably - I will use it to refer to some general concepts regarding data/state/program execution that were introduced by the aforementioned paper from ‘59 (and the so-called 'lambda papers’ that expanded on their implementation), and as a catch-all for programming languages that implement those features (or derive from them) - including the one that I will be implementing in later chapters of this.

In short, my fascination stems from the fact that the aforementioned ‘metaprogramming’ aspect makes the language incredibly simple, but is also easily extended by various other concepts from within the language itself, allowing for an easy and flexible exploration of the possibilities of computing.

Since there are a lot of general topics to talk about, this series (yeah, it’s a series now) will be split in five chapters (implemented as individual subpages). I’m still in the process of bringing them up to date (or, er, writing them in the first place), so most of them are as of yet missing.

• the introduction - you are here
• history of the language - with a long preface on the history of symbolic computation
• basics/fundamentals - aforementioned “general concepts”
• intro to functional programming (and various other paradigms) - how to use those basics to actually accomplish anything
• implementing an interpreter - ie a thing that can run that code, which is what started all this madness
• implementing a compiler - ie a thing that transforms our code into something that can run on hardware, requiring a much more in-depth analysis of what things are and how they work