From aspect-oriented design to aspect-oriented programs

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.

2004

This position paper presents some principles for the design of aspect-oriented systems and preliminary guidelines for aspect-oriented design using the aSideML modeling language.

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

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

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.

Aspect-Oriented Programming is known as a technique for modularizing crosscutting concerns. However, constructs aimed to support crosscutting modularity might actually break class modularity. This can be mitigated by using adequate Design Rules between classes and aspects. We present a language that supports most of the Design Rules found in AO Systems, making easy to express and verify them automatically. We discuss how our language improves crosscutting modularity without breaking class modularity. Also, we give some details about the language semantics expressed in Alloy.

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

ACM SIGSOFT Software Engineering Notes, 2004

We present a new classification system for aspect-oriented programs. This system characterizes the interactions between aspects and methods and identifies classes of interactions that enable modular reasoning about the crosscut program. We argue that this system can help developers structure their understanding of aspect-oriented programs and promotes their ability to reason productively about the consequences of crosscutting a program with a given aspect.

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.

International Journal of Advanced Computer Science and Applications, 2019

This paper describes and analyzes the main differences and advantages of the Join Point Interfaces (JPI) as an Aspect-Oriented Programming (AOP) approach for the modular software production concerning the standard aspect-oriented programming methodology for Java (AspectJ) to propose a structural modeling approach looking for modular software solutions. Using a Software Engineering point-of-view, we highlight the relevance of structural and conceptual design for JPI software applications. We model and implement a classic example of AOP using AspectJ and JPI as an application example to review their main difference and highlight the JPI consistency between products (models and code). Our proposal of UML JPI class diagrams allows the definition of oblivious classes which know about their JPI connections, an essential element to adapt and transform tradition like-AspectJ AOP solutions to their JPI version. Thus, for the modular software production and education, JPI seems an ideal software development approach.

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.

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.

Object-Oriented …, 1998

1998

Aspect-oriented programming is a new software design and implementation technique proposed by researchers at Xerox PARC. This project is assessing the claims of aspect-oriented programming to improve the software development cycle for particular kinds of applications. The project is divided into three experiments, the first of which has been completed. These experiments have been designed to investigate, separately, such characteristics of aspect-oriented development as the creation of new aspect-oriented programs and ease of debugging aspect-oriented programs.

Aspect-oriented programming (AOP) is an exciting new development in the field of software engineering. The open-source AspectJt project has taken a leading role in defining what an aspect-oriented programming language should look like and in building tools that enable aspect-oriented techniques to be employed in the development of large-scale commercial software. IBM both contributes to the development of AspectJ and uses it internally with its accompanying IDE (integrated development environment) support, AspectJ Development Tools (AJDT). This paper provides an introduction to aspect-oriented programming using AspectJ and AJDT. We also discuss the role that open source (and being an open-source project) has played in the ongoing development of AspectJ, and how this has facilitated a level of collaboration and exploitation that would not have been possible otherwise.