the presentation is about the aspect oriented programming its benefits and how is it different from object oriented programming.

1. PERFORMANCE ANALYSIS OF
SYNCHRONISATION PROBLEM USING ASPECT
ORIENTED PROGRAMMING
Submitted by:-
Harshit monish
9911103466
F-4

2. OVERVIEW
 Cross Cutting Concerns
 Logging
 Producer Consumer problem(synchronization)
 The cost of tangled code
 Aspect Oriented Programming
 Development stage
 Terminology
 Aop benefits and oop shortcomings
 Producer Consumer problem

3. CROSS CUTTING CONCERNS:-
 What is a crosscutting concern?
 Behavior that cuts across the typical divisions of
responsibility, such as logging or debugging
 A problem which a program tries to solve.
 Aspects of a program that do not relate to the core
concerns directly, but which proper program execution
nevertheless requires

4. Function
Requirements
Non-Functional
Requirements
Production
Code
=+

5. CROSS CUTTING CONCERNS:-
 Examples
 Synchronisation
 Logging
 Authorisation
 Exception handling

6. LOGGING WITHOUT AOP

7. LOGGING WITH AOP

8. PRODUCER CONSUMER PROBLEM

9. TWO PROBLEMS AOP TRIES TO SOLVE

10. TWO PROBLEMS AOP TRIES TO SOLVE

11. THE COST OF TANGLED CODE
 redundant code
 same fragment of code in many places
 difficult to reason about
 non-explicit structure
 the big picture of the tangling isn’t clear
 difficult to change
 have to find all the code involved
 and be sure to change it consistently
 Poor traceability
 Lower productivity
 Less code reuse
 Harder refactoring

12. ASPECT ORIENTED PROGRAMMING
 AOP is a programming paradigm which aims to
increase modularity by allowing the separation of
cross-cutting concerns
 In AOP crosscutting concerns are implemented in
aspects instead of fusing them into core modules.
 Aspects can be reused.
 By reducing code tangling it makes it easier to
understand what the core functionality of a module
is.
 An “aspect weaver” takes the aspects and the core
modules and composes the final system

13. Coding is
HARD
AOP
makes it
EASY

14. AOP DEVELOPMENT STAGES
Integrating all
concerns
Identify concerns

15. What’s in it for YOU?

16. BENEFITS
 Write less code
 Read less code
 More concise and easy to understand
 More maintainable
 Fewer code =
 Less boilerplate code
 More interesting work
 Increased attention
 More PRODUCTIVITY!
FEWER DEFECTS!

17. TERMINOLOGY
 Cross-cutting – Identify areas of code
where common functionality exists
 Advice – The code to be injected
 Joinpoint – Where one or more aspects
can be applied
 Pointcut – A collection of joinpoints
 Aspect – General term for where advice
and point-cuts are combined

18. TERMINOLOGY
 Weaving – Integrating applications and
aspects (e.g. AspectJ is an “aspect weaver”)
 Compile-time – Can produce integrated source-
code, but typically only produces woven byte-
code.
 Run-time – Aspects are applied “on the fly”
(typically when classes are loaded)

19. OOP SHORTCOMINGS
 OOP allows to decompose a system into units of
function or behavior
 Certain software properties cannot be isolated in single
functional unit, instead they crosscut multiple
components
 Such crosscutting concerns result in tangled code that is
hard to develop and maintain

20. AOP BENEFITS
 Separation of components and aspects
 Better understanding of software
because of high level of abstraction
 Easier development and maintenance
because tangling of code is prevented
 Increased potential for reuse for both components as well as
aspects

21.  AOP breaks encapsulation in a controlled
manner.
 Encapsulation is broken between classes and
aspects.
 Aspects marked as privileged have access to the
private members of a class.
 Encapsulation is preserved between classes.
 An aspect encapsulates a crosscutting concern.
WHAT ABOUT ENCAPSULATION?

22. PROBLEM DESCRIPTION
 Question: ''How to enforce synchronization policies with
AOP?''
 Suppose multiple objects are concurrently working on
some shared data and exclusive access is needed for
modification
 All objects that are working on the data must be
synchronized, for example by locking the shared data
temporarily

23. PROBLEM DESCRIPTION
 Question: ''How to enforce synchronization policies with
AOP?''
 Suppose multiple objects are concurrently working on
some shared data and exclusive access is needed for
modification
 All objects that are working on the data must be
synchronized, for example by locking the shared data
temporarily

24. OBSERVATION
 Without AOP
 Every component that works on the shared data must take
care of the locking itself, leading to tangled and complex code
 With AOP
 The locking aspect is separated from the components by
means of an aspect module, resulting in usual benefits of
modularization

25. THE PRODUCER CONSUMER ASPECT