A UML-based aspect-oriented design notation for AspectJ

The Scientific World Journal, 2014

Unified Modeling Language is the most popular and widely used Object-Oriented modelling language in the IT industry. This study focuses on investigating the ability to expand UML to some extent to model crosscutting concerns (Aspects) to support AspectJ. Through a comprehensive literature review, we identify and extensively examine all the available Aspect-Oriented UML modelling approaches and find that the existing Aspect-Oriented Design Modelling approaches using UML cannot be considered to provide a framework for a comprehensive Aspectual UML modelling approach and also that there is a lack of adequate Aspect-Oriented tool support. This study also proposes a set of Aspectual UML semantic rules and attempts to generate AspectJ pseudocode from UML diagrams. The proposed Aspectual UML modelling approach is formally evaluated using a focus group to test six hypotheses regarding performance; a “good design” criteria-based evaluation to assess the quality of the design; and an AspectJ-...

2017

The Aspect-composition is a vital step in aspect modelling. Aspects are composed with each other and with base constructs through pointcuts defined in the aspects. Design languages address this composition by providing composition techniques and directives. However, most of the contemporary design languages lack support for inter-aspect and inner-aspect compositions. Another problem is resolving aspect interference which arises as a result of a composition. Although some techniques have been proposed to overcome aspect interference at the implementation level, the problem needs attention at the modelling level. The eradication of interference and conflicts related to aspect composition at the modelling stage could ensure better implementation and fewer conflicts. This paper provides a composition strategy equipped with new design notations and diagrams to provide support for aspect compositions, as well as inneraspect compositions. The paper also provides a technique to prioritize a...

2009

Designing crosscutting concerns (aspects) is a challenging task. Since crosscutting concerns were not addressed while developing contemporary software design techniques, so they lack support for accommodating representation of such concerns along with base program. Some design languages like UML have been extended to express aspects and their elements but they do not fully represent aspects. Some lack adequate representation of aspect elements and some lack an efficient and reusable composition technique.

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.

2007

Modularization of crosscutting concerns is the main benefit provided by Aspect-Oriented constructs. However, current AO languages do not address class modularity adequately. In order to achieve both class and crosscutting modularity, Design Rules for AO Systems should be defined. In this work we propose a language to specify Design Rules that establish the minimum requirements to enable the parallel development of class and aspects. Beyond the modularization improvement, the language creates a simpler and unambiguous specification, supporting the development of mechanisms for automatically checking the specified rules and making easier the using of the parametrization mechanisms.

Proceedings 33rd International Conference on Technology of Object-Oriented Languages and Systems TOOLS 33, 2000

Separation of concerns is a basic engineering principle that is also at the core of object-oriented analysis and design methods in the context of the Unified Modeling Language (UML). The UML gives the designer a rich, but somehow disorganized, set of views on her model as well as many features, such as design pattern occurrences, stereotypes or tag values, allowing her to add nonfunctional information to a model. Aspect-oriented concepts are applied to manage the multitude of design constraints. However, it can then be an overwhelming task to reconcile the various aspects of a model into a working implementation. In this paper, we introduce our UMLAUT framework as a tool for "weaving" aspects when modeling with the UML. This is accompanied with an example of a distributed multimedia application, applying two different weavings: one for implementation, the other one for validation based on model checking technology.

Aspect Oriented Programming (AOP) is a technique used to enhance the separation of concern in software design and implementation. To implement AOP developers most commonly use AspectJ, an extension of the Java language. In order to represent the separation of concerns a new design technique is needed for modeling of aspects. Aspect Oriented Design language (ASDL) is a design notation could build on the existing design language UML. It is capable of supporting many aspects-oriented languages. This research aims to investigate where developers can use aspect-oriented programming in the software development process. This includes how to identify Aspects in the design stage, then how they can be applied in the implementation process in software development .This will lead to improve modularity and reusability of the software. The paper will be a position paper abut Aspect Oriented Software Design, also will investigate several case studies of the design and implementation of a software application that shows how we can identify the Aspect in the process.

Aspect oriented software development is an emerging software development technology that seeks new modularizations of software systems, in computing. Today typical enterprise and internet applications have to tackle “concerns” like security, transactional behavior, logging et al. Many important concerns often crosscut several objects and classes of object oriented systems. AOSD is a favorable model to promote improved separation of concerns, leading to the production of software systems that are easily maintainable. Nevertheless implementation wise AOSD has made remarkable progress and number of efficient technologies has been developed, but there is no satisfactory design solution for AOSD. This position paper presents an analysis of the design languages for aspect oriented programming paradigm. Keywords: Aspect Oriented Software development (AOSD), Aspect Oriented Design Language (AODL), Design language, Modeling Language.

The Journal of Object Technology, 2007

Aspect-Oriented technologies, including Aspect-Oriented Modelling, provide a set of new constructs (e.g., advices or pointcuts), that help to improve the modularisation of crosscutting concerns. However, these new constructions can make it more difficult to understand how a system works as a whole, once all design modules are composed together, because: (1) designers may not be familiar with the new aspect-oriented constructions; and/or (2) aspect-orientation may cause new problems, such as the handling of aspect interactions. A straightforward and simple solution to check how a system works is to execute it. UML and its Action Semantics provide the foundations for modelling and executing object-oriented software systems. This paper presents a UML 2.0 Profile which extends the UML and its Action Semantics for the construction of aspect-oriented executable models and also a model weaver which makes the execution of such models possible. Our approach is illustrated using an Online Book Store system taken from the literature.

Proceedings of the 10th international workshop on Aspect-oriented modeling, 2007

Aspect-Oriented technologies, including Aspect-Oriented Modeling, introduces a set of new constructions, e.g., advices or pointcuts, that improve the modularization of crosscutting concerns. These new constructions can make it more difficult to understand or visualize how a system works after the different (design) modules are composed together. A straightforward and simple mechanism to observe how a system works is to execute it. UML and its Action Semantics provide the foundations for modeling and executing objectoriented software systems. This paper presents an aspectoriented extension to the UML and its Action Semantics for the construction and execution of aspect-oriented models. Before executing such aspect-oriented models, they must be weaved. The corresponding model weaver is also presented in this paper.

2014

Many different aspect oriented languages have been developed since the first presentation of aspect oriented concepts in 1997 by Kiczales et al. In this paper we compare four of the existing languages using different criteria: the aspect oriented concepts implemented, weaving, and whether they require source code modification.

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

Aspect-oriented programming comes with new composition mechanisms which permit to modularize code which crosscuts other modules using traditional composition techniques. Although such mechanisms permit a better modularization they do not guarantee it: if the aspect-oriented code is better modularized depends on the design of the aspect-oriented applications. This paper describes typical design failures in AspectJ and introduces a tool implemented on top of AspectJ which permits to specify design constraints on AspectJ code.

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

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