A UML Profile for Aspect Oriented Modeling

2004

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.

International Journal of Engineering and Manufacturing

Aspect Oriented Software Development (AOSD) has been considered one of the most promising abstractions to make software structure more maintainable and configurable. It also helps to overcome two big issues of current object oriented programming principles, to reduce the problem of code tangling and code scattering. Aspect Oriented Programming (AOP) has been focused largely in the implementation/coding phase. But nowadays the AOP has been matured enough to turn into AOSD, as it the main objective of separation of concerns right through the process of software development. In this paper we deal with the impact of aspect in development of software especially in designing aspect with Unified Modelling Language (UML). We propose visual models to incorporate aspect and aspectual constructs as an UML metamodel approach and new extensions to UML. The proposed language aspect oriented design modelling language (AODML) is an extension for aspect modelling into existing UML specifications. This paper allows designers to specify and realize aspects in the design and implementation phase explicitly. The proposed visual models, supports Aspect, aspectual components and its association with base components i.e. classes to be incorporated into UML. AODML motivates designer to get benefited to develop the system using AOSD paradigm. It allows to model aspects in design diagrams so that it can be implemented in any AOP language effectively.

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.

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

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. In this paper, some of the aspect-oriented design techniques have been critically discussed. A proposed aspect model has been discussed which helps in overcoming the deficiencies in the contemporary aspect-oriented design techniques. This model represents aspects and their elements throughout the software development life cycle.

Aspects are widely accepted as properties that cross-cut several components in a subsystem. Aspect Oriented Software Development (AOSD) is a challenging field of research. On the one hand, the main problems have been defined and addressed; on the other hand, these problems and their solutions have brought new ones. Since a few years there are mainly two linguistic approaches for aspectual programming languages, namely AspectJ and Compose*. Proposals towards the modeling of aspects, have also been outlined, as well as methods for aspect identification at the requirements stage. Tools for aspect mining in code have also been developed. The efforts of several research groups come together and provide an interesting framework which we believe is aimed at improving current software development approaches and build over the Object Oriented Paradigm. It is nevertheless necessary to precise our understanding of the subject matter of research, the so called aspects, and provide for a clear definition, a syntax and semantics. This paper proposes a basic still precise definition of aspect and outlines an approach to provide aspects with a syntactical and semantic corpus.

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.

2005

Aspect-oriented software development (AOSD) techniques aim at providing means for the systematic identification, modularisation and composition of crosscutting concerns throughout the software life cycle. A number of aspect-oriented programming approaches are available, for instance, AspectJ [2], composition filters , adaptive programming and Hyper/J . The concepts are also being applied at the earlier stages of software development. At the requirements engineering stage, provide means for handling aspectual requirements. Similarly, a number of aspect-oriented specification and design approaches have been proposed. With a range of techniques available to a software engineer at each stage, the task of engineering an aspect-oriented system poses significant challenges. At each development stage, the software engineer needs to employ the most suitable aspect-oriented technique for the application being developed. The choice of technique can be dictated by a number of factors including system requirements, organisational practices, constraints imposed by the tools or development environments, and the nature of the crosscutting concern. The latter implies that multiple techniques may be employed at each stage in conjunction with each other. This hybrid view of separation of concerns has previously been advocated by multi-paradigm approaches and more recently for aspect-oriented programming techniques . As AOSD techniques mature, there is a need for guidelines supporting development of wellengineered aspect-oriented systems. It is the aim of this chapter to provide such guidelines for key phases of the software lifecycle. The guidelines are aimed at describing the distinguishing characteristics of AOSD approaches at each stage and their suitability for the application or concern being modularised. By making these guidelines available, we aim to support the software engineer in choosing the optimal technique or set of techniques at each stage. Note that aspectisation should not be a forced phenomenon. Conventional separation of concerns techniques (e.g. object-oriented approaches) should be used if crosscutting concerns can be cleanly modelled without having to encapsulate them in a separate unit. For instance, a crosscutting concern could be embodied in the choice of specific system architecture rather than an individual unit . However, when this clean separation of a crosscutting concern is not possible, aspect-oriented techniques should be used.

IEE proceedings-software, 2004

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.

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.

Lecture Notes in Computer Science, 2010

This report summarizes the outcome of the 14th Workshop on Aspect-Oriented Modeling (AOM), as part of the 12th International Conference on Model Driven Engineering Languages and Systems-MoDELS 2009-in Denver, Colorado, USA, on the 4th of October 2009. The workshop brought together researchers and practitioners from two communities: aspect-oriented software development (AOSD) and software model engineering. This paper gives an overview of the accepted submissions, and summarizes the results of the discussion.

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

2006

This report summarizes the outcome of the 7th Workshop on Aspect-Oriented Modeling (AOM) held in conjunction with the 8th International Conference on Model Driven Engineering Languages and Systems–MoDELS 2005–in Montego Bay, Jamaica, on the 2nd of October 2005. The workshop brought together researchers and practitioners from two communities: aspect-oriented software development (AOSD) and software model engineering.