Using Type Constraints for Refactoring
In this research, type constraints are used to support various semantics-preserving transformations of object-oriented programs. A set of type constraints is derived from a program's abstract syntax tree. The original program provides one solution to this constraint system, but other solutions may exist that correspond to transformed/refactored versions of the program. The OOPSLA'03 paper shows how the preconditions and source code modifications associated with several common refactorings related to generalization can be inferred from the constraint system. In the ECOOP'05 paper, we extend the system of type constraints to infer type parameters for references to generic library classes. Our OOPSLA'05 paper uses type constraints to determine references of deprecated library classes that can be migrated to their replacements. Several refactorings in the Eclipse distribution are based on this research.My ACM TOPLAS 2000 paper with Gregor Snelting uses a combination of type constraints and concept analysis to find opportunities for refactoring of class hierarchies by splitting and merging classes, and by moving methods and fields to a more suitable place in the class hierarchy. This work was further developed in the context of the KABA system developed at the University of Passau.
Change Impact Analysis
The goal of this research is to help programmers understand the effects of changes they make, and to provide debugging support when changes unexpectedly lead to test failures. The PASTE'01 paper presents a conceptual framework in which edits are deconstructed into a model of atomic changes with interdependences. A call graph is computed for each test associated with the system in the original version of the system, and affected tests are identified by correlating these call graphs with the change representation. The affecting changes for a given affected test are computed by correlating the change representation with the call graph for that test in the edited version of the system. Our OOPSLA'04 paper presents the implementation of this work in the context of a practical tool called Chianti, and reports on a number of experiments with the tool. In a new technical report, changes are correlated with tests results and classified as RED, YELLOW, or GREEN, depending on the likelihood that they are the cause of a test failure.This is joint research with Barbara Ryder, and is funded by NSF grant CCR-0204410.
Whole-Program Analysis and Optimization
The goal of the Jax project was to reduce the size of Java programs so that they could be transmitted faster over the internet. Techniques employed to reduce application size include the removal of dead methods and fields, name compression, compaction of the class hierarchy, and inlining. The ACM TOPLAS paper presents an overview of the Jax work, and a more popular account was published in CACM. Several techniques developed in the context of the Jax project have been incorporated into WebSphere Studio Device Developer. The construction of precise call graphs is a key step in application extraction, and Jens Palsberg and I developed several scalable algorithms, which were presented at OOPSLA 2000. More recently, I collaborated with Bjorn De Sutter on a whole-program optimization technique that relies on the creation of custom Java library classes using type constraints and profile information, which was published at ECOOP'04.Other Research Interests
I have also done research on program slicing, and on the generation of tools from algebraic specifications, but it has been a while since I worked on these topics.