scholarly journals Replacing Object Oriented Programming Features through Aspect Oriented Programming with Crosscutting Concerns

2017 ◽  
Vol 171 (7) ◽  
pp. 15-18
Author(s):  
Ravi Kumar ◽  
Munishwar Rai
Keyword(s):  
Object Oriented ◽  
Object Oriented Programming ◽  
Aspect Oriented Programming ◽  
Crosscutting Concerns

scholarly journals Facets of Aspect Oriented Programming

2020 ◽  
Vol 9 (4) ◽  
pp. 1693-1696
Keyword(s):  
Object Oriented ◽  
Object Oriented Programming ◽  
Aspect Oriented Programming ◽  
Crosscutting Concerns ◽  
Design And Implementation ◽  
Programming Paradigm ◽  
Early Stages

AOP-Aspect Oriented Programming is a new programming paradigm for separating crosscutting concerns that are generally hard to do in object-oriented programming. As AOP has better ability to handle crosscutting concerns than Object-Oriented Programming (OOP,) it supports to write more modularized and more sustainable code. In addition, numerous publications discuss about the advantages of AOP design and implementation. However, for this new programming paradigm the work is in its early stages. The paper is all about the surveyed and reviewed several facets of AOP.

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.

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.

The Study on the Implementation of AOP in .NET Platform

2013 ◽  
Vol 336-338 ◽  
pp. 2077-2082
Author(s):  
Zheng Yan Dong
Keyword(s):  
Design Pattern ◽  
Implementation Strategy ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Aspect Oriented Programming ◽  
The Moment

AOP(Aspect Oriented Programming) is a programming technology that makes the OOP (Object Oriented Programming) technology more complementary and perfect when being applied together with OOP technology. AOP provides ideal modularized structure for programming. At the moment, AOP has been supported and applied in two leading programming platforms: Java and .Net. Java provides perfect support to AOP, but .Net has not clearly provided the technique to support AOP. Meanwhile, Design Pattern has been widely used in programming. This study analyzes the theory of AOP technique and provides an implementation strategy for AOP based techniques on Proxy Pattern in .Net platform.

scholarly journals MRI: Modular reasoning about interference in incremental programming

2012 ◽  
Vol 22 (6) ◽  
pp. 797-852 ◽  
Author(s):  
BRUNO C. D. S. OLIVEIRA ◽  
TOM SCHRIJVERS ◽  
WILLIAM R. COOK
Keyword(s):  
Side Effects ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Hard Problem ◽  
Aspect Oriented Programming ◽  
Modular Reasoning ◽  
Data Flows ◽  
Tightly Coupled ◽  
Algebraic Laws ◽  
Program Components

AbstractIncremental Programming (IP) is a programming style in which new program components are defined as increments of other components. Examples of IP mechanisms include Object-oriented programming inheritance, aspect-oriented programming advice, and feature-oriented programming. A characteristic of IP mechanisms is that, while individual components can be independently defined, the composition of components makes those components become tightly coupled, sharing both control and data flows. This makes reasoning about IP mechanisms a notoriously hard problem: modular reasoning about a component becomes very difficult; and it is very hard to tell if two tightly coupled components interfere with each other's control and data flows. This paper presents modular reasoning about interference (MRI), a purely functional model of IP embedded in Haskell. MRI models inheritance with mixins and side effects with monads. It comes with a range of powerful reasoning techniques: equational reasoning, parametricity, and reasoning with algebraic laws about effectful operations. These techniques enable MRI in the presence of side effects. MRI formally captures harmlessness, a hard-to-formalize notion in the interference literature, in two theorems. We prove these theorems with a non-trivial combination of all three reasoning techniques.

Metrics Analysis in Object Oriented and Aspect Oriented Programming

2019 ◽  
Vol 13 (2) ◽  
pp. 117-122 ◽  
Author(s):  
Preeti Gulia ◽  
Manju Khari ◽  
Shrikant Patel
Keyword(s):  
Common Good ◽  
Design Patterns ◽  
Best Practice ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Aspect Oriented Programming ◽  
Multiple Points ◽  
Throughput Rate ◽  
Software Applications ◽  
Function Call

Background: Object oriented programming (OOP) is a programming paradigm that has been used for several years by the software engineering community. The best practice of OOP was gathered and they are known as Design Patterns. They provide guidelines for developing flexible software applications. Recent studies claim that some patterns have limitations and their implementations could be improved. Researchers claim that Aspect Oriented Programming (AOP) is a paradigm that provides features to overcome the limitations of OOP and patterns. However, even with the good results achieved using AOP, it is possible to cause side effects in code. We revised all patents relating to aspect oriented programming of applicability. This paper tries to implement a subset of the patterns with AOP and identify merits and demerits in comparison with the traditional OOP implementations. In another term if a method which is called several time in different class so we use to write code on both classes (if we don’t want to overload it) and manually write code of function call after those methods which we want to execute. Methods: Aspect-Oriented Programming entails breaking down program logic into distinct parts called so-called concerns. The functions that span multiple points of an application are called cross-cutting concerns and these cross-cutting concerns are conceptually separate from the application's business logic. There are various common good examples of aspects like logging, auditing, declarative transactions, security, and caching, etc. Results: after the implement AOP concept with OOPs, the response time is reduce and throughput rate is increases. And the development of program is become more easy and reliable. Conclusion: so those method which is called several time in a program execution these type of method must be written in AOP so it is triggered automatically when the pointcode if occurred.

Sign in / Sign up

Export Citation Format

Share Document