A classification system and analysis for aspect-oriented programs

ECOOP'97—Object- …, 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. *

Proceedings of the 21st international conference on Software engineering - ICSE '99, 1999

The principle of separation of concerns has long been used by software engineers to manage the complexity of software system development. Programming languages help software engineers explicitly maintain the separation of some concerns in code. As another step towards increasing the scope of concerns that can be captured cleanly within the code, Kiczales and colleagues have introduced aspect-oriented programming. In aspect-oriented programming, explicit language support is provided to help modularize design decisions that cross-cut a functionally-decomposed program. Aspect-oriented programming is intended to make it easier to reason about, develop, and maintain certain kinds of application code. To investigate these claims, we conducted two exploratory experiments that considered the impact of aspect-oriented programming, as found in AspectJ version 0.1, on two common programming activities: debugging and change. Our experimental results provide insights into the usefulness and usability of aspect-oriented programming. Our results also raise questions about the characteristics of the interface between aspects and functionallydecomposed core code that are necessary to accrue programming benefits. Most notably, the separation provided by aspect-oriented programming seems most helpful when the interface is narrow (i.e., the separation is more complete); partial separation does not necessarily provide partial benefit.

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. *

Proceedings of the 6th international conference on Aspect-oriented software development - AOSD '07, 2007

Join Point Designation Diagrams (JPDDs) permit developers to design aspect-oriented software on an abstract level. Consequently, JPDDs permit developers to communicate their software design independent of the programming language in use. However, developer face two problems. First, they need to understand the semantics of JPDDs in addition to their programming language. Second, after designing aspects using JPDDs, they need to decide how to map them into their programming language. A tool-supported translation of JPDDs into a known aspect-oriented language obviously would ease both problems. However, in order to achieve this goal, it is necessary to determine what a "good" JPDD translation looks like, i.e. it is necessary to have a number of principles that determine the characteristics of a "good" translation. This paper describes a toolsupported translation of JPDDs to aspect-oriented languages. Principles for translating JPDDs are described and a concrete mapping to the aspect-oriented language AspectJ is explained.

Journal of Electrical Systems and Information Technology, 2018

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.

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 ...

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.

Communications of the ACM, 2001

There is growing agreement in the software community about the limitations of object orientation to cope with the problem of building highly reusable, adaptable, and extensible software systems.

2020

The success of new programming paradigm such as the Aspect-Oriented Programming (AOP) relies mainly on solid support tools and advanced development environments. However, the productivity is still restricted by a text-based primary input method at coding level, what makes program understanding, building, and maintaining difficult for developers. To reduce such difficulties, we propose to take the AOP out of the conventional style of coding by using a new approach, which is partially visual. The approach is intended to better support the coding process by introducing more interactivity and a high-degree of flexibility. We seek to minimize the influence of language syntax on overall usability by using the ordinary drag-and-drop technique to overcome the weaknesses of text-based style to the of AOP paradigm. Our approach has been implemented in an Eclipse-based prototype tool and evaluated through a controlled experiment to prove its feasibility and usefulness. As preliminary results, ...

Aspect-oriented programming (AOP) is a way of modularizing a software system by means of new kind of modules called aspects in software development. To this end AOP helps in alleviating crosscutting concerns of system modules by separating into several aspect modules, thereby aiming to improve separation of concerns. On the other hand, aspects can bring unexpected behaviour to a system while attempting to alter the system’s concerns. They can modify the behaviour of the base system without warning. Following to this, such impact can limit to achieve modular reasoning in an aspect-oriented system properly. Obtaining the valuable data, we try to get an idea of how difficult it is to achieve modular reasoning. In this thesis, we analyse the existing ten aspect-oriented systems by answering six research questions. These six questions were derived from our general question: "how AspectJ is used in practice?". In order to answer each one of them, we have implemented a metrics suite including both aspect-oriented and object-oriented features using Ekeko. Next to modular reasoning, we also acquire other usefulness about AOP constructs and coupling between classes and aspects. These results can then be used to influence the design of existing or new AOP languages, or to improve existing analysis tools.