Crosscutting Capabilities for Java and AspectJ through DJ Demeter Team

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

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

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

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

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

YOUR PROJECT class graph

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

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

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

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 :BusList buses busStops :BusStopList Bus15:DieselPowered passengers CentralSquare:BusStop waiting :PersonList :PersonList Joan:Person Paul:Person Seema:Person r++; 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 definedThings System * Thing * usedThings * * Definition Body definedThings= from System bypassing Body to Thing usedThings = from System through Body to Thing

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

Name map 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 { } }

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

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

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

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

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); return (HashSet)v.getReturnValue(); } green: traversal 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.

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

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

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

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

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

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

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.

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.

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

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

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

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.

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