Change impact analysis for AspectJ programs

2007

In aspect-oriented programming, pointcuts are formulated as conditions over the context of dynamic events in the execution of a program. Hybrid pointcut languages also allow this context to come from interactions between the pointcut language and the base program. While some pointcut languages only allow conditions on the current execution event, more recent proposals have demonstrated the need for expressing conditions over a history of join points. Such pointcut languages require means to balance the expressiveness of the language with the additional memory and runtime overhead caused by keeping a history of join point context data. In this paper, we introduce a logic-based pointcut language that allows interaction with the base program as well as pointcuts over a history of join points. We introduce forward chaining as an implementation model for this language, and discuss possible optimization strategies for the additional overhead. 1 1 ACM, 2007. This is a minor revision of the work published in

Software Evolution, 2008

This chapter identifies evolution-related issues and challenges in aspectoriented programming. It can serve as a guideline for adopters of aspect technology to get a better idea of the evolution issues they may confront sooner or later, of the risks involved, and of the state-of-the-art in the techniques currently available to help them in addressing these issues. We focus in particular on the programming level, although some of the issues and challenges addressed may apply to earlier software development life-cycle phases as well. The discussed issues range from the exploration of crosscutting concerns in legacy code, via the migration of this code to an aspect-oriented solution, to the maintenance and evolution of the final aspectoriented program over time. We discuss state-of-the-art techniques which address the issues of aspect exploration, extraction and evolution, and point out several issues for which no adequate solutions exist yet. We conclude that, even though some promising techniques are currently being investigated, due to the relative immaturity of the research domain many of the techniques are not out of the lab as yet.

Proceedings of the 19th Annual Acm Sigplan Conference, 2004

This paper reports on the design and implementation of Chianti, a change impact analysis tool for Java that is implemented in the context of the Eclipse environment. Chianti analyzes two versions of an application and decomposes their difference into a set of atomic changes. Change impact is then reported in terms of affected (regression or unit) tests whose execution behavior may have been modified by the applied changes. For each affected test, Chianti also determines a set of affecting changes that were responsible for the test's modified behavior. This latter step of isolating the changes that induce the failure of one specific test from those changes that only affect other tests can be used as a debugging technique in situations where a test fails unexpectedly after a long editing session. We evaluated Chianti on a year (2002) of CVS data from M. Ernst's Daikon system, and found that, on average, 52% of Daikon's unit tests are affected. Furthermore, each affected unit test, on average, is affected by only 3.95% of the atomic changes. These findings suggest that our change impact analysis is a promising technique for assisting developers with program understanding and debugging.

ACM SIGSOFT Software Engineering Notes, 2004

We present a new classification system for aspect-oriented programs. This system characterizes the interactions between aspects and methods and identifies classes of interactions that enable modular reasoning about the crosscut program. We argue that this system can help developers structure their understanding of aspect-oriented programs and promotes their ability to reason productively about the consequences of crosscutting a program with a given aspect.

2003

For each affected test, Chianti also determines a set of affecting changes that were responsible for the test's modified behavior. We evaluated Chianti on 6 months of data from M. Ernst's Daikon system, and found that, on average, 62.4% of the tests is affected. Furthermore, each affected test, on average, is affected by only 5.6% of the atomic changes. These findings suggest that change impact analysis is a promising technique for assisting developers with program understanding and debugging.

International Journal of Information Technology and Computer Science, 2015

Object-oriented (OO) software have complex dependencies and different change types which frequently affect their maintenance in terms of ripple-effects identification or may likely introduce some faults which are hard to detect. As change is both important and risky, change impact analysis (CIA) is a technique used to preserve the quality of the software system. Several CIA techniques exist but they provide little or no clear information on OO software system representation for effective change impact prediction. Additionally, OO classes are not faults or failures-free and their fault-proneness is not considered during CIA. There is no known CIA approach that incorporates both change impact and fault prediction. Consequently, making changes to software components while neglecting their dependencies and fault-proneness may have some unexpected effects on their quality or may increase their failure risks. Therefore, this paper proposes a novel framework for OO software CIA that allows for impact and fault predictions. Moreover, an intermediate OO program representation that explicitly represents the software and allows its structural complexity to be quantified using complex networks is proposed. The objective is to enhance static CIA and facilitate program comprehension. To assess its effectiveness, a controlled experiment was conducted using students' project with respect to maintenance duration and correctness. The results obtained were promising, indicating its importance for impact analysis.

2001

Abstract We propose the application of aspectoriented programming to software configuration management. We believe it could improve the change control by providing a new basis for reasoning about a change. To demonstrate this, we designed an abstract-oriented extension to procedural languages where a change is represented by an aspect. Consequently, a change gains the properties of an aspect: it becomes well-localized and separated from the (unchanged) base program.

2012

Background In the last 30 years, software engineering researchers have proposed several definitions of CIA and developed many techniques for CIA. In the early 1980s, the work on impact analysis focused on the so-called ripple effect [10, 11]. The first definition of impact analysis was proposed by Horowitz et al. in 1986 as 'an examination of an impact to determine its parts or elements'[12]. In 1990, Pfleeger et al. presented a model of software maintenance, which took impact analysis as one of its key activities [13].

Maintenance of software systems is becoming major concern for software developers and users. In software projects/products, where software changes/updates are frequently required to improve software quality, maintainability is an important characteristic of ISO 9126 quality standard to evaluate. Analyzability, changeability, stability, and testability are sub attributes/characteristics of maintainability in ISO 9126. In this paper, changeability is measured by making changes at code level of an Aspect-Oriented (AO) system. The approach taken to evaluate the changeability of an AO system is to compute the impact of changes made to modules of the system. Some projects 1 in aspect-oriented programming (AOP) language, AspectJ, have been taken for testing. The results suggest that the AO system can easily absorb changes and AO design metrics can be used as indicators of changeability as well as of maintainability. The results also suggest that a code level change in AO systems not always cause less change impact to other modules than a code level change in Object-Oriented (OO) systems.