Aspects and Objects: A Unified Software Design Framework

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

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.

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.

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.

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.

ACM SIGSOFT Software Engineering Notes, 2006

There is a need to study various approaches in the use of object-oriented design patterns and aspect oriented design approach in enterprise systems for architecture and its implementation. The development of aspect oriented requirements gathering approach, design notation and environment for development of enterprise systems needs to be further refined in the context of software applications and industry. Current development in aspects and the path to future work in this direction is highlighted regarding developing a general-purpose design language for aspect oriented software development.

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.

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.

8th Workshop on …, 2006

2012

The aspect-oriented programming has valuable advantages over other programming paradigms, but in turn it presents difficulties when applying the concepts within the stages of analysis and development to reduce the drawbacks of this paradigm. This paper proposes a methodology to reduce the drawbacks of the paradigm, at the same time provides steps that involve elements of common analysis in the Requirements Engineering with Aspects (basic unit of paradigm) in order to create the framework for a specific domain. The proposed methodology brings together some benefits methodologies, but it emphasizes the treatment of the first disadvantages of the programming aspects and the location and identification of aspects and elements; in addition, this article provides a tool that supports some methodology steps by generating part of the framework code base. In the process of treatment issues, the analysis is oriented to the specification of aspects using AspectJ, with rules to locate and determine aspects within its four cyclical stages. Finally, it includes a case study which evaluates the steps in this methodology