Metamodel for Tracing Concerns across the Life Cycle

Several aspect-oriented approaches have been proposed to specify aspects at different phases in the software life cycle. Aspects can appear within a phase, be refined or mapped to other aspects in later phases, or even disappear.\ud Tracing aspects is necessary to support understandability and maintainability of software systems. Although several approaches have been introduced to address traceability of aspects, two important limitations can be observed. First, tracing is not yet tackled for the entire life cycle. Second, the traceability model that is applied usually refers to elements of specific aspect languages, thereby limiting the reusability of the adopted traceability model.We propose the concern traceability metamodel (CTM) that enables traceability of concerns throughout the life cycle, and which is independent from the aspect languages that are used. CTM can be enhanced to provide additional properties for tracing, and be instantiated to define\ud customized traceability models with respect to the required aspect languages. We have implemented CTM in the tool M-Trace, that uses XML-based representations of the models and XQuery queries to represent tracing information. CTM and M-Trace are illustrated for a Concurrent Versioning System to trace aspects from the requirements level to architecture design level and the implementation

a(MDÆ)2: A Model Driven Approach to Multi-Dimensional Separation of Concerns with OCL

AbstractA typical activity in the object-oriented software engineering process involves the construction of a class structure in terms of which the system behaviour is to be specified. The behaviour, however, commonly consists of multiple tasks, each of which usually needs only part of the information available in that class structure. Additionally, a different representation of the required information may be appropriate. Therefore, it would be useful to be able to have multiple views on the global class structure, each being suitable for the specification of the behaviour related to a certain task. This paper introduces a(MDÆ)2, a technique to realise such a strategy. It incorporates OCL as a powerful query language and advocates a model driven development process which relieves the developer from the burden of manually writing a considerable amount of tedious and error-prone code

Facilitating Configurability by Separation of Concerns in the Source Code

Producing configurations of a software product, e.g. designed for different operating systems, using different database technologies or serving different groups of users is undoubtedly a time-consuming and error-prone process. In this paper we propose an approach facilitating the configurability of software using separation of concerns, which helps to eliminate unwanted parts of the source code whenever the corresponding requirements change without manual intervention and without the risk of corrupting the program. A prototype implementation provided with the approach demonstrates its powerfulness in the practice

An experimental study of the effectiveness of Panorama as a maintenance tool

It is a well known fact that the amount of time and money spent debugging and maintaining software far outstrips the amount spent developing it. Reports suggest that a majority of this effort is related to information-seeking, concept-location, and software comprehension. In addition to being inherently complex activities, these problems are exacerbated due to the fact that the original developers are often unavailable to help with the maintenance activities. To perform a maintenance task programmers first form dynamic and static mental models of the program based on their prior knowledge of programming and on information available about the program. Aside from high level design documents, Javadoc-like documentation has been the primary means of obtaining such information about programs. There are two severe shortcomings of this form of documentation: a) as recognized by proponents of AOP, the code for many of the concerns of interest to the maintainer are scattered across different classes and files and b) there are a lot of classes and files for large systems leading to information overload and it is very hard and time-consuming to identify the few segments of code and documentation that are relevant for a specific maintenance activity. To address these problems, we have developed an Eclipse plug-in, Panorama, which allow master developers to document sections of code related to a specific developer concern and provides ways to make such information readily available to maintainers. This tool helps directly with information-seeking, concept location, and software comprehension activities and focuses maintainer\u27s attention on the specific code and guidance necessary for a particular task. To validate the tool and our approach, we conducted an experimental study with 19 subjects assigning them several maintenance tasks on a fairly complex application (a multi-user Poker game). The study showed that the experimental group who had access to Panorama was able to complete more maintenance tasks in less time than the control group who did not have access to the tool. In addition, preliminary results indicate that the tool will have more impact on productivity of persons new to the application and programming environment than on experts

Identifying Crosscutting Concerns Using Fan-in Analysis

Aspect mining is a reverse engineering process that aims at finding crosscutting concerns in existing systems. This paper proposes an aspect mining approach based on determining methods that are called from many different places, and hence have a high fan-in, which can be seen as a symptom of crosscutting functionality. The approach is semi-automatic, and consists of three steps: metric calculation, method filtering, and call site analysis. Carrying out these steps is an interactive process supported by an Eclipse plug-in called FINT. Fan-in analysis has been applied to three open source Java systems, totaling around 200,000 lines of code. The most interesting concerns identified are discussed in detail, which includes several concerns not previously discussed in the aspect-oriented literature. The results show that a significant number of crosscutting concerns can be recognized using fan-in analysis, and each of the three steps can be supported by tools.Comment: 34+4 pages; Extended version [Marin et al. 2004a

Tool-supported identification of functional concerns in object-oriented code

Concern identification aims to find the implementation of a functional concern in existing source code. In this work, concerns are described, using the Hierarchic Concern Model, as gray-boxes containing subconcerns, inputs, and outputs. The inputs and outputs are used as concern seeds to identify data-oriented abstractions of concern implementations, called concern skeletons. The identification approach is based on context free language reachability and supported by a tool, called CoDEx

Using diagrammatic explorations to understand code

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2008.Includes bibliographical references (p. 139-145).Understanding code is a significant challenge for developers. This thesis examines the limitations of current tools that use diagrams to assist code comprehension and demonstrates the value of four design principles: * That diagrams should be based on familiar models such as UML class diagrams and layered architectural diagrams, so that developers can understand them without additional training. * That the familiar diagrams must be able to focus on specific parts of a codebase relevant to the developer's task, to prevent users from getting overwhelmed with irrelevant information. * That the focused diagrams need to support exploration of the codebase by directly interacting with the existing diagram. * That the focused diagrams can be created by users' exploration as needed for their tasks in traditional code editors. This thesis shows that understanding for software developers can be effectively supported by interactive exploration using focused diagrams of familiar representations of code. These ideas have been combined to build two tools: Strata, which displays using the popular layered architectural diagrams, and Relo, which is based on UML class diagrams. The tools have been evaluated using both controlled lab studies and field deployments. Study results have been positive, indicating merit in these ideas.by Vineet Sinha.Ph.D