I wrote a paper

My paper with Tomas Petricek was accepted at HATRA. I hope this collaboration with Tomas marks the end of my epic researcher’s block!

HATRA is a workshop encouraging early stage work and hence not even publishing proceedings. Yet the reviews were some of the most attentive and helpful I’ve ever gotten. There was plenty of criticism, but they all earnestly engaged with the ideas in the paper. My compliments to the organizers and the Program Committee.

With this paper I am finally confronting the deep dark specter at the heart of my vision: structure editing. Perhaps the reason my earlier work has failed to spark is because I’ve been avoiding this fundamental problem. Up till now I’ve been using embedded unique IDs to preserve identity, much as CRDTs do. Such IDs are the secret sauce of much work on Live Programming. But I kept hitting blocking problems with IDs, for example when moving and copying. I have had to restart from scratch and adapt ideas from OT instead. The key result in this paper is how to generalize OT to do version control for structured editing. In fact maybe that should be the title. Here’s the submitted title and abstract (we’ll post the full paper once we finish revising it):

Typed Image-based Programming with Structure Editing

Many beloved programming systems are image-based: self-contained worlds that persist both code and data in a single file. Examples include Smalltalk, LISP, HyperCard, Flash, and spreadsheets. Image-based programming avoids much of the complexity of modern programming technology stacks and encourages more casual and exploratory programming. However conventional file-based programming has better support for collaboration and deployment. These problems have been blamed for the limited commercial success of Smalltalk. We propose to enable collaboration in image-based programming via types and structure editing.

We focus on the problem of schema change on persistent data. We turn to static types, which paradoxically require more schema change but also provide a mechanism to express and execute those changes. To determine those changes we turn to structure editing, so that we can capture changes in type definitions with sufficient fidelity to automatically adapt the data to suit. We conjecture that typical schema changes can be handled through structure editing of static types.

That positions us to tackle collaboration with what could be called version control for structure editing. We present a theory realizing this idea, which is our main technical contribution. While we focus here on editing types, if we can extend the approach to cover the entire programming experience then it would offer a new way to collaborate in image-based programming.

2 Replies to “I wrote a paper”

  1. Congratulations! Looking forward to seeing your presentation.
    And very glad to learn Tomas Petricek is collaborating with you:
    I got to see him (not virtually) at Lambda Days last year 🙂

  2. I did a lot of work syncing schema changes (across the data and all associated access code) in large relational databases in the late 90’s. I wasn’t constrained to either operational- or state- based transformations, so I created an interpreted language that allowed me to script for each change the optimal transformation technique from the entire available set, the last of which was brute force (dump-reformat-reload). This allowed me to both solve all the thorny cases but also optimize performance. Even restructuring multi-field keys was straightforward and readable.

    I’ll be interested to see what a rigorous solution looks like.

Comments are closed.