1. UCI Feb 031 Adaptive Aspect-Oriented Programming in AspectJ Karl J. Lieberherr Northeastern University Joint work of Demeter Research Group

2. UCI Feb 032 Overview What is “adaptive programming”? Examples in AspectJ. What is behind adaptiveness in AspectJ? Why we need more adaptiveness in AspectJ. DAJ: a simple adaptive add-on to AspectJ. Abstraction behind “more adaptiveness” LoD in AspectJ (adapts to any Java program) Conclusions

3. UCI Feb 033 Adaptive? A program is adaptive if it changes its behavior according to its context. Adaptive programs: Concurrency policy, Distribution policy, Logging Aspect, Adaptive Method, Law of Demeter Checker in AspectJ Possible contexts –Java program or its execution tree –UML class diagram or object diagram

4. UCI Feb 034 What is the role of adaptive features in AOP They become increasingly more important as AOP is applied to larger problems. Encapsulating an aspect without abstracting over the relevant join points leads to brittle code. AspectJ has many adaptive features but more is needed.

5. UCI Feb 035 Adaptive Aspects abstract public aspect RemoteExceptionLogging { abstract pointcut logPoint(); after() throwing (RemoteException e): logPoint() { log.println(“Remote call failed in: ” + thisJoinPoint.toString() + “(” + e + “).”); } public aspect MyRMILogging extends RemoteExceptionLogging { pointcut logPoint(): call(* RegistryServer.*.*(..)) || call(private * RMIMessageBrokerImpl.*.*(..)); } abstract AspectJ team slide

6. UCI Feb 036 A Different Kind of Adaptive Aspect abstract aspect CapabilityChecking { pointcut invocations(Caller c): this(c) && call(void Service.doService(String)); pointcut workPoints(Worker w): target(w) && call(void Worker.doTask(Task)); pointcut perCallerWork(Caller c, Worker w): cflow(invocations(c)) && workPoints(w); before (Caller c, Worker w): perCallerWork(c, w) { w.checkCapabilities(c); } AspectJ team slide

7. UCI Feb 037 A more complex adaptive aspect: Law of Demeter Checker (Object Form) aspect Check { … after(): Any.MethodCall{ // call (* *(..)); // check whether // thisJoinPoint.getTarget() // is a preferred supplier // object }

8. UCI Feb 038 Observation 1 Many AspectJ programs are adaptive (designed for a family of Java programs) –Context: Java program or its execution tree (lexical joinpoints or dynamic join points) Features enabling adaptiveness: –*,.. (wildcards) –cflow, + (graph transitivity) –this(s), target(s), args(a), call (…), … (inheritance as wild card) pc(Object s, Object t): this(s) && target(t) && call(… f …)

9. UCI Feb 039 Observation 2 Want to improve the adaptive capabilities of AspectJ: AspectJ still leads to tangling and duplication.

10. UCI Feb 0310 Overview What is “adaptive programming”? Examples in AspectJ. What is behind adaptiveness in AspectJ? Why we need more adaptiveness in AspectJ. DAJ: a simple adaptive add-on to AspectJ. Abstraction behind “more adaptiveness” LoD in AspectJ Conclusions

11. UCI Feb 0311 Listing files in a FileSystem :FileSystem :CompoundFile :File_PList:NonEmpty_File_PList :FileName root contents next first it contents f f parent

12. UCI Feb 0312 public aspect FileSystemTraversals { public void CompoundFile.listAll() { FileLister v = new FileLister(); eachFile(v); void CompoundFile.eachFile(…) { … if (contents != null) eachFile_crossing_contents(newTokens); } void CompoundFile. eachFile_crossing_contents(…) { this.contents.eachFile(tokens); } // much more }

13. UCI Feb 0313 Example of an Adaptive Method in AspectJ (DAJ) aspect FileSystemTraversals { declare traversal: void listAll(): "from CompoundFile to File" (FileLister); }

14. UCI Feb 0314 http://daj.sourceforge.net/ DAJ gives you –the power of AspectJ and –the beauty of DJ and –the convenience of DemeterJ all at once without having to learn a new programming language other than AspectJ and a schema notation (Java Data Binding).

15. UCI Feb 0315 Another Adaptive Method aspect FileSystemTraversals { declare strategy: eachFile: "intersect(from CompoundFile to File, down)"; declare traversal: void listAll(): eachFile(FileLister); declare strategy: down: "from * bypassing -> *,parent,* to *"; }

16. UCI Feb 0316 What To Do class FileLister { Stack path = new Stack(); void before(File file) { path.push(file.name);} void after(File file) { System.out.print("."); Iterator it = path.iterator(); it.next(); while (it.hasNext()) System.out.print("/" + it.next()); System.out.println(); path.pop();} } High-level AspectJ advice using dynamic join points!

17. UCI Feb 0317 Ordinary Java Class class Main { public static void main(String[] args) { FileSystem fs = FileSystem.parse(new File(args[0])); Commands script = Commands.parse(new File(args[1])); script.interpret(fs.root); System.out.println(" Status of File System "); fs.root.listAll(); }

18. UCI Feb 0318 Domain-specific aspect languages What is a good infrastructure for this? Goes back to the theme of Crista: domain- specific aspect languages.

19. UCI Feb 0319 DAJ What is new for the AspectJ programmer Two additional declarations –declare strategy: including intersection –declare traversal Object structure and language aspect – class dictionary files

20. UCI Feb 0320 range of AOP languages means of … join points add memberssignaturesclass members static JPM DemeterJ, DAJ dynamic JPM static JPM 1 static JPM 2 static JPM 3 AspectJ dynamic JPM JPM when traversal reaches object or edge class members points in execution call, get, set… join points visitor method signatures traversal spec. s class graph g class names class graph signatures w/ wildcards & other properties of JPs identifying visitor method bodies s + g (result = traversal implementation) add members class graph with tokens=grammar (result = parsing and printing implementation) advice specifying semantics at

21. UCI Feb 0321 Overview What is “adaptive programming”? Examples in AspectJ. What is behind adaptiveness in AspectJ? Why we need more adaptiveness in AspectJ. DAJ: a simple adaptive add-on to AspectJ. Abstraction behind “more adaptiveness” LoD in AspectJ Conclusions

22. UCI Feb 0322 A General Graph-based Adaptive Mechanism Three layers of graphs: Bottom, Middle, Top –Bottom layer: trees to select subtrees guided by top layer. Each bottom layer tree has a graph from the –Middle layer associated with it that contains meta- information about the bottom layer tree. Acts as an abstraction barrier between the top and bottom layers. Used to reduce search space. –Top layer graph is basically a subgraph of the transitive closure of the middle layer graph, decorated with additional information attached to the edges.

23. UCI Feb 0323 Middle graph: Abstraction barrier Bottom tree: select subtrees A B A B C Top graph: subgraph of transitive closure of middle layer C A B c1:C c2:C c3:C

24. UCI Feb 0324 Graph-based adaptiveness The call graph application (AspectJ): –Top: computational pattern, –Middle: static call graph, –Bottom: call tree. The standard application (Demeter): –Top: strategy graph, –Middle: class graph, –Bottom: object trees.

25. UCI Feb 0325 Call graph example jp_lock = call(R.lock()) jp_write = call(R.write()) jp_unlock = call(R.unlock()) jp_read = call(R.read()) jps1 = from jp_start to {jp_lock, jp_write, jp_unlock, jp_read} jps2 = from jp_start bypassing {jp_lock, jp_write, jp_unlock, jp_read} to {jp_lock, jp_write, jp_unlock, jp_read} jps1 = jps2.

26. UCI Feb 0326 Overview What is “adaptive programming”? Examples in AspectJ. What is behind adaptiveness in AspectJ? Why we need more adaptiveness in AspectJ. DAJ: a simple adaptive add-on to AspectJ. Abstraction behind “more adaptiveness” LoD in AspectJ Conclusions

27. UCI Feb 0327 Aspects and lexical join points Going to the roots of the Northeastern branch of AOP: Law of Demeter. Closing the circle: Write an ultimately adaptive program in AspectJ: –Works with all Java programs –Checks the object-form of the Law of Demeter: “talk only to your friends”

28. UCI Feb 0328 Instrumentation of Java programs with Aspects Supplier TargetBinStack ReturnValueBin ArgumentBin GlobalPreferredBin LocallyConstructedBin ImmediatePartBin Checker Statistics Requirements: Good Separation of Concerns in Law of Demeter Checker Aspect Diagram uses pointcuts Aspect framework

29. UCI Feb 0329 Explanation The *bin* aspects collect potential preferred supplier objects that represent good coupling in the context of a method body. The Checker aspect checks each method call whether the receiver is a preferred supplier object. The Statistics aspect counts events generated by the Checker aspect.

30. UCI Feb 0330 Law of Demeter (Join Point Form) JPT(ID) = [ ID] List(ID) List(JPT) [ ID]. List(S) ~ {S}.

31. UCI Feb 0331 JPT(ID) = [ ID] List(ID) List(JPT) [ ID]. List(S) ~ {S}. J r1.foo1() a1.bar() t2.foo2() r3.foo2() E target t2 args {a1,a2} target t2 ret r1 target null ret r3

32. UCI Feb 0332 Generic Law of Demeter (Join Point Form) Definition 1: The LoD_JPF requires that for each join point J, target(J) is a potential preferred supplier of J. Definition 2: The set of potential preferred suppliers to a join point J, child to the enclosing join point E, is the union of the objects in the following sets:

33. UCI Feb 0333 Argument rule: the args of the enclosing join point E, including the target Associated rule: the associated values of E: the ret values of the children of E before J whose target is the target of E or whose target is null. Generic Law of Demeter (Join Point Form)

34. UCI Feb 0334 aspect LoD extends Violation { pointcut LoD_JPF(): //LoD definition ArgumentRule() || AssociatedRule(); pointcut ArgumentRule(): if(thisEnclosingJoinPoint.getArgs().contains(thisJoinPoint.getTarget()); pointcut AssociatedRule(): if(thisEnclosingJoinPoint.hasSelfishChild(thisJoinPoint.getTarget())); }

35. UCI Feb 0335 Pseudo Aspect LoD is a ``pseudo'' aspect because it cannot run in the current implementation of AspectJ, which doesn't allow declare warning to be defined on any pointcut with an if expression.

36. UCI Feb 0336 Join Point Form The pointcuts ArgumentRule and AssociatedRule select the ``good'' join points. ArgumentRule selects those join points whose target is one of the arguments of the enclosing join point;

37. UCI Feb 0337 Join Point Form AssociatedRule selects those join points whose target is in the set of locally returned ID's, and the ID's created in the siblings of the current node.

38. UCI Feb 0338 Map Dynamic Object Form (DOF) to LoD_JPF We use LoD_JPF pointcut to check DOF: –Dynamic join point model is mapped to JPT. Object is mapped to ID. Method invocations are mapped to JPF join points. The enclosing join point is the parent in the control flow.

39. UCI Feb 0339 Map Lexical Class Form (LCF) to LoD_JPF We use LoD_JPF to check LCF as follows. –Lexical join point model is mapped to JPT. Lexical join points are nodes in the abstract syntax tree –Class is mapped to ID. –Join points are signatures of call sites. The enclosing join point is the signature of the method in which the call site resides. To run the aspect, a suitable ordering has to be given to the elements of children: all constructor calls, followed by local method calls, followed by the other join points.

40. UCI Feb 0340 AspectJ code In AOSD 2003 paper with David Lorenz and Pengcheng Wu DOF: AspectJ works well. Program uses most adaptive ingredients of AspectJ: *, cflow, this, target, etc. LCF: AspectJ cannot do it. We sketch how to add statically executable advice to AspectJ.

41. UCI Feb 0341 package lawOfDemeter; public abstract class Any { public pointcut scope(): !within(lawOfDemeter..*) && !cflow(withincode(* lawOfDemeter..*(..))); public pointcut StaticInitialization(): scope() && staticinitialization(*); public pointcut MethodCallSite(): scope() && call(* *(..)); public pointcut ConstructorCall(): scope() && call(*.new (..)); public pointcut MethodExecution(): scope() && execution(* *(..)); public pointcut ConstructorExecution(): scope() && execution(*.new (..)); public pointcut Execution(): ConstructorExecution() || MethodExecution(); public pointcut MethodCall(Object thiz, Object target): MethodCallSite() && this(thiz) && target(target);

42. UCI Feb 0342 public pointcut SelfCall(Object thiz, Object target): MethodCall(thiz, target) && if(thiz == target); public pointcut StaticCall(): scope() && call(static * *(..)); public pointcut Set(Object value): scope() && set(* *.*) && args(value); public pointcut Initialization(): scope() && initialization(*.new(..)); } Class Any continued

43. UCI Feb 0343 package lawOfDemeter.objectform; import java.util.*; abstract class ObjectSupplier { protected boolean containsValue(Object supplier){ return targets.containsValue(supplier); } protected void add(Object key,Object value){ targets.put(key,value); } protected void addValue(Object supplier) { add(supplier,supplier); } protected void addAll(Object[] suppliers) { for(int i=0; i< suppliers.length; i++) addValue(suppliers[i]); } private IdentityHashMap targets = new IdentityHashMap(); }

44. UCI Feb 0344 package lawOfDemeter.objectform; public aspect Pertarget extends ObjectSupplier pertarget(Any.Initialization()) { before(Object value): Any.Set(value) { add(fieldIdentity(thisJoinPointStaticPart), value); } public boolean contains(Object target) { return super.containsValue(target) || Percflow.aspectOf().containsValue(target); } private String fieldIdentity(JoinPoint.StaticPart sp) { … } private static HashMap fieldNames = new HashMap(); }

45. UCI Feb 0345 package lawOfDemeter.objectform; aspect Check { private pointcut IgnoreCalls(): call(* java..*.*(..)); private pointcut IgnoreTargets(): get(static * java..*.*); after() returning(Object o):IgnoreTargets() { ignoredTargets.put(o,o); } after(Object thiz,Object target): Any.MethodCall(thiz, target) && !IgnoreCalls() { if (!ignoredTargets.containsKey(target) && !Pertarget.aspectOf(thiz).contains(target)) System.out.println( " !! LoD Object Violation !! " + thisJoinPointStaticPart/*[*/ + at(thisJoinPointStaticPart)/*]*/); } private IdentityHashMap ignoredTargets = new IdentityHashMap();}

46. UCI Feb 0346 package lawOfDemeter.objectform; aspect Percflow extends ObjectSupplier percflow(Any.Execution() || Any.Initialization()){ before(): Any.Execution() { addValue(thisJoinPoint.getThis()); addAll(thisJoinPoint.getArgs()); } after() returning (Object result): Any.SelfCall(Object,Object) || Any.StaticCall() || Any.ConstructorCall() { addValue(result); }

47. UCI Feb 0347 Conclusions Aspects and adaptiveness must work closely together to achieve best results. Crosscutting is closely linked to adaptiveness. AspectJ and DemeterJ have been very well integrated (DAJ on Source Forge). AP is a specialization of AOP and AOP is a specialization of AP. It goes both ways. AspectJ is a really useful language but we are a little concerned about how difficult it was to debug the Law of Demeter checkers.

48. UCI Feb 0348

49. UCI Feb 0349 AOSD

50. UCI Feb 0350 City = List(BusRoute) List(Flight). BusRoute = List(City). Flight = List(City). City routes BusRoute cities City (routes BusRoute cities City) { City -> BusRoute bypassing City BusRoute -> City bypassing City } source: City target: City

51. UCI Feb 0351 Ordinary Java Class class Main { public static void main(String[] args) { FileSystem fs = FileSystem.parse(new File(args[0])); Commands script = Commands.parse(new File(args[1])); script.interpret(fs.root); System.out.println(" Status of File System "); fs.root.listAll(); }

52. UCI Feb 0352 Domain-specific aspect languages What is a good infrastructure for this? Goes back to the old theme of Crista: domain-specific aspect languages.

53. UCI Feb 0353 Aspect-Oriented Programming with Extensible Plugins How can we integrate numerous domain specific aspect languages? Idea: Use AspectJ as basic aspect language and translate domain specific aspect languages to AspectJ. Case study: Redo DAJ in this style. Macneil.Shonle@Sun.COM

54. UCI Feb 0354 Interfaces of Aspects For functionality –Expects –Provides For join points –Import –Export

55. UCI Feb 0355 Kinds of Aspects Class Dictionary Aspect Traversal Aspect Traversal Advice Aspect AspectJ Aspect Class Everything reduced to classes and AspectJ aspects

56. UCI Feb 0356 Kinds of Aspects Class Dictionary Aspect –Imports: nothing (is a sink) –Exports: class graph nodes and edges –Expects: nothing (is a sink) –Provides: parser, numerous traversal advice (print, copy, display, check, equal) Traversal Aspect –Imports: class graph nodes and edges –Exports: dynamic join points during traversal –Expects: traversal advice –Provides: (adaptive) methods Import and export Join points Dynamic/lexical Provide and expect Something executable

57. UCI Feb 0357 Kinds of Aspects Traversal Advice Aspect –Imports: object graph slice nodes and edges –Exports: dynamic join points during visitor methods –Expects: methods –Provides: visitor methods (advice) AspectJ Aspect –Imports: class graph nodes, dynamic join points –Exports: dynamic join points during advice –Expects: abstract methods and pointcuts –Provides: advice, introductions Import and export Join points Dynamic/lexical Provide and expect Something executable

58. UCI Feb 0358 ClassDictionary Aspect aspect FileSys [ClassDictionary] { FileSystem = CompoundFile EOF. File : SimpleFile | CompoundFile common Ident. SimpleFile = "simple". CompoundFile = "compound" FileList [ CompoundFile]. FileList ~ "(" { File } ")". } Join point examples EBNF

59. UCI Feb 0359 Traversal Aspect aspect FileSystemTraversals [Traversal] { declare strategy: eachFile: "intersect(from CompoundFile to File, down)"; declare traversal: void listAll() : eachFile(FileLister); declare strategy: down: "from * bypassing -> *,parent,* to *"; declare strategy: up: "from * bypassing -> *,contents,* to *"; } Happens to be AspectJ code

60. UCI Feb 0360 Need for Glue The class dictionary aspect and traversal aspect. Use name mapping: –CompoundFile, File, parent, content Need to check whether there is a path from CompoundFile to File in the class graph that is exported from the class dictionary aspect.

61. UCI Feb 0361 Glue Aspect aspect FileSystemMethods [Cd_Traversal] { default name map; // FileSys.CompoundFile = // FileSystemTraversals.CompoundFile // etc. }

62. UCI Feb 0362 AspectJ Aspect aspect FileSystemMethods [AspectJ] { File CompoundFile.getFile(Ident name) { for (Iterator it = contents.iterator(); it.hasNext();) { File file = (File) it.next(); if (file.name.equals(name)) return file; } return null; }

63. UCI Feb 0363 Traversal Advice Aspect aspect FileLister [TraversalAdvice] { Stack path = new Stack(); void before(File file) { path.push(file.name);} void after(File file) { System.out.print("."); Iterator it = path.iterator(); it.next(); while (it.hasNext()) System.out.print("/" + it.next()); System.out.println(); path.pop();} } Happens to be a Java class

64. UCI Feb 0364 LoD for Fred (D. Orleans) The set of potential preferred suppliers to a message-send expression M in the body of a branch B is the union of the objects in the following sets: the argument list A of the decision point E that caused the invocation of B; the associated values of E, that is, –the results of message-send expressions M' in the body of B before M whose argument lists A' intersect with A; –instances that were created in the control flow of the body of B before M. Fred (AOSD 02): simplest AOP language: decision points, branches

65. UCI Feb 0365

66. UCI Feb 0366 Meta program Program Join point trees Subtrees cflow Nodes: *,..,+ Edges: Meta classes Classes Pathsets Object trees Subtrees from A Nodes: * Edges: * Meta aspects Aspects Aspect object tree Subtrees lexical dynamic

67. UCI Feb 0367 Meta program Program Lexical call graph Join point trees Join point trees = Dynamic call graph Subtrees cflow Nodes: *,..,+ Edges: Meta classes Classes Class graph Pathsets Object trees Subtrees from A Nodes: * Edges: * Meta aspects Aspects Aspect graph Aspect object tree Subtrees lexical dynamic Reflection connections: CR, AR Aspect extent: duration of method call, object only: context object paper.