Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
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 * S T def * Definition body D Thing * Body B 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 S T Add D B usedThings = from EquationSystem through Expression to Variable Fig. Eq3 M1: Equation System EquationSystem equations Equation_List Ident * Equation lhs Variable Numerical rhs Expression * Simple args Expression_List op Compound S T Add D B 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..* Part lhs NonTerm S Concrete Abstract T D B 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..* Part lhs NonTerm S Concrete Abstract T D B 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.