Aspect oriented programs: Issues and perspective
hima bindu m2018, Journal of Electrical Systems and Information Technology
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
Aspect oriented programming (AOP) helps programmers for separating crosscutting concerns. All programming methodologies support split up and encapsulation of concerns. In object-oriented programming (OOP) crosscutting aspects are distributed among objects. It is hard to attain crosscutting in OOP as it is scattered in different objects. In AOP crosscutting concerns are addressed using one entity called aspect. This paper discusses varieties of existing slicing techniques of AOP. Also, we discuss a novel method to calculate dynamic slice of AOP. To represent AOP Aspect Oriented System Dependence Graph (AOSDG) is used. The complexity of this new approach is equal or improved as related to certain prevailing approaches.
Figures (8)
Related papers
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
Slicing of Aspect-Oriented Software and Its Application to Software Refactoring
2016
This thesis first presents some program slicing techniques for Aspect-Oriented Programs (AOPs) and then presents a technique for refactoring of software using the proposed slicing technique. Main aim of all the proposed slicing algorithms in this thesis is to compute accurate and precise dynamic slices of AOPs. In order to compute the slices of aspect-oriented programs, first we extend the System Dependence Graph (SDG) for Object-Oriented Programs (OOPs) to handle AOPs. We have named the extended SDG Extended Aspect-Oriented System Dependence Graph (EAOSDG). The EAOSDG successfully represents different aspect- oriented features such as class representation, method invocation, inheritance, aspect declaration, point-cuts, advices etc. The EAOSDG of an aspect-oriented program consists of System Dependence Graph (SDG) for the non-aspect code, a group of Aspect-Oriented Dependence Graphs (ADGs) for aspect code and some additional dependence edges that are used to connect the SDG of the n...
Program Slicing Techniques and their Need in Aspect Oriented Programming
International Journal of Computer Applications, 2013
Analysis of various studies has proved the importance of applying program slicing on the source code while debugging, testing, quality assurance, software measurement and maintenance by extracting out the code irrelevant to criteria on behalf of which program slicing is applied, without affecting the relevancy in the information of the code. Program slicing techniques has been upgraded by its different types emerged to overcome the limitation of its previous types with different types of dependence graphs, criteria and on different types of programming paradigm with different types of tools. Paper highlights the effectiveness of hybrid slicing over static and dynamic slicing using case study for applying different types of slicing on same program. Paper also discusses the Aspect Oriented Programming and the areas where it has been proved better than object oriented programming and upholds the need for applying hybrid slicing on Aspect Oriented Program.
A Novel Approach for Computing Dynamic Slices of Aspect-Oriented Programs
2014
We propose a dynamic slicing algorithm to compute the slices of aspect-oriented programs. We use a dependence based intermediate program representation called Aspect System Dependence Graph (AOSG) to represent aspect-oriented programs. Then, we propose the dynamic slicing algorithm for AOPs, which is an extended version of EMDS algorithm for object-oriented programs. Our algorithm is based on marking and unmarking of the edges of AOSG appropriately during runtime.
Dynamic Slicing of Aspect-Oriented Programs
Informatica (slovenia), 2008
Program slicing is a decomposition technique which has many applications in various software engineering activities such as program debugging, testing, maintenance etc. Aspect-oriented programming (AOP) is a new programming paradigm that enables modular implementation of cross-cutting concerns such as exception handling, security, synchronization, logging etc. The unique features of AOP such as join-point, advice, aspect, introduction etc. pose difficulties for slicing of AOPs. We propose a dynamic slicing algorithm for aspect-oriented programs. Our algorithm uses a dependence-based representation called Dynamic Aspect-Oriented Dependence Graph (DADG) as the intermediate program representation. The DADG is an arc-classified digraph which represents various dynamic dependences between the statements of the aspect-oriented program. We have used a trace file to store the execution history of the program. We have developed a tool called Dynamic Depenedence Slicing Tool (DDST) to implement our algorithm. We have tested our algorithm on many programs for 40-50 runs. The resulting dynamic slice is precise as we create a node in the DADG for each occurrence of the statement in the execution trace.
ParaAJ: toward reusable and maintainable aspect oriented programs
2009
Aspect Oriented Programming (AOP) aims to ease maintenance and promote reuse of software components by separating core concerns from crosscutting concerns: aspects of a program that cannot be conned to a single program component. In AOP languages such as AspectJ, this kind of concern is encapsulated in an aspect and connected to main classes using pointcuts. This removes extraneous code from the classes of the program, allowing them to focus on their core purpose and making them more maintainable and reusable. The implementation of each crosscutting concern, which would have been scattered throughout an object oriented program, is centralised in a single aspect. Unfortunately, due to the way aspects and classes are associated, and the lack of an explicit interface between them, these aspects may be tightly coupled to the classes of the program and so may not be as reusable or maintainable as might be expected. We propose ParaAJ (Parametric Aspects), as an extension to AspectJ. ParaAJ allows classes to specify which aspects should be applied, and allows applications to specify which aspects to apply to which classes in what ways. This makes it easier for classes and aspects to be developed and maintained independently, and encourages reuse of both.
Semantic Dependencies and Modularity of Aspect-Oriented Software
2007
Modularization of crosscutting concerns is the main benefit provided by Aspect-Oriented constructs. In order to rigorously assess the overall impact of this kind of modularization, we use Design Structure Matrixes (DSMs) to analyze different versions (OO and AO) of a system. This is supported by the concept of semantic dependencies between classes and aspects, leading to a more faithful notion of coupling for AO systems. We also show how design rules can make those dependencies explicit and, consequently, yield a more modular design.
An Approach for Computing Dynamic Slice of Concurrent Aspect-Oriented Programs
We propose a dynamic slicing algorithm to compute the slice of concurrent aspect-oriented programs. We use a dependence based intermediate program representation called Concurrent Aspect-oriented System Dependence Graph (CASDG) to represent a concurrent aspect-oriented program. The CASDG of an aspect-oriented program consists of a system dependence graph (SDG) for the non-aspect code, a group of dependence graphs for aspect code and some additional dependence edges used to connect the system dependence graph for the non-aspect code to dependence graph for aspect code. The proposed dynamic slicing algorithm is an extended version of NMDS algorithm for concurrent object-oriented programs, which is based on marking and unmarking of the executed nodes in CASDG appropriately during run-time.
Aspect-Oriented Programming with Aspectual Methods
2001
We use Gregor Kiczales' de nition of an aspect: a modular unit of crosscutting implementation and present a useful kind of aspect-oriented programming in Java. By focussing on a limited, but commonly occuring set of aspects, we are able to provide the Java library DJ that allows us to write aspectual methods whose ad-hoc implementation cuts across several classes. An aspectual method is evaluated in the context of a class graph and it invokes a traversal-style method that traverses through objects following has-a links guided by a traversal speci cation. We present the key elements of the library and we connect aspectual methods with the AspectJ terminology. Several examples demonstrate the advantages and limitations of aspectual methods.
Practical applications of the aspect-oriented programming
This paper describes the basic concepts of the aspect-oriented programming (AOP) and some of its practical use cases. It also explains different ways of implementation of AOP, particularly the way in which aspects are applied to given program (process called aspect-weaving). The paper also shows some technologies which take advantage of the AOP and compares them based on different characteristics, including: type of the technology, applications of the technology, AOP model which is used and its high level implementation. Technologies are chosen to cover large spectrum of applications. The use cases of AOP programming are supported by practical examples in which the usage of aspects leads to more modular and maintainable code.
Related papers
A REVIEW OF ASPECT ORIENTED PROGRAMMING FOR ENHANCED PROGRAM MODULARITY
IJCSMC, 2020
Software development process has evolved from the traditional software development paradigm with the attendant difficulties to a more intuitive approach. With the various improvement injected into the software program development landscape by the introduction of object oriented programming in terms of the modularization process, there abound a huge limitation due to the presence of cross-cutting concerns that have undermined the principle of abstraction with the attendant code scattering and tangling but with the inception of Aspect oriented programming and its complementary role to traditional OOP, there has been an improvement in the effective management of these concerns through the use of Aspect which focuses on specific cross-cutting functionality by unburdening its core classes, improving modularity and program efficiency. This paper reviews this two software development paradigm with a view to ascertain the common ground and visible difference amongst them and how AOP is changing the software development process.
Problems in Aspect Oriented Design
The classic challenge in writing object-oriented programs (OOP) is finding the right decomposition into classes and objects. This problem arises whenever programmers need to deal with crosscutting concerns. Aspect Oriented Programming (AOP) is a well known methodology to overcome this issue by modularizing crosscutting concerns using aspects. Programmers are slowly realizing the importance of AOP since it creates cleaner code. But AOP breaks encapsulation in joint points and modifies flow control, making the source code hard to understand.AOP is not very well tested and documented and there is a lack of specific development tools. That's why it is mainly used only for maintaining the system, rather than being a good choice for developing the initial version of the system. The main goal of this paper is to increase the acceptability of AOP by offering some tips against its drawbacks.
A Systematic Review on Performance Evaluation of Aspect-Oriented Programming Techniques used to Implement Crosscutting Concerns
Aspect-Oriented Programming (AOP) was proposed with the main objective of addressing an important software quality principle that is modularization. The basic idea of the paradigm is to capture crosscutting concerns as a programming abstraction called aspect. Since the introduction of aspects as a complement to objectoriented programming, many evaluations and empirical studies were provided to the new paradigm, including the application of a variety of software metrics in order to provide evidence of the benefits or problems with the new paradigm. There is no consensus about the impact on performance of the use of AOP techniques to deal with crosscutting concerns. The use of AOP to implement crosscutting concerns and its impact on performance is the motivation for this study. This paper explores further the evaluation of performance by proposing a systematic literature review with the purpose of finding out how performance is affected by the introduction of aspects. The result of this systematic review is that there has been few studies on scientific literature concerning AOP and performance and most of these studies are too specific, and sometimes even inconclusive. This article presents these miscellaneous results and how they were extracted from the literature.
Slicing aspect-oriented program using aspect- oriented dependence flow graph for software maintenance
2016
Program slicing is useful for debugging, testing, and maintaining software systems due to availability of information about the structure and relationship of the program modules. In general, program slicing can be performed either based on control flow graph (CFG) or dependence graph (DG). However, in the case of aspect-oriented programming (AOP), aspect-oriented control flow graph (AOCFG) or aspect-oriented dependence graph (AODG) individually is not enough to model the features of Aspectoriented (AO) programs. Thus, a suitable graph model for aspect-oriented program slicing is required to gather information on the structure of aspect-oriented programs. In this thesis, the concept of slicing aspect-oriented programs for maintenance purpose is proposed. In order to aid in slicing an aspect-oriented program, a graph model known as Aspect-Oriented Dependence Flow Graph (AODFG) is proposed to represent the structure of aspect-oriented programs. The graph is formed by merging AOCFG and ...
Aspect Programming with the Use of AspectJ
Developments in Information & Knowledge Management for Business Applications, 2020
Aspect programming with the use of AspectJ illustrates how the AOP techniques can be used to avoid the occurrence of application problems related to the information systems creation when using the Object-Oriented programming paradigm. Implementation of cross-cutting concerns using OOP forces programmers to repeat many times the same code instructions in the system. The approach provided by Aspect-Oriented programming allows maintaining the modular design of the application by extracting the cross-cutting concerns from it, its modularization in terms of aspects, and its reintegration into the applications main part in the weaving process or with the use of a proxy mechanism.
A classification system and analysis for aspect-oriented programs
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.
Aspect-Oriented Programming to Improve
Journal of Software, 2014
The separation of concerns design principle improves software reutilization, understandability, extensibility and maintainability. By using the objectoriented paradigm, it is not always possible to separate into independent modules the different concerns of an application. The result is that the source code of crosscutting concerns are tangled and scattered across the whole application. Aspect-oriented programming offers a higher level of modularity, providing a solution for the code tangling and scattering problem. To show how aspectoriented programming can be used as a suitable mechanism to improve the modularity of object-oriented applications, this divulgative article presents the implementation of a typical design pattern following both the object-and aspectoriented paradigms. The two approaches are compared from the modularity perspective, establishing a discussion on the benefits provided and is current use.
Second Workshop on Aspect-Oriented Software Development
2002
Syntax Trees 59 11 D. Vollmann Visibility of Join-Points in AOP and Implementation Languages 65 Part I Implementing and Reasoning about Aspects Reasoning About a Classification of Crosscutting Concerns in Object-Oriented Systems Constantinos A. Constantinides Department of ...
A Brief Survey on Aspect-Oriented Modeling Methodologies
2016
The methodology of Aspect oriented software development is the new technique to improve the modularity in the area of software development. It eliminates the limitation of traditional classical approaches. It gives more emphasis on the crosscutting concern with the help of Separation. Over the last few years, several techniques of crosscutting have been introduced. In this article several existing approaches aspect oriented development have been
Aspect-oriented programming
ECOOP'97Object- …, 1997
We have found many programming problems for which neither procedural nor object-oriented programming techniques are sufficient to clearly capture some of the important design decisions the program must implement. This forces the implementation of those design decisions to be scattered throughout the code, resulting in "tangled" code that is excessively difficult to develop and maintain. We present an analysis of why certain design decisions have been so difficult to clearly capture in actual code. We call the properties these decisions address aspects, and show that the reason they have been hard to capture is that they cross-cut the system's basic functionality. We present the basis for a new programming technique, called aspectoriented programming, that makes it possible to clearly express programs involving such aspects, including appropriate isolation, composition and reuse of the aspect code. The discussion is rooted in systems we have built using aspect-oriented programming. *
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.