Features of AOP languages AOP languages have the following main elements: –a join point model (JPM) wrt base PL –a specification language for expressing sets of join points (JPS) –a means of specifying behavior involving join points (BJP) –encapsulated units combining JPS and BJP (CSB) –method of attachment of units to base program (AU)

Comparing AspectJ DemeterJ DJ ATC AspectC

AspectJ JPM principled points of execution –message sends (basically a method call), message receptions, method executions –field references (get and set) –exception throwing and handling –constructor execution which context is available at each join point?

AspectJ JPS pointcut designators –primitive: calls(sig), receptions(sig), executions(sig), instanceof(type), within(type), cflow(pcd), getter(sig?), setter(sig?) –operators: &&, ||, ! can name a pointcut and expose context –pointcut foo (V v):pcd (using v); pointcut maybe abstract (declaration) and defined in a subaspect.

AspectJ BJP before, after, around: a pointcut. can refer to thisJoinPoint –explain join point object: instance of JoinPoint class. Interface: getSignature(), getActualParameters(),… JoinPoint has eleven subclasses: CallJoinPoint, ReceptionJoinPoint, ExecutionJoinPoint, ExceptionJoinPoint, … in around (instead of) can say: proceed()

AspectJ CSB an aspect contains a list of advice and point cut declarations and introductions and regular fields and methods.

Explaining aspect instance when you declare an aspect, you say either of eachJVM() or of eachobject(pcd) logging: log stream put in aspect instance of each VM (one instance for whole program) dft: mark field put it in aspect instance of each object (node object of the graph)

AspectJ AU ajc takes a list of files: aspects and classes and weaves them together.

DemeterJ JPM traversal method calls on Java object, constructor calls

DemeterJ JPS strategies –define family of traversal programs to be enhanced –approximation: function mapping object graphs to subgraphs sentences –define family of Java objects: executions of constructor calls

DemeterJ BJP visitor classes –before *

DemeterJ CSB adaptive methods –void f() to S (V1, V2)

DemeterJ AU make new.beh file, add to.prj file, demeterj

DJ JPM object graph : nodes and edges principled points: traversal of nodes or edges fix a traversal algorithm

DJ JPS strategies –define family of traversal programs to be enhanced –approximation: function mapping object graphs to subgraphs (object graph slices)

DJ BJP visitor classes –before(A a), after(C c), cbefore_x(Object a, Object b), caround_x(Object a, Object b, Subtraverser st) –each method applies to a different part of the point cut (strategy)

DJ CSB aspectual methods void f(ClassGraph cg) { cg.traverse(this, “from A to S”, new Visitor() {…});}

DJ AU add methods to classes

DJ: Second view: Doug

DJ JPM object graph slices: nodes and edges fix a traversal algorithm

DJ JPS strategies –define family of traversal programs to be enhanced –approximation: function mapping object graphs to subgraphs (object graph slices) in addition: visitor methods are pointcut designators pointcut designators are encoded in signatures of visitor methods

DJ BJP visitor classes –each visitor method is advice on the point cut specified by the method signature

DJ CSB a visitor class is a package of advice when you use a visitor in a traversal of an ogs (in traverse) then each pointcut is intersected with the traversal pointcut, namely cflow(traverse). (can also use within)

DJ AU to attach an aspect you call traverse with an aspect (visitor). traverse expression attaches the aspect to an object graph slice.

AspectC JPM function calls, variable references data available: args to function calls

AspectC JPS point cut designators –call (foo( c )): all calls of function foo with one argument –cflow( any point cut designator): “whatever comes afterwards on the stack” –varref(name) –combine with &&, || and !

AspectC BJP before, after, around

AspectC CSB are hardwired together: when advice is given, you need to give point cut

AspectC AU concatenated to the source

ATC JPM Aspects in Tiny CLOS generic function receptions, method executions use MOP to implement aspects what data is exported: see join point object

ATC JPS ! point cut designators –predicate on aspect instance and join point object –explain join point object: instance of class. Interface: slots: generic (generic function being called), args (actual parameters), stack (stack of join points in current control flow) has two subclasses: and has additional slot: method (being executed) (all the traversal methods in the cflow of the first traversal call)

ATC BJP before, after, around: take aspect instance and join point object as argument. around has third arg: continuation generic function...

ATC CSB advice has a pointcut generic function (like an abstract pointcut in AspectJ). Methods of generic function are specified separately. an aspect contains a list of advice (no point cut declaration) an aspect is an instance of

Explaining aspect instance class has two subclasses: logging: log stream put in aspect instance of each VM (one instance for whole program) dft: mark field put it in aspect instance of each object (node object of the graph)

ATC AU ! mixin: has slot aspects: holds list of attached aspects is a subclass of both and ( is the class of all generic functions) add-aspect!, remove-aspect! all generic functions in base program are aspectizable (non-obliviousness ok)

Aspectual Collaborations JPM principled points of execution –abstract join points that are mapped by the adapter to concrete ones –execution of methods modified by collaboration enhance the class graph: open classes: add more members to existing classes which context is available at each join point?

Aspectual Collaborations JPS sets of join points: collaboration + adapter (in the adapters we express the cross cutting) collaboration roles only: have the flavor of an abstract pointcut.

Aspectual Collaborations BJP before, after, around: for methods can refer to actual parameters in replace (around (instead of)) can say: expected()

Aspectual Collaborations CSB collaborations and adapters

Aspectual Collaborations AU ac-compiler (non existent) takes a list of files: classes and collaborations and adapters and weaves them together.

Using AspectJ to implement collaborations/adapters AspectJ can only express the adapted collaborations AspectJ supports interfaces with full methods and multiple inheritance

Goal Input: classes, collaborations, adapters Output: AspectJ code