Better Separation of Crosscutting Concerns with Aspectual Components

1. Better Separation of Crosscutting Concerns withAspectual Components Karl Lieberherr College of Computer Science Demeter Team Northeastern University, Boston www.ccs.neu.edu/research/demeter Aspectual Components

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

3. Overview • Aspect-Oriented Programming (AOP): Crosscutting concerns, controlling tangling and scattering. • Example: Collect entities. • Aspectual Components + DJ • Comparison to AspectJ • Summary 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 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 • ... 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. 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, …” Aspectual Components

8. AOP: not every concern fits into a component: crosscutting Goal: find new component structures that encapsulate “rich” concerns 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 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. Aspectual Components

11. Tangling: count color changes ordinary program better program structure-shy functionality Component 1 structure Component 2 synchronization Component 3 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 CM3 synchronization Concern 3 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. Aspectual Components

14. 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 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) Aspectual Components

16. minimal assumptions on application structure + expected interfaces meth meth meth meth 1,1 1,k 3,j 3,1 Aspectual Component 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 ... P3 enhancements = before/around/after + provided ... 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 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 Aspectual Components

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

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

21. Aspectual Component component COLLECT { participantSource { expectedstatic 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(Thingv1){ return_val.add(cg.fetch(v1, id) );} public Object getReturnValue(){return return_val;}}; Source.cg.traverse(this, “fromSource” + constraint + “toTarget”, v}; participantTarget { } } 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. Aspectual Components

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

24. Java code 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(Thingv1){ return_val.add(cg.fetch(v1, id) );} public Object getReturnValue(){return return_val;}}; cg.traverse(this,“fromSystem”+constraint+“toThing”, v); return (HashSet)v.getReturnValue(); } HashSet defined(ClassGraph cg){ return (HashSet) this.collect(cg, “bypassingBody” );} HashSet used(ClassGraph cg){ return (HashSet) this.collect(cg, “throughBody” );}} green: traversal black bold: structure purple: advice red: parameters Aspectual Components

25. Ad-hoc Implementation oftraversal-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 Aspectual Components

26. Need more than localizationof 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 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. 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). Aspectual Components

29. 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 AspectJ (Xerox) DJ (NEU) Aspectual Components

30. Concepts needed(DJ classes) • ClassGraph • Strategy (= Java String = traversal strategy) • Visitor Aspectual Components

31. Adaptive Programming Strategy Bold names refer to DJ classes. is use-case based abstraction of ClassGraph defines family of Object Aspectual Components

32. Adaptive Programming Strategy defines traversals of Object Aspectual Components

33. Adaptive Programming Strategy guides and informs Visitor Aspectual Components

34. 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 AOP AP 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 Applicable to design and documentation of your current systems. 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. 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 Aspectual Components