1. Better Separation of Crosscutting Concerns with Aspectual Components
Karl Lieberherr
College of Computer Science
Demeter Team
Northeastern University, Boston
We focus on traversal-related concerns. Those are concerns that involve a group of connected objects that we traverse and manipulate to implement a behavior. Those concerns cut across multiple classes and are very common. Following the ideas of Aspect-Oriented Programming (AOP), we would like to encapsulate a traversal-related concern into an aspect. Doing this in the straight-forward way leads to reduced scattering, but often results in an aspect that is tangled with accidental structural information. We notice a tradeoff between reducing scattering across classes and increasing tangling of structural information in the aspect.
We find a fundamental improvement to this tradeoff by using ideas from non-deterministic finite automata theory to reduce both scattering and tangling. The well localized traversal-related aspects can all be written in plain Java using basically three classes from the Java package DJ. We explain the basics of DJ and how you can use it to better structure your Java programs.
2/5/2019
Aspectual Components

2. Team with Professors Felleisen, Lorenz, Wand Ph.D. students:
Doug Orleans,
Johan Ovlinger
Therapon Skotiniotis
Pengcheng Wu
2/5/2019
Aspectual Components

3. Overview
Aspect-Oriented Programming (AOP): Crosscutting concerns, controlling tangling and scattering.
Example: Collect entities.
Aspectual Components + DJ
Comparison to AspectJ
Summary
2/5/2019
Aspectual Components

4. Message AOP is useful and has a long history at NU
Aspectual components, an AOP mechanism, are useful
Adaptive Programming mechanisms must be used to properly express traversal-related aspects
2/5/2019
Aspectual Components

5. The MIT Technology Review (Jan./Feb. 2001 issue)
Ten emerging technologies that will change the world
Untangling Code - Aspect-Oriented Programming (AOP)
Data Mining
Micro Fluids
Robot Design
...
2/5/2019
Aspectual Components

6. Northeastern Connection
Crista Lopes wrote the first Ph.D. Thesis on AOP at Northeastern supported by Xerox PARC. Gregor Kiczales co-advisor.
The Demeter Research Group worked with interesting AOP Systems long before the name AOP was invented.
2/5/2019
Aspectual Components

7. Quote: MIT Technology Magazine
“The idea of aspects has been around for many years and with many different names. It is called adaptive programming at Northeastern University, and subject-oriented programming at IBM, …”
2/5/2019
Aspectual Components

8. AOP: not every concern fits into a component: crosscutting
Goal: find new component structures that encapsulate “rich” concerns
2/5/2019
Aspectual Components

9. AOP Crosscutting concerns
Example: Logging: record every operation an application performs
“When adding a new operation to this application, always put a trace statement in”
Keeping track of crosscutting concerns is error-prone
2/5/2019
Aspectual Components

10. AOP
Crosscutting concerns, when implemented in an ad-hoc way, lead to a lot of tangling and scattering in the program.
Goal of AOP is to control the tangling and scattering in the program.
2/5/2019
Aspectual Components

11. Tangling: count color changes
ordinary program
better program
structure-shy
functionality
Component 1
structure
Component 2
avoid tangled programs
AOP
synchronization
Component 3
2/5/2019
Aspectual Components

12. Scattering: count number of components to which color goes
ordinary program
better program
structure-shy
functionality
CM1
Concern 1
structure
CM2
Concern 2
avoid tangled programs
AOP
CM3
synchronization
Concern 3
2/5/2019
Aspectual Components

13. Aspect-Oriented Programming: Example
Separating the following crosscutting concerns:
Object Structure concern (JAXB, optional package for Java 2 platform, XML schema; UML class graph)
Traversal-related concerns: traverse a group of connected objects and execute code attached to nodes and edges of object graph (advice).
separate traversals and advice
Those two kinds of concerns appear frequently.
2/5/2019
Aspectual Components

14. Crosscutting in Equation System
overall graph: object structure; green graph: traversal; purple: advice
usedThings = from EquationSystem through Expression to Variable
Crosscutting in Equation System
equations
es:EquationSystem
els:Equation_List
new HashSet
i1:Ident
lhs
e1:Equation
v1:Variable
Object graph
rhs
els:Expression_List
c1:Compound
i2:Ident
v2:Variable
a1:Add
add
i3:Ident
v3:Variable
add
2/5/2019
Aspectual Components

15. What is a component?
any identifiable slice of behaviour that delivers a meaningful service, involving in general several participants,
used via well-defined interfaces,
formulated for an ideal ontology
can be deployed into a concrete ontology,
is subject to composition by 3rd parties (black-box reuse)
is subject to refinement by 3rd parties (white-box reuse)
2/5/2019
Aspectual Components

16. Aspectual Component + ... Class Graph expected interfaces
minimal
assumptions on
application structure +
Class Graph P1 P3 P2
Behavior Definition P P1
before / around
after
provided =
everything public
written to the CG similar to an OO program is written
to a concrete class graph
meth
1,1
...
meth
1,k P3
enhancements =
before/around/after +
provided
meth
3,1
...
meth
3,j
before / around
after

