Transcript Aspect-oriented programming

Aspect-oriented programming
Laura Ricci
A.A. 2001-2002
Index
 Introduction to AOP
 What are aspects?
 The role of aspects in software design
 AOP issues
 AspectJ
 What next?
Introduction

Currently, the dominant programming paradigm is
object-oriented programming that:
 has been presented as a technology that can
fundamentally aid software engineering
 is reflected in the entire spectrum of current
software development methodologies and tools

Object orientation is a clever idea, but has certain
limitations
Introduction

A new programming technique called aspect-oriented
programming (AOP):
 makes it possible to clearly express those programs
that OOP fail to support
 enables the modularization of crosscutting concerns
by supporting a new unit of sw modularity – aspects
– that provide encapsulation for crosscutting concerns
What are aspects?

The current working definition is (May 99, Gregor
Kiczales):
 modular units that cross-cut the structure of
other modular units
 units that is defined in terms of partial
information from other units
 exist in both design and implementation
Concerns



AOP is based on the idea that computer systems are
better programmed by separately specifying the
various concerns of a system
Separation of concerns is an important software
engineering principle guiding all stage of a sw
development methodology
Concerns:
 are properties or areas of interest
 can range from high-level notion ot low levelnotion
 can be functional or nonfunctional (systemic)
back
Example of crosscutting concerns
It is taken from C. of the ACM

Consider:
 the UML for a simple figure editor in which there
are two concrete classes of figure element, points
and lines
 the concern that the screen manager should be
notified whenever a figure element moves

This requires every method that moves a figure
element to do the notification
Example of crosscutting concerns
The red box is drawn
aroundinside
everyof nor
DisplayUpdating
fits neither
DisplayUpdating
cuts across
the other
boxes
method
that
must
implement
this
around the other boxes in the figure
concern
Display
*
Figure
Point
getX()
FigureElement
Line
2
getP1
getY()
setP1
setX(int)
setP1(Point)
setY(int)
setP2(Point)
DisplayUpdating
What are aspects?

Aspects are similar to classes because:
 have type
 can extend classes and other aspects
 can be abstract or concrete
 can have fields, methods, and types as
members
What are aspects?

Aspect are different than classes because:
 can additionally include as members pointcuts
(picks out join points), advice (code that executes
at each join point )
 do not have constructor or finalizer and they
cannot be created with the new operator
 priviliged aspects can access private members of
other types
What are aspect?


Aspects may arise at any stage of the software
lifecycle
Common example of crosscutting aspects are design
or architectural constraints, systemic properties or
behaviours and features
Examples of how aspects crosscut components
It is taken from AOP document
We wanted to implement a distributed digital library
that stores documents in many forms and provides a
wide range of operations on those documents
application
components
aspects
digital
database,
minimizing network
Library
printers,
traffic,
services
synchronization
constraints,
failure handling
Examples of how aspects crosscut components

There are several aspects of concerns, including:
 communication, by which we mean controlling the
amount of network bandwidth the application uses by
being careful about which objects get copied in remote
method calls
 coordination constraints, by which we mean the
synchronization rules require to ensure that the
component program behaves correctly
 failure handling, by which we mean handling the many
different forms of failure that can arise in a distributed
system
The role of aspects
in software design


AOP aims at providing better means of addressing
the well-known problem of separation of concerns
Three basic approaches to addressing the process of
separation of concerns:
 language-based
 framework-based
 architecture-oriented
Language-based approach



It is based on the definition of a set of language
constructs
Relevant concerns are identified at the problem
domain and translated to aspectual construct
The final application is obtained by weaving the
primary structure with the crosscutting aspects
Framework-based approach




Provides more flexible constructs
Concerns are materialized as aspectual classes at the
framework level
Developers can customize these aspects using the
mechanism supported by the framework
These types of framework are known as AO
frameworks (explicitly engineers concerns)
Architecture-oriented
approach



Early identification of concerns using architectural
organizational models
Architectural view-point involves a higher level of
abstraction than the previous approaches
It tipically comprises two stages
Architecture-oriented
approach

First, developers should determine the problem
architecture
Concerns are initially mapped to
architectural construct

Then, the approach enables several kinds of aspect
materialization through different frameworks
AOP technologies example
It is taken from C. of the ACM



Empirical analysis based on a simulation case study
of the temperature control system (TCS) of a
building ()
This comprises a building with rooms requiring
specific temperatures and a network consisting of
radiators, pipes and a boiler
To simulate TCS, a simple mathematical model of
temporal differential equations specifies the heat flow
among the different components
AOP technologies example
Relevant aspects in TCS
Aspect
Description
Relationships
Scheduling
It refers to how the simulated
entities should run
It works together with
synchronization
Synchronization
It basically involves access to
shared variables and race
condition
It works together
with scheduling
AOP technologies example

Four different groups of programmers implementing:
 typical OO view
 aspect language (AL)
 reflective AO framework (R-AO)
 event-based architectural framework (EBA)
