Expressions of Change is a research project that aims to radically improve the tools for constructing ever-changing computer programs by putting the changes themselves central in the programming experience.

A video demonstrating the current state of the project is available below.

Project motivation

The motivation for this project can be found in two observations:

  1. Computer programs will be changed — and managing those changes themselves forms a large part of a computer programmer’s work.
  2. Existing tools are afterthoughts — the creation of Version Management Systems postdates the programming languages whose programs’ versions they manage.

The fact that most computer programs are destined to evolve has been well known since at least 1974. This has only become more obvious since then, so much that currently popular paradigms such as Agile Development even put it at the core of their philosophy.

The basic building block of programming, however, does not acknowledge this ever-changing nature: to the compiler a program appears as one or more historyless text files.

Because of the central importance of software evolution, a myriad of tools has sprung up to manage it. However, these tools invariably take historyless files as a given and proceed to add history on top of it. In short: dealing with change is an afterthought.

Design goals

The design goals of this project follow directly from the problem definition above. By not accepting history-less files as a basic building block we get:

  • Change to the program itself should be a primitive.
  • Combining arbitrarily sized parts of programs across time should be possible.

Arbitrarily combining parts of programs across time is a radical new idea. Here are just a few examples of what becomes possible in that paradigm:

  • Refactoring a function definition while postponing to update some of the calling locations.
  • Real-time large team cooperation on a single codebase — modules that are currently being edited by others can be referenced or ignored at will.
  • Reproducing bugs by simply replaying them — any version of the program is referencable and executable; combined with a reference to the data reproducing bugs becomes trivial.
  • Using multiple different versions of the same external or internal library across a single program.
  • Running 2 or more versions of the program simultaneously, switching out one of them gradually.

And much more…

Implementation direction

The main goal of the project is to demonstrate a prototype that is an implementation of the design goals mentioned above — i.e. some sort of Programming Language.

Because the project rejects the history-less file as a basic building block, the first step towards this is to build an editor that constructs the primitives of change instead.

For practical reasons (the scope of the project is large enough as it stands), the first editor will only supports constructions a minimal syntax: S-Expressions.

Whether a more advanced syntax is required, e.g. to be able to express type information properly, is an open question.


This is an ongoing project. Progress will be documented on this site in two forms:

  1. Articles describing the progress of the project and its philosophical underpinnings.
  2. Demo (research) implementations. The first such demo is of an editor.

In the fall of 2017 I have switched my attention to incremental static analysis of changing computer programs.