







How a programming language can be an idea.
Learn C • Build Your Own Lisp
If you're looking to learn C, or you've ever wondered how to build your own programming language, this is the book for you.
The Coalton Programming Language
A statically typed, functional programming language that compiles to Common Lisp
The Next 7000 Programming Languages
Landin’s seminal paper “The next 700 programming languages” considered programming languages prior to 1966 and speculated on the next 700. Half-a-century on, we cast programming languages in a Darwinian ‘tree of life’ and explore languages, their features (genes) and language evolution from the viewpoint of ‘survival of the fittest’.

Bringing Clojure programming to Enterprise
How a dialect of LISP can help developping modern enterprise applications

Contents • Build Your Own Lisp
Why I Still Lisp (and You Should Too)
The old fashioned language might not be used by many. But it’s still a part of my codebases.

What Kind of Programming is Natural Language Programming?
In previous posts I’ve written about Natural Language Programming, Dijkstra’s Ghost – the End of The Symbolic Supremacy and Ephemeral Editable Specifications (aka Extract, Edit, A…

Gamedev in Lisp. Part 1: ECS and Metalinguistic Abstraction
In this series of tutorials, we will delve into creating simple 2D games in Common Lisp. The result of the first part will be a development environment setup and a basic simulation displaying a 2D sce...

Toolkits for the Mind
Programming languages shape the way their users think—which helps explain how tech startups work and why they are able to reinvent themselves.

Programming Language Design in the Era of LLMs: A Return to Mediocrity?
The most exciting part of Programming Languages (PL) research for me has always been in Programming Language Design.
(iterate think thoughts): Painting with Gaussians
Dmitri's blog about programming, Clojure, and software development
Executable Archaeology of Programs That Model Programming: Reanimating the Heuristic Compiler (1961) and KBEmacs (1984)
Early AI programs were often also theories of how people think, and programs that wrote programs were, in part, theories of how people program. Here we report on the reanimation of two such programs that offer two seemingly different theories of programming and were developed for quite different purposes. The first, Herbert Simon's Heuristic Compiler (1961), was an experimental model of programming as problem-solving, applying the means-ends analysis methods of the General Problem Solver to investigate the nature of the programming task. The second, KBEmacs (1984), was a working prototype of an intelligent programming assistant developed by MIT's Programmer's Apprentice project, built on the view that expert programmers recognize and combine familiar patterns, or "cliches." It let a programmer build up programs by combining cliches through a stylized English command language. We approach both through the methodology of Executable Archaeology, the study of historical computational systems by running their original code, a process we call "reanimation." Our reanimation of the Heuristic Compiler reproduces the compiled code appearing in Simon's 1963 paper, and our reanimation of KBEmacs reproduces the SQRT sequence of its December 1984 self-test. Examined side by side, the two theories turn out to have much in common: the Heuristic Compiler also works by adapting existing routines, and Simon later argued that search alone requires a large body of programming knowledge. To highlight the reflexivity of this project, we deliberately used a modern AI-assisted programming tool, Anthropic's Claude Code (Opus 5.5), to carry out much of the detailed reanimation work, building on a significant base of existing software. The explicit, executable theories of programming that both systems embodied are largely absent from today's far more capable AI coding assistants.

ELS 2026, Kraków - European Lisp Symposium
Homepage for the European Lisp Symposium
Andrew Blinn
I use programming language theory as a lens on UI design, trying to make engagement with abstractions more fluid, tangible, and fun
