1. Crosscutting Capabilities for Java and AspectJ through DJ
Demeter Team

2. Expanding Definitions
Strat: Literal | Intersection | Variable.
Literal = String.
Reduce to: Strat : Literal

3. Similar to: Expression evaluation
E : S | C.
S = int.
C = Op <arg1> E <arg2> E.
Op : A | M.
A = . M = .
Only want:
E : S.

4. Class graph: Find undefined things
Fig. UML1
Class graph: Find undefined things
definedThings
Ident
System *
Thing *
usedThings * *
def S T
Definition
body
Body D B
definedThings= from System bypassing Body to Thing
usedThings = from System through Body to Thing

5. M1: Equation System Fig. Eq1 EquationSystem equations Equation_List
Ident *
Variable
lhs
Equation
Numerical
rhs
Expression_List
Simple
args
Expression * op
Add
Compound

6. CS1: UML class diagram Grammar
Fig. G1
CS1: UML class diagram Grammar
0..*
Entry
EParse
entries
Grammar
BParse
Production
Body
rhs
parts
Part
lhs
0..*
NonTerm
Concrete
Abstract

7. YOUR PROJECT class graph

8. Java Program: Adaptive Method with DJ
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);
return (HashSet)v.getReturnValue(); }
repUndef is a
modular unit
of crosscutting
implementation.
Ad-hoc
implementation may
cut across
100 classes.
green: traversal
black bold: structure
purple: advice
red: parameters

9. Java Program: Adaptive 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.");
}}});} }

10. Control Tangling and Scattering of Class Structure, Traversals and Traversal Advice

11. 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.

12. overall graph: object structure; green graph: traversal; purple: advice
Why crosscutting?
r=0;
Route1:BusRoute
:BusList
buses
busStops
:BusStopList
Bus15:DieselPowered
passengers
CentralSquare:BusStop
waiting
:PersonList
:PersonList
Joan:Person
Paul:Person
Seema:Person
r++;
r++;
Eric:Person

13. 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

14. 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

15. Example Check whether all used entities are defined.
Object structure, traversal (basically an introduction), advice on traversal

16. Find undefined things definedThings System * Thing * usedThings * *
Definition
Body
definedThings= from System bypassing Body to Thing
usedThings = from System through Body to Thing

17. M1: Equation System Fig. Eq1 EquationSystem equations Equation_List
Ident *
Variable
lhs
Equation
Numerical
rhs
Expression_List
Simple
args
Expression * op
Add
Compound

18. Name map
Definition ClassDef Production Equation

19. 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).

20. 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 { } }

21. Collaboration with strategies
collaboration COLLECT {
role System {
out HashSet collect(){};
defined(){(uses collect, definedThings)};
used(){(uses collect, usedThings)};
in definedThings =
from System bypassing Body to Thing;
in usedThings =
from System through Body to Thing; }
role Body { }
role Thing { }
role Definition { } }

22. 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

23. 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 adaptive methods.
They cut across many classes in an ad-hoc implementation.

24. Java Program: Adaptive 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);
return (HashSet)v.getReturnValue(); }
green: traversal
black bold: structure
purple: advice
red: parameters

25. Java Program: Adaptive 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.");
}}});} }

26. After applying name map
For now we manually edit the Java program.

27. 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);
return (HashSet)v.getReturnValue(); }
green: traversal
black bold: structure
purple: advice
red: parameters

28. 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.");
}}});} }

29. 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.

30. CS1: UML class diagram ClassG
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

31. CS1:UML class diagram ClassG
usedThings = from ClassG through Body to ClassName
CS1:UML class diagram ClassG
0..*
Entry
EParse
entries
ClassG
BParse
ClassDef
Body
parts
Part
className
0..*
ClassName
Concrete
Abstract

32. M1: Equation System Fig. Eq1 EquationSystem equations Equation_List
Ident *
Variable
lhs
Equation
Numerical
rhs
Expression_List
Simple
args
Expression * op
Add
Compound

33. M1: Equation System definedThings = from EquationSystem Fig. Eq2
bypassing Expression to Variable
Fig. Eq2
M1: Equation System
EquationSystem
equations
Equation_List
Ident *
lhs
Equation
Variable
Numerical
rhs
Simple
args
Expression
Expression_List S T * op
Add
Compound D B

34. M1: Equation System usedThings = from EquationSystem Fig. Eq3
through Expression to Variable
Fig. Eq3
M1: Equation System
EquationSystem
equations
Equation_List
Ident *
lhs
Equation
Variable
Numerical
rhs
Simple
args
Expression
Expression_List S T * op
Add
Compound D B

35. Equation System Object
Fig. Eq4
Equation System Object
equations
es:EquationSystem
els:Equation_List
i1:Ident
lhs
e1:Equation
v1:Variable
rhs
i2:Ident
v2:Variable

36. M1: Equation System usedThings = from EquationSystem
through Expression to Variable
Example:
x = 1.0 .
y = (+ x 4.0).
z = (* x y).
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.

37. M1: Equation System definedThings= from EquationSystem
bypassing Expression to Variable
Example:
x = 1.0 .
y = (+ x 4.0).
z = (* x y).
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.

38. CS1: UML class diagram Grammar
Fig. G1
CS1: UML class diagram Grammar
0..*
Entry
EParse
entries
Grammar
BParse
Production
Body
rhs
parts
Part
lhs
0..*
NonTerm
Concrete
Abstract

39. CS1: UML class diagram Grammar
Fig. G2
definedThings = from Grammar bypassing Body to NonTerm
CS1: UML class diagram Grammar
0..*
Entry
EParse
entries
Grammar
BParse
Production
Body
rhs
parts
Part
lhs
0..*
NonTerm S T
Concrete
Abstract D B

40. CS1:UML class diagram Grammar
usedThings = from Grammar through Body to NonTerm
Fig. G3
CS1:UML class diagram Grammar
0..*
Entry
EParse
entries
Grammar
BParse
Production
Body
rhs
parts
Part
lhs
0..*
NonTerm S T
Concrete
Abstract D B

41. 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.

42. Context Switch Textbook and project: Chapter 7: Before The Project
Chapter 6: While You are Coding