Towards a New Aspect-Oriented Modelling Approach
Abdelhabib Bourouis
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
The application of the aspect oriented programming (AOP) paradigm throughout software cycle development as specification, design, and implementation phases, namely aspect oriented software development (AOSD), emerges as a young and dynamic research area in computer programming. It is a rapidly evolving area and one of the most popular topic for dealing with cross-cutting concerns by the realization of the separation of concerns (SOC) principle. In this paper, we propose a new aspect-oriented profile towards a new AO modelling approach based on the Unified Modelling Language (UML) as one of the most prominent protagonists at the design level.
Related papers
A Theory of Aspects for Aspect-Oriented Software Development
Citeseer
Aspect-Oriented Software Development (AOSD) is an emerging area with the goal of promoting advanced separation of concerns throughout the software development lifecycle. However, since there are many different approaches to Aspect-Oriented Programming (AOP), it is very difficult to identify the essential concepts and properties for supporting the design of aspect-oriented languages and tools, and effectively promote advances in the field of AOSD. In this context, this paper presents a theory of aspects -a conceptual framework for AOP that provides consistent terminology and basic semantics for thinking about a problem in terms of the core concepts and properties that characterize the aspect-oriented style as an emerging paradigm to software development. This theory has been used for evaluating existing aspect-oriented languages and tools and, in special, it has been used to characterize aSide, an aspect-oriented modeling language.
A UML Profile for Aspect Oriented Modeling
2001
AOP has matured to become Aspect Oriented Software Development (AOSD) that means the community recognizes the importance of applying aspect orientation to all phases of software development life cycle. Once an initial decomposition of the problem domain identifies software components and the corresponding aspectual properties that cut through these components we would like to be able to express this initial decomposition and carry it to the next life cycle phase. For this refinement process to be effective it must preserve the initial semantics. In this Position paper we propose an initial discussion on UML profile for AO modeling, which we believe will set the stage for AOSD modeling and hence move us towards a truly aspect oriented software systems. We also initiate the discussions regard modeling the orthogonal concerns in the aspectoriented software system, where loosely coupled concerns in different dimensions can be easily modeled and reasoned about in isolation of the core components and aspectual components.
Improving the Design and Implementation of Software Systems uses Aspect Oriented Programming
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 DESIGN LANGUAGES- AN ANALYSIS
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.
Extensions of UML to Model Aspect-oriented Software Systems
CLEI ELECTRONIC JOURNAL, 2011
Aspect-Oriented Programming (AOP) has arisen as a new technology to support a better SoC (Separation of Concerns), intending to contribute to the development of reusable, maintainable, and evolvable software sys-tems. Aspects have been also explored in the ...
Analyzing the role of aspects in software design
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.
From aspect-oriented design to aspect-oriented programs
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.
Evaluation of UML Extensions for Aspect Oriented Design
There are some concepts, such as synchronization, error checking, distribution, security, and others, that are dissimilar from the basic functionality of a system, and they are not correct encapsulated when using traditional programming methodolo- gies. Thus, the code corresponding to these concepts result disseminated through the complete system, and therefore the overall software quality decreased. Aspect Oriented Programming (AOP) provides solutions for code scattering promoting the separation of these concepts through mechanisms that allow an adequate abstraction and composition of them, to finally integrate the complete system. The unit that aggregates the entire semantic of each of these concepts is defined as aspect .T he explicit disunion of these concepts enables a more reliable management of software complexity, and a final product of better quality. The key principles applied are modularity, and separation of concerns. During the fist stages, the research related with AOP...
Aspect Oriented Software Engineering
Allied Journals, 2015
Aspect-Oriented Software Engineering (AOSE) has emerged a latest and very attractive software development model that is intended to complement and improve a wide variety of modern development areas. In addition, aspect oriented software engineering offers a wide variety of advanced and unique program development and modularization mechanisms. The research has shown that the development of software applications through aspect oriented software engineering mechanisms improves the implementation structure of a software application which has significant influence on a number of important software attributes for instance reduced complexity and enhanced reusability. Hence, these software attributes improves the quality of software development lifecycle as well as results in better software development (Brichau and D’Hondt; Garcia, Kulesza and Sant'Anna). This paper presents a detailed analysis of some of the important aspects associated with aspect oriented software engineering. This paper will outline some of the fundamental areas of aspect orientation approach which are required in contemporary software development. This paper will also discuss the role of aspect oriented software engineering in improving the performance of current software development lifecycles.
Related papers
Aspects and Objects: A Unified Software Design Framework
2013
Aspect-Oriented Software Development provides a means to modularize concerns of a system which are scattered over multiple system modules. These concerns are known as crosscutting concerns and they cause code to be scattered and tangled in multiple system units. The technique was first proposed at the programming level but evolved up through to the other phases of the software development lifecycle with the passage of time. At the moment, aspect-orientation is addressed in all phases of software development, such as requirements engineering, architecture, design and implementation. This thesis focuses on aspect-oriented software design and provides a design language, Aspect-Oriented Design Language (AODL), to specify, represent and design aspectual constructs. The language has been designed to implement co-designing of aspectual and non-aspectual constructs. The obliviousness between the constructs has been minimized to improve comprehensibility of the models. The language is applied in three phases and for each phase a separate set of design notations has been introduced. The design notations and diagrams are extensions of Unified Modelling Language (UML) and follow UML Meta Object Facility (UML MOF) rules. There is a separate notation for each aspectual construct and a set of design diagrams to represent their structural and behavioural characteristics.
Aspect-Oriented Model Development at Different Levels of Abstraction
Modelling Foundations …, 2011
The last decade has seen the development of many diverse aspect-oriented modeling (AOM) approaches. This paper presents eight different AOM approaches that produce models at different level of abstraction. The approaches are different with respect to the phases of the development lifecycle they target, and the support they provide for model composition and verification. The approaches are illustrated by models of the same concern from a case study to enable comparing of their expressive means. Understanding common elements and differences of approaches clarifies the role of aspect-orientation in the software development process.
Towards a UML Meta Model Extension for Aspect Oriented Modeling
The aspect-oriented programming paradigm (AOP) as a way of improving the separation of concerns principle has emerged initially at the programming level using strong languages like AspectJ. Currently, it becomes mature to stretch at premature stages of the software development process namely, the Aspect-Oriented Software Development (AOSD) which is a popular topic of software engineering research that leads to more dependable, reusable and maintainable artifacts. In this paper, we propose a UML profile for modeling crosscutting concerns where the separation of concerns is maintained to the level of code and the weaving is done by an AspectJ compiler.
Aspect-oriented design model.
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.
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
Modelling of Aspects using Aspect-Oriented Design Language
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...
Aspect-Oriented Modeling: Issues and Misconceptions
2010
Aspect-oriented programming is an extension to object-oriented programming. It introduces new constructs called “aspects” for representing crosscutting concerns in a system development. These constructs are somewhat similar to object-oriented “classes” but they also have some clear differences in terms of characteristics. This complicated nature of aspects makes their modeling a difficult task. While working on the modeling of new design techniques for aspect-oriented technology, we have come across some unresolved modeling issues and some misconceptions about the nature of aspects and their representation in software design. This paper highlights these misconceptions and outlines some important aspect-oriented modeling issues, such as the modular nature of aspects, their resemblance with classes, and their high coupling with the base program.
An approach to Aspect Modelling with UML 2.0
2004
The Aspect-Oriented Programming (AOP) has matured to become in Aspect-Oriented Software Development (AOSD), which its main objective is to promote the advance separation of concerns throughout the software development life cycle.
9th International Workshop on Aspect-Oriented Modeling
Lecture Notes in Computer Science, 2007
This report summarizes the outcomes of the 9th Workshop on Aspect-Oriented Modeling (AOM) held in conjunction with the 9th International Conference on Model Driven Engineering Languages and Systems-MoDELS 2006-in Genoa, Italy, on the 1st of October 2006. The workshop brought together approximately 25 researchers and practitioners from two communities: aspect-oriented software development and software model engineering. It provided a forum for discussing the state of the art in modeling crosscutting concerns at different stages of the software development process: requirements elicitation and analysis, software architecture, detailed design, and mapping to aspect-oriented programming constructs. This paper gives an overview of the accepted submissions and summarizes the results of the different discussion groups. Papers and presentation slides of the workshop are available at http://www.aspect-modeling.org/.
A Modelling Proposal for Aspect-Oriented Software Architectures
2006
Aspect-oriented programming (AOP) has emerged in recent years as a new paradigm for software development. PRISMA is an approach for developing complex and large software systems. It combines the aspect-oriented software development (AOSD) and the component-based software development (CBSD) in an elegant and novel way achieving a better management of crosscutting-concerns and software reusability. PRISMA approach proposes the separation of concerns from the very beginning of the software life-cycle in order to introduce them as reusable aspects of software architecture. PRISMA provides a framework to guide the development of complex and large software systems. The framework is composed by a modelling tool, a .NET middleware, and a compiler to automatically generate the application source code. In this paper, we present the modeling tool of the PRISMA framework and how it supports the reuse and maintenance improvements of the PRISMA model and its aspect- oriented description language (AOSD). We illustrate our proposal and modelling tool using a real-life case, the TeachMover robot
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.