Refactoring Using Type Constraints
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 how generic (library) classes can be instantiated in client code. Our OOPSLA'05 paper uses type constraints to determine references of deprecated library classes that can be migrated to their replacements. A paper presented at ICSE'07 presents a technique for introducing type parameters. An overview of our research on refactoring using type constraints was presented at SAS'07. Several refactorings in the Eclipse distribution are based on our 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.
Data-Centric Synchronization
In this project, we present atomic sets, a data-centric mechanism for specifying synchronization constraints in object-oriented languages. In a POPL 2006 paper, we presented an approach in which the programmer groups fields in classes into atomic sets, and a static whole-program analysis is performed to infer where locks need to be placed in order to ensure atomic-set serializability, a correctness criterion that guarantees the absence of data races and similar concurrency-related errors. We are currently working on a type-based approach for data-centric synchronization that avoids the need for whole-program analysis and permits separate compilation. Our ICSE 2008 paper presents a dynamic detector for atomic-set serializability violations, which we used to find data races and concurrency-related errors in Java applications.
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 paper presented at FSE 2006, 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. A paper presented at ICSE 2009 uses a variation on the same atomic change model to determine changes that can be committed safely to a version control repository in the presence of failing tests in a developer's local workspace.This is joint research with Barbara Ryder, and was funded by NSF grant CCR-0204410.
Other Research Interests
I have also done research on program slicing, whole-program analysis and optimization, and on the generation of tools from algebraic specifications, but it has been a while since I worked on these topics.