Project Context & Status

Expressions of Change is a sabbatical research project by Klaas van Schelven.

The aim of the project is to improve the tools for constructing ever-changing computer programs by putting the changes themselves central in the programming experience. This is an ongoing project. Progress is documented on this site in two forms:

  1. Articles describing the progress of the project and its philosophical underpinnings. For example: a paper was recently accepted to the European Lisp Symposium
  2. Demo (research) implementations. The first such demo is of an editor.

Source code exists, but is not optimized for consumption by the general public. Contact me for access.

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.

More thoughts on the motivation are collected in a separate section.

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.

Similar projects

Projects that have some degree of similarity with Expressions of Change:

  • At Utrecht University, Wouter Swierstra and Victor Cacciari Miraldo are researching Type-Directed Diffing of Structured Data.
  • Hazel is a a programming environment rooted in type theory.
  • Project Lamdu aims to create a next-generation live programming environment that radically improves the programming experience.
  • Unison is a next-generation programming platform, currently in development.