Projects

Our research focuses on methods and tools to help software developers manage and evolve the structure of the software systems they are developing both at design time and in source code. In particular, we are working on approaches that help developers assess various design alternatives when performing a software engineering task. Since new methods and tools have little value unless useful to "real" software developers, we are also working on assessment methods to understand how to better validate our research results.

Design Aids and Approaches

Predicting Memory Use (Murphy, Cubranic, Saenko). Increasingly, new applications are being built by composing existing software components rather than by coding a system from scratch. Using this approach, applications can be built quickly. Far too often, however, these applications do not exhibit acceptable performance. The benefits of construction through composition could be more reliably achieved if a software engineer could assess the performance impact of a component prior to its use. We have done some initial investigations of a method to predict memory use for C++ components. We are currently working on prediciting memory use for Java components as part of CSER in cooperation with OTI, Inc. (Workshop Paper)

Interaction-based Programming (Lee). Interaction-based programming is an experimental approach aimed at improving the reusability of components by providing first-class language constructs---software interactions---to moderate communications between component interfaces. An interaction-based approach is being taken in the development of the RASP toolkit that supports the development of visual simualtions.

Source Code Analysis

Exception Flow Analysis in Java (Robillard, Murphy). Because of unchecked exceptions and of subsumption of exception types in method headers, it's difficult for programmers to reason about the flow of exceptions in Java programs. We have developed a static analysis to called Jex, to extract detailed exception flow information from Java programs. The main purpose of Jex is to help developers improve their error-handling code. (Paper)

Conceptual Modules (Baniassad, Murphy). We have developed a tool, called the conceptual module tool, to help software developers extract components from existing systems. This tool allows a developer to query source code in terms of components that do not conform to existing structures, such as procedures, in the code base. This tool may have applications in software architecture and design conformance checking. (Paper and Talk)

Visualization (Walker, Murphy, and a bunch of OTI folks). In cooperation with OTI Inc. and CSER, we are investigating techniques to visualize information about the execution of an object-oriented system. The intent of this work is to find effective techniques to help software developers perform various software engineering tasks, such as improving the performance of a system. (Paper and Talk)

Concern Graphs (Robillard, Murphy) A Concern Graph provides an abstract representation of a concern in a software system code. The representation abstracts the implementation details of a concern and makes explicit the relationships between different parts of a concern. From the representation, there is an obvious and inexpensive mapping back to the source code. The FEAT (Feature Exploration and Analysis) tool allows a developer to manipulate a concern representation extracted from a Java system, and to analyze the relationships of that concern to the code base. ( Paper: Concern Graphs - Finding and Describing Concerns using Structural Program Dependencies)

Assessment

Aspect-oriented Programming Assessment (Baniassad, Murphy, Walker) . Software design and implementation approaches and development support tools are valuable only if a developer can effectively use them to build and maintain software products. We are investigating case study and experimental methods by which software engineering researchers may evaluate claims made about new software engineering techniques and tools. Most of our work in this area has been in the context of early assessment of AOP. (Paper and Talk: Atlas - A Case Study in Buildling a Web-based Learning Environment using AOP, Paper: An Initial Assessment of AOP and Paper: Evaluating Emerging Software Development Technologies: Lessons Learned through Assessing AOP )