My research is about
The basic idea is to identify the
In effect the language runtime provides external agents with the ability to explore nearby variants of the program without re-executing the whole thing from scratch. Programs no longer run once and then disappear, but hang around so that they can be interacted with.
A central benefit is that the synchronisation of state in response to interaction is an automatic feature, rather than something which has to be explicitly coded. This makes programming easier, and removes the layer of imperative I/O otherwise needed to make functional programs interact. Instead, any change in the value of a program constant counts as an input, and any change in a computed value as an output. This is nicely illustrated by a feature called "dynamic interactivity" which appeared in version 6 of Mathematica.
Interactive languages are "spreadsheets all the way down". This contrasts with a traditional spreadsheet, where the execution of a formula has no observable internal structure. The persistence of the structure has two important consequences. First, there is the potential to reuse parts of it when computing the new state. In fact, this is essential to an efficient implementation. This connects my research to the incremental computation literature, in particular the self-adjusting computation of Acar et al.
The second consequence of persistence is that the full history of a computation is available for debugging: one can simply inspect the structure to see why the computation produced the value it did. This idea has been explored by Jonathan Edwards in the experimental interactive language Subtext.