ASPECT ORIENTED DESIGN LANGUAGES- AN ANALYSIS

2000

Aspect-oriented programming (AOP) aims at providing linguistic mechanisms that enable better separation of concerns in program development. Mainstream techniques, like objectoriented programming, do not provide a satisfactory solution to this problem, in that they do not capture the frequent case of aspects that cross-cut system components, and hence cannot be fully encapsulated. On the other hand, AOP is in its early stages, and it is still unclear what are the fundamental design criteria for aspectoriented languages (AOLs). A previous evaluation of a general-purpose AOL suggested that the flexibility gained by the ability to freely intertwine aspect and functional code opens several potential conflicts with the principles of objectorientation. Based on this experience, in this paper we present an alternative approach where the vision of a general-purpose AOL is replaced by the vision of a system where several, independent aspects are gathered, each providing specialized support for a single concern. The hypothesis underlying this work is that such a design approach provides a good compromise between flexibility and preservation of good objectoriented and programming principles.

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.

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 Software, 2014

The separation of concerns design principle improves software reutilization, understandability, extensibility and maintainability. By using the objectoriented paradigm, it is not always possible to separate into independent modules the different concerns of an application. The result is that the source code of crosscutting concerns are tangled and scattered across the whole application. Aspect-oriented programming offers a higher level of modularity, providing a solution for the code tangling and scattering problem. To show how aspectoriented programming can be used as a suitable mechanism to improve the modularity of object-oriented applications, this divulgative article presents the implementation of a typical design pattern following both the object-and aspectoriented paradigms. The two approaches are compared from the modularity perspective, establishing a discussion on the benefits provided and is current use.

2005

Nowadays, the object-oriented programming (OOP) is the dominant paradigm of software engineering. The solutions provided by OOP can be applied to facilitate creating well-structured program as well as the code reuse. That is the reason for its wide adoption and its relative dominance. The concept behind the OO approach is that the program under development consists of autonomous entities, so-called objects, whose functionality is realized by the communications of these objects.

Aspect-oriented programming is an extension to object-orientation with the goal of sep- arating the concerns of domain logic from application logic. The essay aims at look- ing at aspect-oriented from a theoretical perspective, trying to place it within the existing framework provided by object-orientation. The first section is an introduction to object- orientation. Here I will present the most common elements of object-orientation, and show the multifaceted terrain that object-orientation is. Concluding this first section I present two different ways of viewing object-orientation, trying to bring some order to the mate- rial presented that far. The second section deals with aspect-oriented programming. First I introduce the topic, and then I relate it to object-orientation actual implementations. Con- cluding I arguing for its relevance as a complimentary technique to be added to the object- orientation toolbox.

Lecture Notes in Computer Science, 1999

Aspect-oriented programming is a promising idea that can improve the quality of software by reduce the problem of code tangling and improving the separation of concerns. At ECOOP'97, the first AOP workshop brought together a number of researchers interested in aspectorientation. At ECOOP'98, during the second AOP workshop the participants reported on progress in some research topics and raised more issues that were further discussed. This year, the ideas and concepts of AOP have been spread and adopted more widely, and, accordingly, the workshop received many submissions covering areas from design and application of aspects to design and implementation of aspect languages.

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

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.

Software development evolution has introduced a number of useful software development methods. Efficient modularization of program artifacts that cut across multiple locations during software development called crosscutting concerns have been a major drawback for these software development methods including the almighty Object-Oriented Software Development method. Concerns like recovery, synchronization, logging, encryption, authentication, authorization, validation, verification, caching, transaction processing, monitoring, error detection and correction, optimizations etc are common and cut-across many modules. That is to say that the source codes for these concerns are duplicated in so many modules. In the case of Object-Oriented Software Development method, these concerns are not captured as an aspect but their source codes duplicated across multiple object methods because of the encapsulation principle. These crosscutting concerns reduce the reusability, maintainability and adaptability of software products, hence the need for a software development method called Aspect Oriented Software Development (AOSD) that gives a better modularization implementation in software development which are used for the composition of the program components more especially to the Object Oriented Software Development method.

2003

This paper describes and assesses the experiences gained using aspect-oriented programming as supported by the AspectJ language. Aspect-oriented programming is intended to support the modularisation in the design of concerns that are inherently cross-cutting in traditional object-oriented design.

2006

This report carries out a study that is based on literature of the state-of-the-art in Aspect-Oriented Design Approaches. The goal of this work is to position these design approaches within the full life-cycle of a software engineering process that encompasses requirements analysis, architecture design, detailed design, implementation, maintenance, evolution, etc. The study takes on the form of an evaluation that is based on a set of criteria communicating the goals of this report. The report provides a description and classification of these criteria including a discussion on the influence they have on various software quality factors. A conclusion will present a number of interesting observations about the current state-of-the-art.

ijcsi.org

Abstract: The classic challenge in writing object-oriented programs (OOP) is finding the right decomposition into classes and objects. This problem arises whenever programmers need to deal with crosscutting concerns. Aspect Oriented Programming (AOP) is a well known ...

Currently, the dominant programming paradigm is object-oriented programming—the idea that one builds a software system by decomposing a problem into objects and then writing the code of those objects. Such objects abstract together behavior and data into a single ...

The classic challenge in writing object-oriented programs (OOP) is finding the right decomposition into classes and objects. This problem arises whenever programmers need to deal with crosscutting concerns. Aspect Oriented Programming (AOP) is a well known methodology to overcome this issue by modularizing crosscutting concerns using aspects. Programmers are slowly realizing the importance of AOP since it creates cleaner code. But AOP breaks encapsulation in joint points and modifies flow control, making the source code hard to understand.AOP is not very well tested and documented and there is a lack of specific development tools. That's why it is mainly used only for maintaining the system, rather than being a good choice for developing the initial version of the system. The main goal of this paper is to increase the acceptability of AOP by offering some tips against its drawbacks.