Given the fact that it’s been a bit quiet on this website for the past few months, I figured it was time for a short status update.

In this project I experiment with better tooling for constructing ever-changing computer programs. The project is split into 2 major related parts: an editor in which changes take a central role, and the interpretation of artifacts as produced by the editor as computer programs.

I have decided to let the editor be for now, and have recently switched my attention to working on a small Lisp interpreter. This takes as its input a mechanism of construction of an S-Expression, rather than just the constructed end-product.

As some key parts of the modelling I have identified:

• A small set of Lisp forms
• A vocabulary of change on these forms (A “Clef”).
• A mapping of changes to S-Expressions to changes to Lisp forms.

The above is (roughly) implemented.

The current step is to make sure the Lisp forms lead to an actually functioning interpreter. Doing so as a prototype should, hopefully, be fairly simple.

An important goal in the implementation of this interpreter is to stay faithful to the notion of expressions of change. In particular: rather than interpret fully constructed programs, the focus is in interpreting the meaning of changes to existing programs.

A related goal is to express certain kinds of program analysis in terms of analyses to changes to programs. (“incremental analysis”)

Some candidates for such analyses are:

• Analysing variable usage & binding incrementally. By doing so we improve the programmer experience from “this variable is undefined” to “this variable became undefined at such and such edit operation” and similarly for “this variable is unused” and “this variable shadows another variable”.

• Static type-analyses may similarly be formulated incremtally.

Stay tuned for further updates.