Transcript crosscut-3360

Slides for Gregor Kiczales
• Two versions
– short version: Crosscutting capabilities for Java
and AspectJ through DJ (4 viewgraphs only)
– long version: Controlling tangling and
scattering ...
Crosscutting Capabilities for Java
and AspectJ through DJ
Demeter Team
Fig. UML1
Class graph:
Find undefined things
System
Ident
definedThings
*
usedThings *
def
*
Definition
body
Thing
*
Body
definedThings= from System bypassing Body to Thing
usedThings = from System through Body to Thing
Java Program: Aspectual Method
with DJ
class System{
String id = “from Thing to edu.neu.ccs.demeter.Ident”;
void repUndef(ClassGraph cg){
repUndef is a
checkDefined(cg, getDefThings(cg));}
modular unit
HashSet getDefThings(ClassGraph cg){
of crosscutting
String definedThings =
implementation.
"from System bypassing Body to Thing";
Ad-hoc
Visitor v = new Visitor(){
implementation may
HashSet return_val = new HashSet();
cut across
void before(Thing v1){
100 classes.
return_val.add(cg.fetch(v1, id) );}
public Object getReturnValue(){return return_val;}};
cg.traverse(this, definedThings, v); green: traversal
return (HashSet)v.getReturnValue();
black bold: structure
}
purple: advice
red: parameters
Java Program: Aspectual Method
with DJ
void checkDefined(ClassGraph cg, final HashSet classHash){
String usedThings =
”from System through Body to Thing";
cg.traverse(this, usedThings, new Visitor(){
void before(Thing v){ Ident vn = cg.fetch(v, vi);
if (!classHash.contains(vn)){
System.out.println("The object "+ vn
+ " is undefined.");
}}});}
}
What DJ adds to AspectJ
• Point cut definitions based on connectivity
in class graph.
• Define point cuts by specifying a (traversal)
program based on class graph.
• Point cut reduction (high-level point cut
designator): free programmer from details
of class graph. Free programmer from
detail of some aspect.
Control Tangling and Scattering
of Class Structure, Traversals and
Traversal Advice
Feb. PI Meeting
Aspect-Oriented Programming
• Separating the following cross-cutting
concerns:
–
–
–
–
Object Structure
Traversals through Objects
Advice on Traversals
New behaviors based on collaborating objects
• Focus on those four concerns only. They
appear frequently.
overall graph: object structure; green graph: traversal; purple: advice
Why crosscutting?
r=0;
Route1:BusRoute
busStops
buses
:BusList
:BusStopList
CentralSquare:BusStop
waiting
:PersonList
Bus15:DieselPowered
passengers
:PersonList
Joan:Person
Paul:Person
r++;
Seema:Person
r++;
Eric:Person
Why aspects: Oblivious
• Object Structure
– does not have to know about traversals and
advice on traversals
• Traversals
– don’t have to know about advice on traversals
• Advice on Traversals
– has to know minimally about object structure
and traversals
Ad-hoc Implementation
of three concerns
• Leads to lots of tangled code with numerous
disadvantages
• The question is not how to eliminate the
tangling but how to reduce it
• AOP is about tangling control the
implementation of crosscutting concerns
• Crosscutting will always lead to some
tangling at code level
Example
• Check whether all used entities are defined.
• Object structure, traversal (basically an
introduction), advice on traversal
Find undefined things
System
definedThings
*
usedThings *
*
Definition
Thing
*
Body
definedThings= from System bypassing Body to Thing
usedThings = from System through Body to Thing
Name map
Roles
CS1
CS2
M1
System
ClassG
Grammar
EquationSystem
Body
Body
Body
Expression
Thing
ClassName
NonTerm
Variable
Definition
ClassDef
Production
Equation
High-level description
• It is useful to have a high-level description
of the collaboration besides the Java source
code. Useful documentation.
• Ultimately we are interested in the
executable form of the collaboration (Java
source code).
Collaboration with strategies
collaboration checkDef {
role System {
out repUndef(){(uses getDefThings, checkDefined)};
getDefThings(){(uses definedThings)};
checkDefined(){(uses usedThings)};
in definedThings =
from System bypassing Body to Thing;
in usedThings =
from System through Body to Thing; }
role Body { }
role Thing { }
role Definition { }
}
Use of collaboration: Adapter
Need to provide the expected methods (in methods) and provide name map.
• name map:
–
–
–
–
System : EquationSystem
Definition : Equation
Body : Expression
Thing : Variable
• expected methods:
– in definedThings // use default
– in usedThings // use default
What is an aspect?
• An aspect is a modular unit of crosscutting
implementation.
• A Java method is a modular unit.
• Can we make a Java method an aspect?
• Yes, we call such methods aspectual
methods.
• They cut across many classes in an ad-hoc
implementation.
Java Program: Aspectual Method
class System{
String id = “from Thing to edu.neu.ccs.demeter.Ident”;
void repUndef(ClassGraph cg){
checkDefined(cg, getDefThings(cg));}
HashSet getDefThings(ClassGraph cg){
String definedThings =
"from System bypassing Body to Thing";
Visitor v = new Visitor(){
HashSet return_val = new HashSet();
void before(Thing v1){
return_val.add(cg.fetch(v1, id) );}
public Object getReturnValue(){return return_val;}};
cg.traverse(this, definedThings, v); green: traversal
return (HashSet)v.getReturnValue();
black bold: structure
}
purple: advice
red: parameters
Java Program: Aspectual Method
void checkDefined(ClassGraph cg, final HashSet classHash){
String usedThings =
”from System through Body to Thing";
cg.traverse(this, usedThings, new Visitor(){
void before(Thing v){ Ident vn = cg.fetch(v, id);
if (!classHash.contains(vn)){
System.out.println("The object "+ vn
+ " is undefined.");
}}});}
}
After applying name map
• For now we manually edit the Java
program.
Java Program with less tangling
class EquationSystem{
String id = “from Variable to edu.neu.ccs.demeter.Ident”;
void repUndef(ClassGraph cg){
checkDefined(cg, getDefThings(cg));}
HashSet getDefThings(ClassGraph cg){
String definedThings =
"from EquationSystem bypassing Expression to Variable";
Visitor v = new Visitor(){
HashSet return_val = new HashSet();
void before(Variable v1){
return_val.add(cg.fetch(v1, id) );}
public Object getReturnValue(){return return_val;}};
cg.traverse(this, definedThings, v); green: traversal
return (HashSet)v.getReturnValue();
black bold: structure
}
purple: advice
red: parameters
Java Program with less tangling
void checkDefined(ClassGraph cg, final HashSet classHash){
String usedThings =
”from EquationSystem through Expression to Variable";
cg.traverse(this, usedThings, new Visitor(){
void before(Variable v){ Ident vn = cg.fetch(v, id);
if (!classHash.contains(vn)){
System.out.println("The object "+ vn
+ " is undefined.");
}}});}
}
Tangling is localized
Scattering eliminated
• Instead of having code spread across several
classes, it is localized in one class.
• Java program is describing the abstract
pattern behind the computation of interest:
checking whether used entities are defined.
• Tangling control through abstraction of
patterns. We abstract away from structure.
definedThings = from ClassG bypassing Body to ClassName
CS1: UML class diagram ClassG
0..*
Entry
EParse
entries
ClassG
BParse
ClassDef
Body
parts
Part
className
0..*
ClassName
Concrete
Abstract
usedThings = from ClassG through Body to ClassName
CS1:UML class diagram ClassG
0..*
Entry
EParse
entries
ClassG
BParse
ClassDef
Body
parts
0..*
Concrete
Abstract
Part
className
ClassName
Fig. Eq1
M1: Equation System
EquationSystem
equations
Equation_List
Ident
*
Variable
lhs
Equation
Numerical
rhs
Expression
Expression_List
Simple
args
*
op
Compound
Add
definedThings = from EquationSystem Fig. Eq2
bypassing Expression to Variable
M1: Equation System
EquationSystem
equations
Equation_List
Ident
*
Equation
lhs
Variable
Numerical
rhs
Expression
*
Simple
args
Expression_List
op
Compound
Add
usedThings = from EquationSystem
through Expression to Variable
M1: Equation System
EquationSystem
equations
Equation_List
Ident
*
Equation
lhs
Variable
Numerical
rhs
Expression
*
Fig. Eq3
Simple
args
Expression_List
op
Compound
Add
Fig. Eq4
Equation System Object
equations
es:EquationSystem
els:Equation_List
i1:Ident
e1:Equation
lhs
rhs
v2:Variable
i2:Ident
v1:Variable
Example:
x = 1.0 .
y = (+ x 4.0).
z = (* x y).
usedThings = from EquationSystem
through Expression to Variable
M1: Equation System
EquationSystem = <equations> List(Equation).
Equation = <lhs> Variable “=“ <rhs> Expression “.”.
Variable = Ident.
Expression : Simple | Compound.
Simple : Variable | Numerical.
Compound = “(“ Op <args> List(Expression) “)”.
Op : Add | Mul.
Add = “+”.
Mul = “*”.
Numerical = float.
Example:
x = 1.0 .
y = (+ x 4.0).
z = (* x y).
definedThings= from EquationSystem
bypassing Expression to Variable
M1: Equation System
EquationSystem = <equations> List(Equation).
Equation = <lhs> Variable “=“ <rhs> Expression “.”.
Variable = Ident.
Expression : Simple | Compound.
Simple : Variable | Numerical.
Compound = “(“ Op <args> List(Expression) “)”.
Op : Add | Mul.
Add = “+”.
Mul = “*”.
Numerical = float.
Fig. G1
CS1: UML class diagram Grammar
0..*
Entry
EParse
entries
Grammar
BParse
Production
Body
rhs
parts
0..*
Concrete
Abstract
Part
lhs
NonTerm
definedThings = from Grammar bypassing Body to NonTerm
Fig. G2
CS1: UML class diagram Grammar
0..*
Entry
EParse
entries
Grammar
BParse
Production
Body
rhs
parts
0..*
Concrete
Abstract
Part
lhs
NonTerm
usedThings = from Grammar through Body to NonTerm
Fig. G3
CS1:UML class diagram Grammar
0..*
Entry
EParse
entries
Grammar
BParse
Production
Body
rhs
parts
0..*
Concrete
Abstract
Part
lhs
NonTerm
DJ
• Is a Java package that supports AOP for the
three concerns: class structure, traversals,
and traversal advice.
• Tested by 50+ users.
• Connection to AspectJ: both can be used
simultaneously.
Concepts needed
(DJ classes)
•
•
•
•
•
ClassGraph
Strategy
ObjectGraph
ObjectGraphSlice
Visitor
Adaptive Programming
Bold names
refer to DJ
classes.
Strategy
is use-case based
abstraction of
ClassGraph
defines family of
ObjectGraph
Adaptive Programming
Strategy
defines traversals
of
ObjectGraph
plus Strategy
defines
ObjectGraphSlice
Adaptive Programming
Visitor
advises
Traversal
AspectJ (Xerox)
• Abstract pointcut
– set of execution points
– where to watch
• Advice
– what to do
• Concrete pointcut
– set notation using
regular expressions
DJ (NEU)
• Abstract object slice
– set of entry/exit points
– where to go
• Visitor
– what to do
• Actual object slice
– traversal strategies
AOP
• Program with aspects
that correspond to the
concerns of the
programmer.
AP
• Relieve the programmer
from the details of some
concern.
• Create robustness to
changes in an aspect.
• AP is about point cut
reduction.
• Example: structureshyness
Technology Evolution
Object-Oriented Programming
Other
Technologies
Tangled structure/behaviors
robustness to structure changes
Adaptive Programming
Tangled concerns in general
(synchronization, etc.)
Aspect-Oriented Programming
robustness to aspect changes
Aspect-Oriented Programming II
What DJ adds to AspectJ
• Point cut definitions based on connectivity
in class graph.
• Define point cuts by specifying a (traversal)
program based on class graph.
• Point cut reduction (high-level point cut
designator): free programmer from details
of class graph.