I am working on Theseus, an approach to update server applications without restarting them (live updates), and Dynamic Ownership.

I can propose the following projects:

Linking class evolution and the characteristics of their instances at run-time

There have been many studies of the evolution of classes, but they did not consider the corresponding characteristics of the corresponding objects at run-time. For instance, do classes that evolve a lot have many or few instances at run-time? Do classes that evolve a lot correspond to thread-local or thread-shared objects? Etc. The goal of this project is to study the evolution of classes, taking into accound the characteristics of their corresponding instances at run-time.

To measure the characteristics of objects at run-time, we will need to devise a dedicated instrumentation technique. We will use either program transformation (rewritting), or the Maxine VM with virtual machine level analysis.

VM-support for incremental updates

In Theseus, live updates are incremental: different versions of code coexists at run-time isolated into contexts. Objects shared across contexts are mediated with bidirectional transformations to accomodate structural changes.

We have implemented several prototypes of this approach using program rewriting. The goal is to implement this approach at the VM-level for optimal performances.

Essentially, pointers must be changed to indicate whether the object is local or shared. The semantics of method invocations and field accesses will differ for local and shared objects.

Delegation Proxies

Proxy is a design pattern that has found many useful applications, e.g. to implementat persistency, asynchronous computation (Future), tracing and logging, etc. The goal of this project is to provide better support for proxies in the programming language.

A draft of the implementation is already available, but there are many open points, both conceptual & technical.

Ownership and Factory Methods

It is common that an object owns other objects. For instance, a list implemented internally with linked nodes, owns the nodes. The ownership relationship is usually not explicit in programming language, and it can by consequence be hard to enforce.

We have built a first version of an extension of Smalltalk with dynamic ownership, but we did not consider factory methods on the class-side. The goal of the project is to implement an improved version that handles factory methods.