Synchronization is an important problem in the design and development of the software, which has been resolved in the object-orientedprogramming (OOP). However, the implementation of OOP is easy to leads to code-tang...
详细信息
ISBN:
(纸本)9780769534985
Synchronization is an important problem in the design and development of the software, which has been resolved in the object-orientedprogramming (OOP). However, the implementation of OOP is easy to leads to code-tangling and code-scattering between functional properties and crosscutting properties. aspect-oriented programming (AOP) can solve the problem of code-tangling and code-scatterting, and provide a mechanism of the modularization of crosscutting properties. Synchronization, as a typical aspect, is resolved based on AOP in this paper. Taking the classical producer-consumer problem as a case study, this paper identifies the synchronization as a crosscutting concern, modularizes it as an aspect and implements the program with aspectJ. The execution result shows AOP can not only resolve the problem of synchronization, but also gain the effect of modularization better than OOP. Furthermore, compared execution time of AOP program with that of OOP program, the result shows that the execution time of AOP is similar to OOP.
aspectorientedprogramming (AOP) is a new programming paradigm that enhances current programming methodologies. It introduces higher level of modularity and better handling of software complexity by providing another...
详细信息
ISBN:
(纸本)1932415300
aspectorientedprogramming (AOP) is a new programming paradigm that enhances current programming methodologies. It introduces higher level of modularity and better handling of software complexity by providing another level of abstraction for Separation of Concerns. Multidimensional Separation of Concerns (MDSOC) is one of the AOP approaches with the strong emphasis on addressing software evolution issues including encapsulation of random and/or even the unanticipated concerns. Visual Basic((R)) is commonly used in various business applications that usually change so fast It should have a good evolution capability. Now, ***(TM) is very powerful and its abstraction capability enables MDSOC implementation on it. Hyper-YB tool is created to demonstrate how the AOP addition to ***(TM) using MDSOC approach enhances software evolution;modularity and reusability. The techniques used are adapted from the ones used by Hyper/J(TM) system (an AOP implementation using MDSOC for Java(TM) developed by IBM(R)) and further improved.
aspect-oriented programming (AOP) is commonly assumed to be a technique which improves the resulting software with respect to modularity. However, previous empirical experiments suggest that AOP is with respect to dev...
详细信息
ISBN:
(纸本)9780769543987
aspect-oriented programming (AOP) is commonly assumed to be a technique which improves the resulting software with respect to modularity. However, previous empirical experiments suggest that AOP is with respect to development or maintenance time either a technique without a measurable benefit or a technique with a measurable negative effect. A possible reason why previous experiments were not able to show such a benefit is, that those experiments did not consider situations where AOP has its strength: situations where modules need to be frequently changed. In those situations AOP might be able to compensate a possible higher initial development effort. This paper describes an empirical, socio-technical study with Java and aspectJ where developers needed to perform changes on their code base multiple times. It shows that frequent changes in the crosscutting code which do not change the concern's underlying structure compensate an initial higher development time for those concerns. But it also shows that changes, which do alter the concern's structure again result in higher development times when using AOP.
A characteristic of aspect-oriented programming, as embodied in aspectJ, is the use of advice and pointcuts to define behavior that crosscuts the structure of the rest of the code. The events during execution at which...
详细信息
A characteristic of aspect-oriented programming, as embodied in aspectJ, is the use of advice and pointcuts to define behavior that crosscuts the structure of the rest of the code. The events during execution at which advice may execute are called join points. A pointcut is a set of join points. An advice is an action to be taken at the join points in a particular pointcut. In this model of aspect-oriented programming, join points are dynamic in that they refer to events during the flow of execution of the program. We give a denotational semantics for a minilanguage that embodies the key features of dynamic join points, pointcuts, and advice. This is the first semantics for aspect-oriented programming that handles dynamic join points and recursive procedures. It is intended as a baseline semantics against which future correctness results may be measured.
The aspect-oriented programming (AOP) is gaining popularity for it offers a means to encapsulate crosscutting concerns in the development of complex software systems. The power of AOP enables more degree of separation...
详细信息
ISBN:
(纸本)9783642549007;9783642548994
The aspect-oriented programming (AOP) is gaining popularity for it offers a means to encapsulate crosscutting concerns in the development of complex software systems. The power of AOP enables more degree of separation-of-concerns which leads to more understandable, maintainable and extensible software. However, challenges arise when using AOP in the embedded software development. In this work we propose to do embedded application development based on AOP. We implement cockpit display system application software framework (CASF) on VxWorks platform with AOP features based on aspect-oriented C. Based on this, we implement a sample cockpit display application and test it on the real avionic device. This case study illustrates the potential benefits and issues associated with the use of AOP in embedded development.
Adaptive User Interfaces (AUIs) provide better usability, user satisfaction as well as personalized experience. AUIs bring broad benefits to end users, but their construction introduces numerous difficulties caused by...
详细信息
ISBN:
(纸本)9781467386111
Adaptive User Interfaces (AUIs) provide better usability, user satisfaction as well as personalized experience. AUIs bring broad benefits to end users, but their construction introduces numerous difficulties caused by extended development and maintenance efforts. One option to deal with the above problems is to generate various User Interface (UI) descriptions from a model or existing code. This paper considers the aspect-oriented programming (AOP)-based approach for the AUI design. Integrations of the approach with contemporary AUI frameworks, such as XML User Interface Language (XUL), User interface protocol (UIP) and JavaServer Faces (JSF) are compared from the perspective of the development and maintenance on a case study involving context-aware (CA) application. The outcome of this paper presents advantages, disadvantages and limitations of the particular frameworks for construction of AUIs.
As programs continue to increase in size, it has become increasingly difficult to separate concerns into well localized modules, which leads to code tangling - crosscutting code spread throughout several modules. Thus...
详细信息
As programs continue to increase in size, it has become increasingly difficult to separate concerns into well localized modules, which leads to code tangling - crosscutting code spread throughout several modules. Thus, aspect-oriented programming (AOP) offers a solution to creating modules with little or no crosscutting concerns. AOP presents the notion of aspects, and demonstrates how crosscutting concerns can be taken out of modules and placed in a centralized location. In this paper, a taxonomy of aspect-oriented programming, as well as a basic overview and introduction of AOP, will be presented in order to assist future researchers in getting started on additional research on the topic. To form the taxonomy, over four-hundred research articles were organized into fifteen different primary categories coupled with sub-categories, which show where some of the past research has been focused. In addition, trends of the research were evaluated and paths for future exploration are suggested.
aspect-oriented programming is considered a promising new technology. As object-orientedprogramming did before, it is beginning to pervade all areas of software engineering. With its growing popularity, practitioners...
详细信息
aspect-oriented programming is considered a promising new technology. As object-orientedprogramming did before, it is beginning to pervade all areas of software engineering. With its growing popularity, practitioners and academics alike are wondering whether they should start looking into it, or otherwise risk having missed an important development. The author of this essay finds that much of aspect-oriented programming's success seems to be based on the conception that it improves both modularity and the structure of code, while in fact, it works against the primary purposes of the two, namely independent development and understandability of programs. Not seeing any way of fixing this situation, he thinks the success of aspect-oriented programming to be paradoxical.
The potential of aspect-oriented programming to adequately capture crosscutting concerns has yet to be fully realized. For example, authors have detailed significant challenges in creating reusable aspect component li...
详细信息
The potential of aspect-oriented programming to adequately capture crosscutting concerns has yet to be fully realized. For example, authors have detailed significant challenges in creating reusable aspect component libraries. One proposed solution is to introduce Explicit Join Points (EJPs) to increase modularity by reducing obliviousness, enabling a Cooperative aspect-oriented programming (Co-AOP) methodology where base code and aspects synergistically collaborate. This article explores the trade-offs between obliviousness and modularity. We briefly introduce EJPs and Co-AOP, and hypothesize how to balance obliviousness and modularity using Co-AOP. We build upon a prior empirical study to refactor three real-life Java applications to implement the exception handling concern using three distinct strategies: (1) using fully oblivious aspects in aspectJ, (2) using EJPs in a fully explicit fashion, and (3) using EJPs while following the Co-AOP methodology. We study other crosscutting concerns by refactoring a fourth application, JHotDraw. The differences in terms of common code metrics are analyzed, and the impact on modularity is assessed using design structure matrices. Results indicate that the Co-AOP methodology can in many cases significantly improve code quality attributes versus fully oblivious or fully explicit approaches. We conclude with guiding principles on the proper use of EJPs within the Co-AOP methodology.
暂无评论