AOP technologies example
 TCS evaluation according to the different implementation
 Analyzed features: scheduling and synchronization
 OO modeling: SS are scattered across the components
requiring these facilities (inheritance anomalies)
 EBA: SS are provided as built-in features in the
framework. It may be difficult to customize some of these
policies
 R-AO – AL: There are specific aspects dealing with SS.
They are kept separated, but some problems about the way
they interact (aspect composition) may arise
AOP technologies example


Several execution of the simulation programs are
maded
TCS performance with the different implementation:
 results were very similar except in the case of R-AO
 similarities found in the study seem to indicate that
both EBA and AL run almost like standard code
AOP technologies example
 To obtain a measure of the complexity of the
implementations, it is gathered code statistics (NCSS)
about:
 number of methods per class
 the NCSS per methods
 cyclomatic complexity (CNN per methods)
In particular, the best results were obtained with EBA (this
payoff comes mainly from the autonomy of component
and decoupling prescribed by framework).
The role of aspects
in software design
The central problem of aspect technologies,
whatever the approach we consider, is not just
about crosscutting or separation of concerns, but
it involves deeper research about how to
understand a number of software parts as
separated artifacts and then integrate some of
then into a coherent system
AOP issues


AOP must address both what the programmer can
say and how the computer system will realize the
program in a program system
AOP system:
 provides a way of expressing crosscutting concerns
 also ensures these mechanisms are conceptually
straighforward and have efficient implementations
AOP issues

How an AOP system specifies aspects:
 join points
 aspect parameterization

What composition mechanisms the system provides:
 dominant decomposition
 visibility
 mechanism provided
AOP issues

Implementation mechanisms:
 static/dinamic distinction
 modular compilation
 target representation

Software process:
 methodology or framework (the system provides for
organizing the system-building activity)
 reusability
 domain-specificity
AspectJ

Aspectj is:
 a general-purpose Ao extension to Java
 Java platform compatible
 easy to learn and use
 freely available under an Open Source license

Aspectj enables the modular implementation of a
wide range of crosscutting concerns
AspectJ



When written as an aspect the structure of a
crosscutting concern is explicit and easy to reason
about
Aspects are modular
AspectJ enables:
 name-based crosscutting (tend to affect a small
number of other classes)
 property-based crosscutting (range from small to
large scale)
AspectJ

Adoption of it into an existing project can be a
straightforward and incremental task:
 to begin with development aspects
 other paths are possible,depending on the needs
of the projects

The goals of the AspectJ project are to make AOP
technology available to a wide range of
programmers, to build and support an AspectJ user
community
Example
What next?



Software engineering researchers provide some help
to determine if it is beneficial for sw development
organization to adopt AOP for building their sw
products
A number of study have been conducted to asses the
usefulness of AOP
Two basic techniques for assessing a programming
technology:
 experiments
 case study
What next?

Three areas emerge as important in supporting the
use of AOP:
 exposing join points
 managing aspect interface
 structuring aspects
References
Communications of the ACM (October 2001-Volume 44,
Number 10)
AOP official web site:
 http://aosd.net/
AspectJ official web site:
 http://aspectj.org/
Sites from which you can find documents about conferences
and several informations:
 http://www.ccs.neu.edu/home/lieber/connection-to-aop.html
 http://www.cs.man.ac.uk/cnc/mscprojects/aspect/node1.htm
l
 http://www.cs.ubc.ca/labs/se/papers/1999/icse99-aop.html
 http://www.eclipse.net/~tomo/pisa/oopsla2000/p_netinant.h
tml

Crosscutting


Crosscutting is how to characterize a concern than
spans multiple units of OO modularity
Crosscutting concerns resist modularization using
normal OO construct
back
Pointcut


Picks out join points
Can be defined in classes or in aspects and can be
named or be anonymous
back
Advice


It is code that executes at each join point picked out
by pointcut
His power comes from the advice being able to
access value in the execution context of a pointcut
back
Join points


Are well-defined points in the execution of a program
Only those points that can be used in a disciplined
and principled manner
back
Framework


It is based on decomposition of aspects in system
design that consists of components, aspects, and
layers.
By separating the different aspects of each
component, we can separate components, aspects,
and layers from each other
back
AspectJ example
It is taken from C. of the ACM



An aspect is defined very much like a class and can
have methods, fielsd, constructors, initializers, named
pointcuts and advice
An example is tracing aspect that prints messages
before certain display operation
The overall effect of this aspect is to print a
descriptive message whenever the traced methods
are called
AspectJ example
Aspect SimpleTracing {
pointcut traced() :
Traced identifies calls to several
key methods on Display
call (void Display.update () ) ||
call (void Display.repaint (..) );
Before advice on this
pointcut uses a helper
method of the aspect
to print a message
before() : traced () {
Advice uses the
println(“Entering:” + thisJoinPoint); thisJoinPoint
special variable to
}
an object that
describes the
void println (String str) {
current join point
<write to appropriate stream> } }
back