Ian Sommerville 2006 Software Engineering, 8th edition.

Chapter 32 Slide 1
Aspect-oriented Software
Development 1
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 2
Objectives
To explain the principle of separation of concerns
in software development
To introduce the fundamental ideas underlying
aspect-oriented development
To show how an aspect-oriented approach can
be used at all stages of development
To discuss problems of testing aspect-oriented
systems
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 3
Aspect-oriented software development
An approach to software development based
around a new type of abstraction - an aspect.
Used in conjunction with other approaches -
normally object-oriented software engineering.
Aspects encapsulate functionality that cross-cuts
and co-exists with other functionality.
Aspects include a definition of where they should
be included in a program as well as code
implementing the cross-cutting concern.
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 4
The separation of concerns
The principle of separation of concerns states
that software should be organised so that each
program element does one thing and one thing
only.
Each program element should therefore be
understandable without reference to other
elements.
Program abstractions (subroutines, procedures,
objects, etc.) support the separation of concerns.
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 5
Concerns
Concerns are not program issues but reflect the system
requirements and the priorities of the system
stakeholders.
Examples of concerns are performance, security, specific
functionality, etc.
By reflecting the separation of concerns in a program,
there is clear traceability from requirements to
implementation.
Core concerns are the functional concerns that relate to
the primary purpose of a system; secondary concerns
are functional concerns that reflect non-functional and
QoS requirements.
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 6
Stakeholder concerns
Functional concerns which are related to specific functionality to be
included in a system.
Quality of service concerns which are related to the non-functional
behaviour of a system.
Policy concerns which are related to the overall policies that govern
the use of the system.
System concerns which are related to attributes of the system as a
whole such as its maintainability or its configurability.
Organisational concerns which are related to organisational goals
and priorities such as producing a system within budget, making use
of existing software assets or maintaining the reputation of an
organisation.
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 7
Cross-cutting concerns
Cross-cutting concerns are concerns whose
implementation cuts across a number of program
components.
This results in problems when changes to the
concern have to be made - the code to be
changed is not localised but is in different places
across the system.
Cross cutting concerns lead to tangling and
scattering.
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 8
Cross-cutting concerns
Securit y req.
Recovery req.
Core concerns
New cust omer
req.
Cust omer
management req.
Account
req.
Cross-cut ti ng
concerns
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 9
Tangling
synchroni zed voi d put (SensorRecord rec ) throws InterruptedExcepti on
{
i f ( numberOfEntri es == bufsi ze)
wai t () ;
store [back] = new SensorRecord (rec.sensorId, rec.sensor Val ) ;
back = back + 1 ;
i f (back == bufsi ze)
back = 0 ;
numberOfEntri es = numberOfEntri es + 1 ;
noti fy () ;
} // put
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 10
Scattering
Pati ent
get Name ()
edi tName ()
get Address ()
edi tAddress ()
...
anonymise ()
...
<at tri but e decl s>
Image
get Modal it y ()
archi ve ()
get Dat e ()
edi tDat e ()
...
saveDi agnosi s ()
saveType ()
...
<at tri but e decl s>
Consul tat ion
makeAppoi nt ()
cancelAppoint ()
assignNurse ()
bookEqui p ()
...
anonymise ()
saveConsul t ()
...
<at tri but e decl s>
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 11
Aspects, join points and pointcuts
An aspect is an abstraction which implements a
concern. It includes information where it should
be included in a program.
A join point is a place in a program where an
aspect may be included (woven).
A pointcut defines where (at which join points)
the aspect will be included in the program.
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 12
Aspect terminology
Term Defi ni ti on
advice The code implementing a concern.
aspect A program abst r action t hat defines a cross-cutting
concern. It includes t he definit ion of a pointcut and
t he advice associated with t hat concern.
join point An event in an executing program where the advice
associat ed wit h an aspect may be execut ed.
join point model The set of event s t hat may be referenced in a
pointcut .
pointcut A statement , included in an aspect , t hat defines the
join points where t he associat ed aspect advice
should be execut ed.
weaving The incorporation of advice code at t he specified
join points by an aspect weaver.

Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 13
An authentication aspect
aspect authentication
{
before: call (public void update* (..)) // this is a pointcut
{
// this is the advice that should be executed when woven into
// the executing system
int tries = 0 ;
string userPassword = Password.Get ( tries ) ;
while (tries < 3 && userPassword != thisUser.password ( ) )
{
// allow 3 tries to get the password right
tries = tries + 1 ;
userPassword = Password.Get ( tries ) ;
}
if (userPassword != thisUser.password ( )) then
//if password wrong, assume user has forgotten to logout
System.Logout (thisUser.uid) ;
}
} // authentication
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 14
AspectJ - join point model
Call events
Calls to a method or constructor
Execution events
Execution of a method or constructor
Initialisation events
Class or object initialisation
Data events
Accessing or updating a field
Exception events
The handling of an exception
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 15
Pointcuts
Identifies the specific events with which advice
should be associated.
Examples of contexts where advice can be
woven into a program
Before the execution of a specific method
After the normal or exceptional return from a method
When a field in an object is modified
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 16
Aspect weaving
Aspect weavers process source code and weave
the aspects into the program at the specified
pointcuts.
Three approaches to aspect weaving
Source code pre-processing
Link-time weaving
Dynamic, execution-time weaving
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 17
Aspect weaving
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 18
Software engineering with aspects
Aspects were introduced as a programming
concept but, as the notion of concerns comes
from requirements, an aspect oriented approach
can be adopted at all stages in the system
development process.
The architecture of an aspect-oriented system is
based around a core system plus extensions.
The core system implements the primary
concerns. Extensions implement secondary and
cross-cutting concerns.
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 19
Core system + extensions
Core syst em
Ext 2 Ext 1
Ext 3
Ext 4 Ext 5 Ext 6
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 20
Types of extension
Secondary functional extensions
Add extra functional capabilities to the core system
Policy extensions
Add functional capabilities to support an organisational policy
such as security
QoS extensions
Add functional capabilities to help attain quality of service
requirements
Infrastructure extensions
Add functional capabilities to support the implementation of the
system on some platform
Ian Sommerville 2006 Software Engineering, 8th edition. Chapter 32 Slide 21
Key points
The key benefit of an aspect-oriented approach
is that it supports the separation of concerns.
Tangling occurs when a module implements
several requirements; Scattering occurs when
the implementation of a single concern is spread
across several components.
Systems may be designed as a core system with
extensions to implement secondary concerns.