Aspect-Oriented Programming Workshop Report
Bedir Tekinerdogan1998, Object-Oriented …
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
AI
AI
The workshop focused on the evolving concept of Aspect-Oriented Programming (AOP) as a mechanism for modeling various concerns within a software system. Participants discussed challenges including the identification of aspects, interaction between components and aspects, and ways to merge them into executable forms. Notably, the discourse highlighted the need for a theoretical foundation, practical applications across all phases of the software development life-cycle, and an understanding of the contextual information necessary for effective AOP implementation.
Key takeaways
- Having dierent aspect languages is neither necessary nor sucient for AOP.
- But can we h a ve a high enough cannot monadic programming 5.4 Reection versus AOP 5.5 Identication of Aspects level output language?
- With AOP we w ant to separate out dierent aspects at a more convenient abstraction level.
- The key question here is how m uch of the technology that is needed for AOP (or AO*) is already available.
- As people will want t o k n o w whether AOP is new or whether it is nothing more than a new name for an old thing, comparisons between AOP and related work (such as composition lters and subject-oriented programming) are important.
Related papers
Second Workshop on Aspect-Oriented Software Development
2002
Syntax Trees 59 11 D. Vollmann Visibility of Join-Points in AOP and Implementation Languages 65 Part I Implementing and Reasoning about Aspects Reasoning About a Classification of Crosscutting Concerns in Object-Oriented Systems Constantinos A. Constantinides Department of ...
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.
Aspect oriented programs: Issues and perspective
Journal of Electrical Systems and Information Technology, 2018
Aspect oriented programming (AOP) helps programmers for separating crosscutting concerns. All programming methodologies support split up and encapsulation of concerns. In object-oriented programming (OOP) crosscutting aspects are distributed among objects. It is hard to attain crosscutting in OOP as it is scattered in different objects. In AOP crosscutting concerns are addressed using one entity called aspect. This paper discusses varieties of existing slicing techniques of AOP. Also, we discuss a novel method to calculate dynamic slice of AOP. To represent AOP Aspect Oriented System Dependence Graph (AOSDG) is used. The complexity of this new approach is equal or improved as related to certain prevailing approaches.
Aspect Programming with the Use of AspectJ
Developments in Information & Knowledge Management for Business Applications, 2020
Aspect programming with the use of AspectJ illustrates how the AOP techniques can be used to avoid the occurrence of application problems related to the information systems creation when using the Object-Oriented programming paradigm. Implementation of cross-cutting concerns using OOP forces programmers to repeat many times the same code instructions in the system. The approach provided by Aspect-Oriented programming allows maintaining the modular design of the application by extracting the cross-cutting concerns from it, its modularization in terms of aspects, and its reintegration into the applications main part in the weaving process or with the use of a proxy mechanism.
Aspect-oriented programming
ECOOP'97Object- …, 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. *
A Formal Foundation for Aspect Oriented Software Development
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.
An initial assessment of aspect-oriented programming
Proceedings of the 21st international conference on Software engineering - ICSE '99, 1999
The principle of separation of concerns has long been used by software engineers to manage the complexity of software system development. Programming languages help software engineers explicitly maintain the separation of some concerns in code. As another step towards increasing the scope of concerns that can be captured cleanly within the code, Kiczales and colleagues have introduced aspect-oriented programming. In aspect-oriented programming, explicit language support is provided to help modularize design decisions that cross-cut a functionally-decomposed program. Aspect-oriented programming is intended to make it easier to reason about, develop, and maintain certain kinds of application code. To investigate these claims, we conducted two exploratory experiments that considered the impact of aspect-oriented programming, as found in AspectJ version 0.1, on two common programming activities: debugging and change. Our experimental results provide insights into the usefulness and usability of aspect-oriented programming. Our results also raise questions about the characteristics of the interface between aspects and functionallydecomposed core code that are necessary to accrue programming benefits. Most notably, the separation provided by aspect-oriented programming seems most helpful when the interface is narrow (i.e., the separation is more complete); partial separation does not necessarily provide partial benefit.
Malaj: A proposal to eliminate clashes between aspect-oriented and object-oriented programming
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.
Assessing aspect-oriented programming and design: Preliminary results
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—An Object-Oriented Extension
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.
Related topics
Related papers
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 programming: Introduction
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 ...
Aspect-Oriented Programming Workshop
1999
Building software from reusable components is considered important in reducing development costs. Object-oriented languages such as C++, Smalltalk and Java, however, are not capable of expressing certain aspects of applications in a reusable way. Software engineers may experience difficulties in composing and reusing applications from components, for example if components implement code for multiple views, dynamic inheritance and synchronization [6]. If these aspects have to be programmed, then object- ...
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.
Problems in Aspect Oriented Design
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.
Practical applications of the aspect-oriented programming
This paper describes the basic concepts of the aspect-oriented programming (AOP) and some of its practical use cases. It also explains different ways of implementation of AOP, particularly the way in which aspects are applied to given program (process called aspect-weaving). The paper also shows some technologies which take advantage of the AOP and compares them based on different characteristics, including: type of the technology, applications of the technology, AOP model which is used and its high level implementation. Technologies are chosen to cover large spectrum of applications. The use cases of AOP programming are supported by practical examples in which the usage of aspects leads to more modular and maintainable code.
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.
Introduction to Aspect-Oriented Programming
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.
Review on Aspect Oriented Programming
International Journal of Advanced Computer Science and Applications, 2013
Aspect-oriented programming (AOP) has been introduced as a potential programming approach for the specification of nonfunctional component properties, such as fault-tolerance, logging and exception handling. Such properties are referred to as crosscutting concerns and represent critical issues that conventional programming approaches could not modularize effectively leading to a complex code. This paper discusses AOP concept, the necessity that led to it, how it provides better results in code quality and software development efficiency, followed by stating challenges that developers and researchers face when dealing with this approach. It has been concluded that AOP is promising and deserves more attention from developers and researchers. However, more systematic evaluation studies should be conducted to better understand its implications.
Aspect-Oriented Programming with AspectJ
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.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.