I am fascinated by how putting structure on information and computations makes it possible to build complex, effective systems. I am interested in understanding which structures best support the expression, evolution, and verification of software systems, and in helping software developers manage these structures. Not all of my research projects fall specifically within this specific theme because I am also interested in ways to improve the day-to-day evolution tasks that software developers must perform. In all of the research that I undertake, I strive to evaluate the research in realistic settings. Experiences in trying to evaluate tools and technologies have led me to an interest in empirical evaluation, and in particular, an interest in qualitative evaluation methods.
(Note this page needs updating)
Our bug triage project is looking at how to help automate the assignment of bugs and detection of duplicate bugs in open-source projects [with J. Anvik and L. Hiew].
Conceptual queries is considering how to automatically display and cluster local context about important parts of artifacts as a developer works [with B. de Alwis]
Mylar builds and makes visible a degree-of-interest model for elements in an IDE based on a developer's activity [with M. Kersten].
ActiveAspect is an approach to generating focused, interactive models that describe the effect of an aspect on a system [with W. Coelho].
Role-based Refactoring [with J. Hannemann] is building support to refactor object-oriented and aspect-oriented code to "better" aspect-oriented forms.
Hipikat [with D. Cubranic] is a recommender that suggests pertinent software artifacts to a developer making a change to the system.
Concern Graphs [with M. Robillard] support the location and description of concerns in source code during software evolution tasks.
AOP Empirical Study [with several others] is about understanding what methods to use to assess new technology, and about whether and how aspect-oriented techniques work.
AVID [in conjunction with OTI, Inc. as part of CSER] enables the visualization of the execution of an object-oriented (Java) system at the user-defined software architecture level.Conceptual Modules [with E. Baniassad and A. Lai] provides a means of overlaying a desired structure on an existing source structure to support reengineering, and more recently, the modeling of the behaviour of concerns.
Design Rational Graphs [with E. Baniassad] supports the linking of design goals, in the form of crosscutting aspects of design patterns, to source code.
Exception Structure [with M. Robillard] involves a source code analysis tool to analyze the flow of exceptions in Java programs, and a design approach to enable the development and reengineering of better exception structures.
Explicit Programming [with A. Bryant, A. Catton, and K. de Volder] advocates and supports the capture of design information in source through the introduction of developer-defined vocabulary.
Implicit Context [with R. Walker] helps reduce EEK in software components, easing reuse and evolution of those components. Rob is continuing work in this direction at the Univ. of Calgary.
Mining Version Information [with A. Ying] used data mining techniques to version information to try to recommend pertinent parts of a software system when making a change.
Predicting Memory Use [with E. Saenko] investigated a method for predicting, based on design information and sample usage information, the memory use of framework and library components prior to their use.
Open Implementations [with G. Kiczales and others] considered how a designer of a reusable module could expose not only its functionality, but also certain crucial aspects of its implementation.
Empirical Study of C Call Graph Extractors [with D. Notkin (U. Washington), W. Griswold (U.C. San Diego) and E. Lan (Microsoft)] demonstrated the differences in assumptions made in various implementations of a common software engineering tool and showed that these tools produce approximate results that are useful to software engineers.
When I was working in industry, I worked on the testing of object-oriented software and was a co-organizer of an OOPSLA '95 Workshop on Testing Smalltalk Applications.
Software Reflexion Models [with D. Notkin (U. Washington) and K. Sullivan (U. Virginia)] enable a software developer to summarize interactions in a large body of source code in terms of a selected, high-level, structural view of the system. The technique has been shown to scale for use with large systems: a developer at Microsoft applied the technique to aid an experimental reengineering of the Excel code base.
Lightweight Lexical Source Model Extraction [with D. Notkin (U. Washington)] involved the development of an approach to generate flexible and tolerant source model extractors from lexical specifications.
Last updated: May 18, 2009