Improving Extensibility of Object-Oriented Frameworks with Aspect-Oriented Programming

2006 ◽  
pp. 231-245 ◽  
Author(s):  
Uirá Kulesza ◽  
Vander Alves ◽  
Alessandro Garcia ◽  
Carlos J. P. de Lucena ◽  
Paulo Borba
Keyword(s):  
Object Oriented ◽  
Aspect Oriented Programming

scholarly journals An Assessment of Maintainability of an Aspect-Oriented System

2013 ◽  
Vol 2013 ◽  
pp. 1-11 ◽  
Author(s):  
Kagiso Mguni ◽  
Yirsaw Ayalew
Keyword(s):  
Software Maintenance ◽  
Structural Complexity ◽  
Object Oriented ◽  
Aspect Oriented Programming ◽  
New Approach ◽  
Crosscutting Concerns ◽  
Aspect Oriented System ◽  
Important Activity ◽  
Oriented System

Software maintenance is an important activity in software development. Some development methodologies such as the object-oriented have contributed in improving maintainability of software. However, crosscutting concerns are still challenges that affect the maintainability of OO software. In this paper, we discuss our case study to assess the extent of maintainability improvement that can be achieved by employing aspect-oriented programming. Aspect-oriented programming (AOP) is a relatively new approach that emphasizes dealing with crosscutting concerns. To demonstrate the maintainability improvement, we refactored a COTS-based system known as OpenBravoPOS using AspectJ and compared its maintainability with the original OO version. We used both structural complexity and concern level metrics. Our results show an improvement of maintainability in the AOP version of OpenBravoPOS.

The Study and Realization of Online Submission and Peer Review System Based on AOP

2011 ◽  
Vol 295-297 ◽  
pp. 1817-1822
Author(s):  
Jing Jun Zhang ◽  
Lei Wang ◽  
Hui Li ◽  
Guang Yuan Liu
Keyword(s):  
Peer Review ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Peer Review System ◽  
Review System ◽  
Aspect Oriented Programming ◽  
Related Object ◽  
Online Submission ◽  
Authentication And Authorization ◽  
Object Models

Aspect-Oriented Programming (AOP) is a new programming technology. It compensates the weakness of Object-Oriented Programming (OOP) at applying common behavior that spans multiple non-related object models. Interceptor adopts the logos of AOP and uses a way of hot swap solving these problems. At this issue, we research the AOP technology of Java Web called Struts interceptor. We show the advantage of this new programming method through an online submission and review system which using AOP method in the authentication and authorization.

MAINTAINABILITY METRICS FOR ASPECT-ORIENTED SOFTWARE

2009 ◽  
Vol 19 (03) ◽  
pp. 389-420 ◽  
Author(s):  
MATHUPAYAS THONGMAK ◽  
PORNSIRI MUENCHAISRI
Keyword(s):  
Design Principle ◽  
Object Oriented ◽  
Design Principles ◽  
Design Guidelines ◽  
Quality Model ◽  
Aspect Oriented Programming ◽  
Scattering Problems ◽  
Object Oriented Design ◽  
Software Maintainability ◽  
Set Up

Maintainability is an important factor that developers should be concerned because two-thirds of software costs involve maintenance. Aspect-oriented programming (AOP) paradigm is aimed to increase the software maintainability. It solves code tangling and code scattering problems by introducing a new modular unit, called "aspect". Various research works are provided to support measuring the object-oriented software, but only few studies are set up to support measuring the aspect-oriented software. This paper proposes aspect-oriented software maintainability metrics and a set of aspect-oriented design guidelines to support the metrics. By combining the proposed guidelines, object-oriented design principles, and aspect-oriented design principles, the metrics are constructed according to the Factor-Strategy (FS) quality model and the Factor-Criteria-Metric (FCM) quality model. Principle violation check definitions in the form of Boolean expressions are also defined to conduct software measurement and to fulfill the metrics. Finally, the aspect-oriented software maintainability metrics are applied to detect design principle violations in fifty AspectJ systems. The results show that for all systems their hidden flaws are exposed. Moreover, the proposed metrics are used to compare the maintainability between two versions of systems written in Java and AspectJ.

Problems of test-driven aspect-oriented development

2009 ◽  
Vol 38 (38) ◽  
pp. 180-186
Author(s):  
Aleksandr Sukhorukov
Keyword(s):  
Single Unit ◽  
Negative Impact ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Test Design ◽  
Aspect Oriented Programming ◽  
Test Driven Development ◽  
New Development ◽  
Unit Tests

Problems of test-driven aspect-oriented developmentTest-driven development and aspect-oriented programming are relatively new development techniques each having its own benefits. However, using aspect-oriented language like AspectJ in test-driven development leads to new types of problems that do not appear if these two approaches are applied separately. These problems arise mainly because aspect-oriented paradigm breaks encapsulation principle - behaviour of class is not implemented just in class itself like in traditional object-oriented programming but can be heavily affected by many external aspects. Traditional unit tests designed to test a single unit are not sufficient any more because behaviour being tested is distributed through several units at once, so test design becomes more complicated. In order to efficiently use these two techniques together such problems have to be identified and ways to workaround them have to be discovered. This paper focuses on those problems, describing the most notable ones. Problem descriptions are based on experience with AspectJ, but most of them are common to any aspect-oriented language with similar features. Some empirically discovered principles are provided that help softening negative impact of those problems.

Sign in / Sign up

Export Citation Format

Share Document