Research Projects

This page lists my main ongoing research projects.

Program Metamorphosis

Refactoring is a great techinque for changing program structure without altering program behaviour.
Existing refactoring tools take the `one-step refactoring' approach, which means that programmers tell the tool what to do and the tool does
what the programmer asked them to do-- plus any extra steps for making sure that all relevant program behaviour is preserved.
However, this traditional approach is not quite as flexible as we might like:

Some complex refactorings aren't supported by existing tools but can't be broken down into smaller refactoring transformations.

Each refactoring tool has its own idea of what the `relevant program behaviour' is, and that idea may or may not match what the programmer had in mind.

Whenever a refactoring changes the program, it may use heuristics to preserve behaviour-- and those heuristics may not match the programmer's intentions.

Program metamorphosis (as defined in my Dissertation) is an alternative approach to refactoring that
subsumes and extends on the traditional approach to refactoring. With program metamorphosis, users apply fine-grained transformations
that need not individually preserve behaviour. Meanwhile, the program metamorphosis tool checks to make sure that the current program
behaviour matches the behaviour of the original program, and guides the user towards possible solutions that restore behaviour.
Program metamorphosis not only offers behaviour-preservation guarantees on par with existing tools, but also solves the three problems above:

These small steps can be composed flexibly to enable refactorings that are impossible with traditional tools (such as Tease Apart Inheritance.

If the user doesn't want to preserve a particular piece of behaviour, they can tell the tool to change the target behaviour.

Since any heuristics are optional, the programmer stays in control of the transformation process at all times.

Try our Java prototype, available at the project homepage! Another prototype for SML
will be avilable soon.

This is joint work with Amer Diwan, Devin Coughlin, and Evan Chang.

Declarative Queries for Imperative Languages

Imperative programming may be popular, but it is also notoriously hard. The goal of this project is to ease the task of writing
imperative code by extending the underlying language (Java, at this time) with high-level declarative query constructs.
Our first such extension, DeAL, adds fast and expressive heap assertions to Java.

We are now exploring exploring more general forms of declarative queries with the goal of easy parallelisation. More information as it
arrives!