Refactoring(with Dirk Baeumer, Ittai Balaban, Julian Dolby, Michael Ernst, Robert Fuhrer, Markus Keller, Adam Kiezun, Max Schaefer, Manu Sridharan, and Emina Torlak)
We have explored the use of type constraints to support various semantics-preserving transformations of object-oriented programs. In this work, 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. An 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 an 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. More recently, we started exploring refactoring of concurrent programs. An FSE'09 paper presents a refactoring for making single-threaded Java programs reentrant, and an ECOOP'10 paper explores what needs to be done to make existing refactorings behave correctly in the presence of concurrency.
Test Generation and Fault Localization for Web Applications(with Shay Artzi, Danny Dig, Julian Dolby, Michael Ernst, Adam Kiezun, and Marco Pistoia)
In this line of work, we adapted an existing dynamic test generation technique that combines concrete and symbolic execution to the domain of web applications written in PHP. Our ISSTA'08 paper presents the technique and its implementation in a tool called Apollo, and reports on dozens of bug that we found in real PHP applications. Our ICSE'10 paper is concerned with the adaptation of existing fault localization techniques such as Tarantula and Ochiai to predict in which statements the fault is likely to be located, and reports that, using our best technique, 87.7% of real faults that we found in some PHP applications are localized to within 1% of all executed statements. An ISSTA'10 paper addresses the problem of how to generate small test suites with maximal fault-localization effectiveness.
Data-Centric Synchronization and Declarative Object Identity(with Julian Dolby, Stephen Fink, Christian Hammer, Mandana Vaziri, and Jan Vitek)
This is a collection of activities that aim at raising the level of abstraction in OO programming languages. It includes the design of data-centric approaches to synchronization, in which programmers specify the locations among which some consistency property exists, from which the compiler can infer where to add locks or other synchronization constructs. A POPL'06 paper presents an approach based on whole-program analysis, and an ECOOP'10 paper a type-based approach that enables separate compilation. A related tool for finding atomic-set-serializability violations was presented at ICSE'08. An ECOOP'07 paper presents a declarative approach to specifying object identity, in which programmers specify those fields in classes that contribute to object identity using a new "key" modifier, with an evaluation that shows that the mechanism is sufficiently general to handle real-world code. A related FSE'07 paper presents a tool for finding violations in equals()/hashCode() contracts.
Change Impact Analysis(with Ophelia Chesley, Xiaoxia Ren, Barbara Ryder, Fenil Shah, Max Stoerzer, Jan Wloka)
In this line of work, we explore how the use of a model of atomic changes with interdependences can be used for a variety of applications. An initial conceptual description of the approach was presented in a PASTE'01 paper. Our OOPSLA'04 and FSE'06 papers were concerned with tools for identifying a subset of a programmer's changes that contribute to a given test's failure. In an ICSE'09 paper, use a variant on the same change model to determine changes that can be committed safely to a version control repository without breaking other developers' tests.