Dynamic Slice of Aspect Oriented Program A Comparative Study

Aspect Oriented Programming (AOP) is a budding latest technology for separating crosscutting concerns . It is very difficult to achieve cross cutting concerns in object - oriented programming (OOP). AOP is generally suitable for the area where code scattering and code tangling arises. Due to the specific features of AOP language such as joinpoint, point - cut, advice and introduction, it is difficult to apply existing slicing algorithms of procedural or object - oriented programming directly to AOP. This paper addresses different types of program slicing approaches for AOP by considering a very simple example. Also this paper addresses a new approach to calculate the dynamic slice of AOP. The complexity of this algorithm is better as compared to some existing algorithms

Debugging Support for Aspect-Oriented Program Based on Program Slicing and Call Graph

Aspect-Oriented Programming (AOP) introduces a new software module unit named aspect to encapsulate crosscutting concerns. While AOP modularizes crosscutting concerns to improve maintainability and reusability, AOP introduces a new factor of complexity. It is difficult to find defects caused by an aspect modifying or preventing the behavior of other objects and aspects. In this paper, we examine a method to support a debugging task in aspect-oriented software development. We propose an application of a call graph generation and program slicing to assist in debugging. A call graph visualizes control dependence relations between objects and aspects and supports the detection of an infinite loop. On the other hand, program slicing shows the user changes of dependence relations caused by aspects. We implement a program-slicing tool for AspectJ and apply it to certain programs. The experiment illustrates how our approach effectively helps developers understand the influence of aspects in a program. 1

Impact-Analyse für AspectJ - Eine kritische Analyse mit werkzeuggestütztem Ansatz

Aspect-Oriented Programming (AOP) has been promoted as a solution for modularization problems known as the tyranny of the dominant decomposition in literature. However, when analyzing AOP languages it can be doubted that uncontrolled AOP is indeed a silver bullet. The contributions of the work presented in this thesis are twofold. First, we critically analyze AOP language constructs and their effects on program semantics to sensitize programmers and researchers to resulting problems. We further demonstrate that AOP—as available in AspectJ and similar languages—can easily result in less understandable, less evolvable, and thus error prone code—quite opposite to its claims. Second, we examine how tools relying on both static and dynamic program analysis can help to detect problematical usage of aspect-oriented constructs. We propose to use change impact analysis techniques to both automatically determine the impact of aspects and to deal with AOP system evolution. We further introduce an analysis technique to detect potential semantical issues related to undefined advice precedence. The thesis concludes with an overview of available open source AspectJ systems and an assessment of aspect-oriented programming considering both fundamentals of software engineering and the contents of this thesis