17. M1: Equation System EquationSystem equations Equation_List Ident *
Variable
lhs
Equation
Numerical
rhs
Expression_List
Simple
args
Expression * op
Add
Compound
2/5/2019
Aspectual Components

18. Collect Things definedThings System * Thing * usedThings * *
Definition
Body
definedThings = from System bypassing Body to Thing
usedThings = from System through Body to Thing
= from System + constraint + to Thing
2/5/2019
Aspectual Components

19. M1: Equation System EquationSystem equations Equation_List Ident * lhs
definedThings = from EquationSystem bypassing Expression to Variable
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
2/5/2019
Aspectual Components

20. M1: Equation System EquationSystem equations Equation_List Ident * lhs
usedThings = from EquationSystem through Expression to Variable
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
2/5/2019
Aspectual Components

21. Aspectual Component component COLLECT { participant Source {
expected static ClassGraph cg;
public HashSet collect(String constraint){
String id = “from Target to edu.neu.ccs.demeter.Ident”;
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;}};
Source.cg.traverse(this,
“from Source” + constraint + “to Target”, v};
participant Target { } }
2/5/2019
Aspectual Components

22. Aspectual Component
Find appropriate class graph and traversals for task at hand
Simplify from graph with 11 nodes to graph with 4 nodes to graph with two nodes.
2/5/2019
Aspectual Components

23. Adapter part // EquationSystem class graph attach COLLECT {
EquationSystem += Source with {
provide EquationSystem::cg to
Source::cg; }
Variable += Target }
2/5/2019
Aspectual Components

24. Java code green: traversal black bold: structure purple: advice
class System{
String id = “from Thing to edu.neu.ccs.demeter.Ident”;
HashSet collect(ClassGraph cg, String constraint){
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,“from System”+constraint+“to Thing”, v);
return (HashSet)v.getReturnValue(); }
HashSet defined(ClassGraph cg){
return (HashSet) this.collect(cg, “bypassing Body” );}
HashSet used(ClassGraph cg){
return (HashSet) this.collect(cg, “through Body” );}}
green: traversal
black bold: structure
purple: advice
red: parameters
2/5/2019
Aspectual Components

25. Ad-hoc Implementation of traversal-related concerns
Leads to lots of tangled and scattered code with numerous disadvantages
The question is not how to eliminate the tangling but how to reduce it
AOP is about tangling control of the implementation of crosscutting concerns
Crosscutting will always lead to some tangling at code level
2/5/2019
Aspectual Components

26. Need more than localization of crosscutting concerns
If we localize a crosscutting traversal-related concern in the standard way, we get a method that violates the Law of Demeter
In addition: Use traversal strategies to eliminate accidental noise in class graph
Need AP to improve AOP
2/5/2019
Aspectual Components

27. AspectJ (Xerox PARC)
A general aspect-oriented programming language for Java.
An aspect is like a class and may contain pointcut definitions defining a set of join points and advice saying what to do before, after or instead of the join points.
2/5/2019
Aspectual Components

28. DJ (Northeastern)
Is a Java package that supports AOP for traversal-related concerns.
Connection to AspectJ: both can be used simultaneously.
DJ provides an implementation of Adaptive Programming (AP).
2/5/2019
Aspectual Components

29. AspectJ (Xerox) DJ (NEU)
Abstract pointcut
set of execution points
where to watch
Advice
what to do
Concrete pointcut
set notation using regular expressions
Abstract object slice
set of entry/exit points
where to go
Visitor
what to do
Actual object slice
traversal strategies
2/5/2019
Aspectual Components

30. Concepts needed (DJ classes)
ClassGraph
Strategy (= Java String = traversal strategy)
Visitor
2/5/2019
Aspectual Components

31. Strategy ClassGraph Object Adaptive Programming is use-case based
Bold names
refer to DJ
classes.
is use-case based
abstraction of
ClassGraph
New: abstractions of class diagrams
notice affinity to design patterns: some of them also talk about families
of class structures
explain strategies
defines family of
Object
2/5/2019
Aspectual Components

32. Strategy Object Adaptive Programming defines traversals of 2/5/2019
explain strategies
2/5/2019
Aspectual Components

33. Strategy Visitor Adaptive Programming guides and informs 2/5/2019
explain strategies
Visitor
2/5/2019
Aspectual Components

34. AOP AP
Program with aspects that correspond to the concerns of the programmer.
Relieve the programmer from the details of some concern.
Create robustness to changes in an aspect.
AP is about join point reduction.
Example: structure-shyness
2/5/2019
Aspectual Components

35. Benefits of Adaptive Programming
robustness to changes
shorter programs
design matches program,
more understandable code
partially automated evolution
keep all benefits of OO technology
improved productivity
ideas can be used without tools
Applicable to design and documentation
of your current systems.
2/5/2019
Aspectual Components

36. Summary
AOP getting a lot of attention. Addresses an important problem: how to program crosscutting concerns.
AP is about relieving the programmer from the details of a concern: traditionally from the structural concern.
2/5/2019
Aspectual Components

37. Summary We view components as slices of behavior Aspectual components
reconcile between functional and object decomposition
add new behavior and modify existing behavior
are a good model for AOP
2/5/2019
Aspectual Components