370 likes | 515 Views
Better Separation of Crosscutting Concerns with Aspectual Components. Karl Lieberherr College of Computer Science Demeter Team Northeastern University, Boston www.ccs.neu.edu/research/demeter. Team. with Professors Felleisen, Lorenz, Wand Ph.D. students: Doug Orleans, Johan Ovlinger
E N D
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
Team • with Professors Felleisen, Lorenz, Wand • Ph.D. students: • Doug Orleans, • Johan Ovlinger • Therapon Skotiniotis • Pengcheng Wu Aspectual Components
Overview • Aspect-Oriented Programming (AOP): Crosscutting concerns, controlling tangling and scattering. • Example: Collect entities. • Aspectual Components + DJ • Comparison to AspectJ • Summary Aspectual Components
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
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
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
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
AOP: not every concern fits into a component: crosscutting Goal: find new component structures that encapsulate “rich” concerns Aspectual Components
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
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
Tangling: count color changes ordinary program better program structure-shy functionality Component 1 structure Component 2 synchronization Component 3 Aspectual Components
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
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
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
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
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
M1: Equation System EquationSystem equations Equation_List Ident * Variable lhs Equation Numerical rhs Expression_List Simple args Expression * op Add Compound Aspectual Components
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
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
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
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
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
Adapter part // EquationSystem class graph attach COLLECT { EquationSystem += Source with { provide EquationSystem::cg to Source::cg; } Variable += Target } Aspectual Components
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
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
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
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
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
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
Concepts needed(DJ classes) • ClassGraph • Strategy (= Java String = traversal strategy) • Visitor Aspectual Components
Adaptive Programming Strategy Bold names refer to DJ classes. is use-case based abstraction of ClassGraph defines family of Object Aspectual Components
Adaptive Programming Strategy defines traversals of Object Aspectual Components
Adaptive Programming Strategy guides and informs Visitor Aspectual Components
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
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
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
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