Change Impact Analysis And Its Applications For Aspect-Oriented Programs

Change impact analysis is a useful technique for software evolution. It determines the effects of a source editing session and provides valuable feedbacks to the programmers for making correct decisions. Recently, many techniques have been proposed to support change impact analysis of procedural or object-oriented software, but seldom effort has been made for aspect-oriented software. In this paper, we propose a new change impact analysis technique for AspectJ programs. At the core of our approach is the atomic change representation which can precisely capture semantic differences between two versions of an AspectJ program. We also present a change impact analysis model, based on static AsepctJ call graph construction, to determine the impacted program parts, affected tests and their responsible affecting changes.Based on the proposed change impact analysis model, we discuss the following three typical applications in software engineering tasks:1. Automated debugging. We present a new approach for Java/AspectJ programs that integrates the potential of delta debugging algorithm with the benefit of change impact analysis to narrow down the search for faulty changes. Our approach first uses change impact analysis to identify a subset of responsible changes for a failed test, then ranks these changes according to our proposed heuristic (indicating the likelihood that they may have contributed to the failure), and finally employs delta debugging algorithm to determine a minimal set of failure-inducing changes. In particular, we apply the original delta debugging algorithm to multiple levels of program changes, working from the coarse method-level to the fine statement-level changes. Most of the generated configurations are syntactically valid, reducing the number of inconsistent configurations that need to be tested.2. Incremental reanalysis of call graph. We present an algorithm for incremental update, instead of exhaustive analysis of the initially constructed call graph in AspectJ software. Our approach first decomposes the source code editing between the updated and initial software versions into a set of atomic changes, which capture the semantic differences precisely. Then, we explore the relationship between software changes and call graph representation to incrementally update the initially constructed call graph, instead of rebuilding it from the ground up.3. Change metrics for AspectJ software evolution. Most of the current research on software metrics intends to measure the program complexity. Seldom effort has been made on evaluating the change impacts. We present a suite of change metrics for measuring change impacts in AspectJ software evolution. These metrics provide useful information for both software developer and maintainers.The proposed techniques have been implemented in Celadon, a change impact analysis framework for AspectJ programs. We also integrate automated debugging support, call graph incremental reanalysis technique, and change metrics evaluation tool into Celadon. To evaluate the effectiveness and efficiency of our proposed techniques, we performed an experimental evaluation on 24 versions of 8 AspectJ benchmarks. The results show that our proposed technique can effectively perform change impact analysis, reduce the automated debugging and call graph analysis overhead significantly, and the changemetrics also provide valuable information for software developers.