Towards Reusable
          Components with Aspects:
An Empirical Study on Modularity and Obliviousness

                Ke...
Seen code that looks like this?




                         (Carlo H. Séquin @ Berkeley)                   (speedcubing.c...
Roadmap

 AOP with AspectJ
 Challenges
 Cooperative AOP with Explicit Join Points
 Empirical Study
     How oblivious...
Cross-cutting Concerns




     (Thanks to AspectJ Dev Tools (AJDT) Visualization Eclipse Perspective)
Cross-cutting Concerns




     (Thanks to AspectJ Dev Tools (AJDT) Visualization Eclipse Perspective)
Real Crosscutting Concerns

 Logging (canonical example)
 Pooling / caching
 Dependency injection
 Policy / contract e...
AOP & Crosscutting Concerns
Separation
Modularization
AOP Stratagems [Filman/Friedman’00]

 Obliviousness
   Increased modularity of base code and aspect code
   Parallel an...
AspectJ

 AspectJ [Kiczales ’01]
 Join point model
     Structural points in ‘base code’

   Quantification model (poi...
Looks Nice, However…
Aspect  Base Code Coupling
Fragile Pointcuts
Base Code                       Aspect Code
private void initScreens(       public aspect
         Servl...
State—Point Separation Issue
Base Code                  aspect AbortedTranAnalyzer {
                           //========...
State—Point Separation Issue
Base Code                  aspect AbortedTranAnalyzer {
                           //========...
State—Point Separation Issue
Base Code                  aspect AbortedTranAnalyzer {
                           //========...
State—Point Separation Issue
Base Code                  aspect AbortedTranAnalyzer {
                           //========...
State—Point Separation Issue
Base Code                  aspect AbortedTranAnalyzer {
                           //========...
AspectJ-specific Problems

 Abstract aspects can’t share pointcuts
 Anonymous advice --> hard to advise aspects
 Blocks...
Lack of Advice Parameterization
Base Code                   aspect ExceptionPrinter {
                                poin...
Some Proposed Techniques

 Aspect-aware Interfaces [Kiczales, Mezini ‘05]
 Open Modules [Aldrich ‘05]
 HyperJ [Ossher, ...
Explicit Join Points (EJPs)

   Abstract a cross-cutting concern to its most
    essential form
     Invoke the informat...
Aspect  Base Code Coupling
Cooperative AOP Methodology




    AspectJ: 39 AspectBase couplings
EJPs: 11 AspectInterface, 15 BaseInterface
Comparison of Approaches
   AspectJ:
                         Base Code                Aspects



   AspectJ with EJPs (...
Building Aspect Libraries with EJPs

   Define semantic interfaces of cross-cutting
    concerns using interfaces and EJP...
EJPs Address…

 Fragile pointcuts
 State—point separation problem
 Abstract aspects can’t share pointcuts
 Anonymous a...
Sullivan—Levels of Obliviousness

  Language-level (i.e. language support for AOP)
  Feature obliviousness—base code una...
This Empirical Study




 What are the tradeoffs
  between modularity
  and obliviousness?
This Empirical Study
   Refactored Exception Handling for 3 Java Apps:
     Using AspectJ
     Using EJPs / Cooperative...
Target Applications

   Telestrada (Java)
     220+ classes and interfaces, 3400 LOC

   Java Pet Store (Java)
     34...
Refactoring Strategy (AspectJ)
BEFORE                  AFTER
class C {               aspect A {
  void m() throws … {     ...
Refactoring Strategy (EJPs)
BEFORE                  AFTER
class C {               aspect A {
  void m() throws … {     sco...
Empirical Metrics
   Coupling Between Modules (CBM)
   Coupling on Intercepted Modules (CIM)
   Lack of Cohesion of Ope...
Coupling Metrics
   Coupling Between Modules (CBM)
     Number of other modules referenced via field access
      or met...
Coupling Between Modules
Coupling Metrics

   Coupling on Intercepted Modules (CIM)
     # of modules explicitly named in pointcuts
     [Ceccat...
Coupling on Intercepted Modules
Cohesion Metric

   Lack of Cohesion in Operations (LCO)
     # of method pairs accessing different fields minus
      #...
Lack of Cohesion of Operations
Size / Complexity Metrics

   Lines of Code (LOC)
     # of lines of code without whitespace / comments

   Concern Lin...
Lines of Code
Concern Lines of Code
Number of Operations
Separation of Concern Metrics

   Concern Diffusion over Modules (CDoM)
     # of modules that implement a concern
    ...
Concern Diffusion over Modules
Concern Diffusion over Operations
Separation of Concern Metrics

   Concern Diffusion over Lines of Code
     # of transitions between one concern to anot...
Concern Diffusion over LOC
% of handlers implemented by
abstract aspects or EJP library
                                  Exception Handler Reuse
Reusable Exception Handler EJPs

 Ignore exception
 Print/log exception
 Rethrow different exception or its cause
 On ...
Empirically, This Happens
Cooperative AOP Can Help




    AspectJ: 39 AspectBase couplings
EJPs: 11 AspectInterface, 15 BaseInterface
Conclusions

   Explicit Interfaces and EJP references:
     Provided effective means for advice
      parameterization
...
Future Work
                                         JSR-308 includes
                                          proposal ...
(SUPPORTING SLIDES)
Addressing EJP Explicitness

 Use EJPs only when appropriate
 Design EJPs so that their presence is minimal


       Bas...
Empirical Metrics Formulated…

   Coupling, Cohesion, Separation of Concerns
     On the reuse and maintenance of Aspect...
Empirical Studies Emerging…
   Separation of Concerns in Multi-agent Systems: An
    Empirical Study [2004]
   Modulariz...
Explicit Join Point Declarations


abstract aspect TranConcern {
  scoped joinpoint void enterTrans(int isolation)
       ...
Referencing EJPs in Base Code
abstract aspect TranConcern {
  scoped joinpoint void enterTrans(int isolation)
          th...
Advising EJPs in Aspects
aspect TranConcernViaSomeLibrary {
   void around(int iso) throws TranException:
           call(...
Advising EJPs in Aspects

aspect BillingComponentsTranPolicy {
  int around(): call(ejp(TranConcern.defIso))
             ...
Upcoming SlideShare
Loading in …5
×

Towards Reusable Components With Aspects [ICSE 2008]

1,396 views
1,338 views

Published on

Does obliviousness increase overall modularity? This presents the results of an empirical study that focuses on the tradeoffs between obliviousness and modularity. The results may surprise you!

Published in: Technology, Sports
1 Comment
1 Like
Statistics
Notes
No Downloads
Views
Total views
1,396
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
73
Comments
1
Likes
1
Embeds 0
No embeds

No notes for slide

Towards Reusable Components With Aspects [ICSE 2008]

  1. 1. Towards Reusable Components with Aspects: An Empirical Study on Modularity and Obliviousness Kevin Hoffman / Patrick Eugster
  2. 2. Seen code that looks like this? (Carlo H. Séquin @ Berkeley) (speedcubing.com) (George W. Hart @ Stony Brook) (George W. Hart @ Stony Brook)
  3. 3. Roadmap  AOP with AspectJ  Challenges  Cooperative AOP with Explicit Join Points  Empirical Study  How obliviousness can be traded for increased modularity and reuse through Cooperative AOP  Potential pitfalls and guidelines
  4. 4. Cross-cutting Concerns (Thanks to AspectJ Dev Tools (AJDT) Visualization Eclipse Perspective)
  5. 5. Cross-cutting Concerns (Thanks to AspectJ Dev Tools (AJDT) Visualization Eclipse Perspective)
  6. 6. Real Crosscutting Concerns  Logging (canonical example)  Pooling / caching  Dependency injection  Policy / contract enforcement  Security  Transactions  Exception Handling
  7. 7. AOP & Crosscutting Concerns
  8. 8. Separation
  9. 9. Modularization
  10. 10. AOP Stratagems [Filman/Friedman’00]  Obliviousness  Increased modularity of base code and aspect code  Parallel and domain-specific development  Better post-mortem extendibility  Quantification (pattern matching)  Reduction in code size and duplicity  Higher level interaction between primary and cross- cutting concerns
  11. 11. AspectJ  AspectJ [Kiczales ’01]  Join point model  Structural points in ‘base code’  Quantification model (pointcuts)  Lexical patterns and type constraints  Dynamic predicates and control flow  Aspects inject advice before, after, around…
  12. 12. Looks Nice, However…
  13. 13. Aspect  Base Code Coupling
  14. 14. Fragile Pointcuts Base Code Aspect Code private void initScreens( public aspect ServletContext ctxt, WafViewTemplateHandler extends String language) ExceptionGenericAspect { { … pointcut initScrGetResHdlr(): screenDefURL = withincode( ctxt.getResource(…); private void … TemplateServlet. } initScreens( ServletContext, String)) && call(URL ServletContext .getResource(String)); … }
  15. 15. State—Point Separation Issue Base Code aspect AbortedTranAnalyzer { //========POSSIBLE======== try { pointcut gotOldExc(OldExc ex): … handler(OldExc) && args(ex); } catch (OldExc e) { pointcut abortedTran(Tran tr): t.abortTrans(…); call(* *.abortTrans(..)) throw new && target(tr); GenExc (quot;failedquot;); } pointcut gotGenExc(GenExc ex): initialization(GenExc.new(..)) && target(ex); //======NOT POSSIBLE======= pointcut get3State(OldExc old, Tran tr, GenExc gen): gotOldExc(old) && abortedTran(tr) && gotGenExc(ex); }
  16. 16. State—Point Separation Issue Base Code aspect AbortedTranAnalyzer { //========POSSIBLE======== try { pointcut gotOldExc(OldExc ex): … handler(OldExc) && args(ex); } catch (OldExc e) { pointcut abortedTran(Tran tr): t.abortTrans(…); call(* *.abortTrans(..)) throw new && target(tr); GenExc (quot;failedquot;); } pointcut gotGenExc(GenExc ex): initialization(GenExc.new(..)) && target(ex); //======NOT POSSIBLE======= pointcut get3State(OldExc old, Tran tr, GenExc gen): gotOldExc(old) && abortedTran(tr) && gotGenExc(ex); }
  17. 17. State—Point Separation Issue Base Code aspect AbortedTranAnalyzer { //========POSSIBLE======== try { pointcut gotOldExc(OldExc ex): … handler(OldExc) && args(ex); } catch (OldExc e) { pointcut abortedTran(Tran tr): t.abortTrans(…); call(* *.abortTrans(..)) throw new && target(tr); GenExc (quot;failedquot;); } pointcut gotGenExc(GenExc ex): initialization(GenExc.new(..)) && target(ex); //======NOT POSSIBLE======= pointcut get3State(OldExc old, Tran tr, GenExc gen): gotOldExc(old) && abortedTran(tr) && gotGenExc(ex); }
  18. 18. State—Point Separation Issue Base Code aspect AbortedTranAnalyzer { //========POSSIBLE======== try { pointcut gotOldExc(OldExc ex): … handler(OldExc) && args(ex); } catch (OldExc e) { pointcut abortedTran(Tran tr): t.abortTrans(…); call(* *.abortTrans(..)) throw new && target(tr); GenExc (quot;failedquot;); } pointcut gotGenExc(GenExc ex): initialization(GenExc.new(..)) && target(ex); //======NOT POSSIBLE======= pointcut get3State(OldExc old, Tran tr, GenExc gen): gotOldExc(old) && abortedTran(tr) && gotGenExc(ex); }
  19. 19. State—Point Separation Issue Base Code aspect AbortedTranAnalyzer { //========POSSIBLE======== try { pointcut gotOldExc(OldExc ex): … handler(OldExc) && args(ex); } catch (OldExc e) { pointcut abortedTran(Tran tr): t.abortTrans(…); call(* *.abortTrans(..)) throw new && target(tr); GenExc (quot;failedquot;); } pointcut gotGenExc(GenExc ex): initialization(GenExc.new(..)) && target(ex); //======NOT POSSIBLE======= pointcut get3State(OldExc old, Tran tr, GenExc gen): gotOldExc(old) && abortedTran(tr) && gotGenExc(ex); }
  20. 20. AspectJ-specific Problems  Abstract aspects can’t share pointcuts  Anonymous advice --> hard to advise aspects  Blocks of code inside methods not advisable  Pointcuts can’t parameterize advice
  21. 21. Lack of Advice Parameterization Base Code aspect ExceptionPrinter { pointcut p1(Exc1 ex): try { handler(Exc1) && args(ex); … before(Exception ex): } catch (Exc1 e) { p1(ex) || p2(ex) println(quot;timeoutquot;); { handleExc(quot;timeoutquot;, thisJP); } } try { pointcut p2(Exc2 ex): … handler(Exc2) && args(ex); } catch (Exc2 e) { before(Exception ex): println(quot;net failedquot;); p1(ex) || p2(ex) } { handleExc(“net failedquot;, thisJP); } void handleExc(String m, JoinPoint jp) { println(jp + quot;:quot; + m); … } }
  22. 22. Some Proposed Techniques  Aspect-aware Interfaces [Kiczales, Mezini ‘05]  Open Modules [Aldrich ‘05]  HyperJ [Ossher, Tarr ‘00]  Classpects [Rajan, Sullivan ‘05]  CaesarJ [Aracic, Gasiunas, Mezini, Ostermann ‘06]  XPIs [Sullivan et. al. ‘05]  Explicit Join Points [Hoffman, Eugster ‘07]
  23. 23. Explicit Join Points (EJPs)  Abstract a cross-cutting concern to its most essential form  Invoke the information hiding principle  Model the abstraction explicitly using named join points instead of implicit join points  Reference EJPs in code explicitly  Or use aspects to inject EJP references obliviously
  24. 24. Aspect  Base Code Coupling
  25. 25. Cooperative AOP Methodology AspectJ: 39 AspectBase couplings EJPs: 11 AspectInterface, 15 BaseInterface
  26. 26. Comparison of Approaches  AspectJ: Base Code Aspects  AspectJ with EJPs (Cooperative AOP): Library Interfaces Pluggable Libraries Base Code EJP Interfaces Aspects Scoped EJPs, pointcutargs and thisblock, advice parameterization by type/value, and policy enforcement
  27. 27. Building Aspect Libraries with EJPs  Define semantic interfaces of cross-cutting concerns using interfaces and EJPs  Package these in a JAR  Define aspects that advise the EJPs to implement the cross cutting concerns  Package each implementation in a different JAR  Write base code or aspects to reference EJPs  Choose aspect implementation JAR at load-time  As the EJPs evolve, use aspects to obliviously adapt calls from old EJPs to new EJPs
  28. 28. EJPs Address…  Fragile pointcuts  State—point separation problem  Abstract aspects can’t share pointcuts  Anonymous advice  Blocks of code inside methods not advisable  Pointcuts can’t parameterize advice
  29. 29. Sullivan—Levels of Obliviousness  Language-level (i.e. language support for AOP)  Feature obliviousness—base code unaware of features in aspects, but do know of preconditions  Designer obliviousness—  Base code programmers blissfully unaware…  Pure obliviousness—  Complete, symmetric separation
  30. 30. This Empirical Study What are the tradeoffs between modularity and obliviousness?
  31. 31. This Empirical Study  Refactored Exception Handling for 3 Java Apps:  Using AspectJ  Using EJPs / Cooperative AOP  Empirical Metrics Measuring:  Coupling & Cohesion  Size & Complexity  Separation of Concerns  Reusability  Revisiting ‘Exceptions and Aspects’ @ FSE06 [Filho et. al.] – Thanks!
  32. 32. Target Applications  Telestrada (Java)  220+ classes and interfaces, 3400 LOC  Java Pet Store (Java)  340+ classes and interfaces,17800 LOC  Health Watcher (AspectJ)  36 aspects, 96 classes and interfaces, 6600 LOC  Aspects for CC, distribution, persistence, some EH
  33. 33. Refactoring Strategy (AspectJ) BEFORE AFTER class C { aspect A { void m() throws … { pointcut p(): try { /*body*/ } execution(void C.m()); catch(E e) { … } void around(): p() { } try { } proceed(); } catch (E e) { … } } declare soft: E: p(); } class C { void m(){ /*body*/ } }
  34. 34. Refactoring Strategy (EJPs) BEFORE AFTER class C { aspect A { void m() throws … { scoped joinpoint ejpH() try { /*body*/ } handles E throws …; catch(E e) { … } void around() throws …: } call(ejpScope(ejpH)) } { try{ proceed(); } catch(E e) { … } } } class C { void m() throws … { A.ejpH(){ /*body*/ } } }
  35. 35. Empirical Metrics  Coupling Between Modules (CBM)  Coupling on Intercepted Modules (CIM)  Lack of Cohesion of Operations (LCO)  Lines of Code (LOC) / Concern LOC (CLOC)  Number of Operations (NoO)  Concern Diffusion over Modules (CDoM)  Concern Diffusion over Operations (CDoO)  Concern Diffusion over Lines of Code (CDoLOC)  Reusable Operation Use Percentage (ROUP)
  36. 36. Coupling Metrics  Coupling Between Modules (CBM)  Number of other modules referenced via field access or method call or EJP reference  Extended to include reference to EJP interfaces  [Chidamber, Kemerer 1994] class C { void m1(B var1, B var2) { A.ejpH(){ var1.m3(); } C.m2(); var2.m4(); CBM = 2 } (A and B) static void m2() { … } }
  37. 37. Coupling Between Modules
  38. 38. Coupling Metrics  Coupling on Intercepted Modules (CIM)  # of modules explicitly named in pointcuts  [Ceccato, Tonella 2004] pointcut initScrGetResHdlr(): withincode( private void TemplateServlet. initScreens( ServletContext, CIM = 3 String)) && call(URL ServletContext .getResource(String));
  39. 39. Coupling on Intercepted Modules
  40. 40. Cohesion Metric  Lack of Cohesion in Operations (LCO)  # of method pairs accessing different fields minus # of method pairs accessing common fields  Helps to measure commonality of purpose class C { Object f1, f2, f3; LCO = 2 void m1() { f1=…; } void m2() { f2=…; } void m3() { f3=…; } void m4() { f1=…; f2=…;} } Disjoint Pairs: m1-m2, m1-m3, m2-m3, m3-m4 Non-Disjoint Pairs: m1-m4, m2-m4
  41. 41. Lack of Cohesion of Operations
  42. 42. Size / Complexity Metrics  Lines of Code (LOC)  # of lines of code without whitespace / comments  Concern Lines of Code (CLOC)  # of lines of code required to implement the exception handling concern  Number of Operations (NoO)  Number of declared methods and advice
  43. 43. Lines of Code
  44. 44. Concern Lines of Code
  45. 45. Number of Operations
  46. 46. Separation of Concern Metrics  Concern Diffusion over Modules (CDoM)  # of modules that implement a concern  … OR reference one that does  Concern Diffusion over Operations (CDoO)  # of operations that implement a concern  … OR reference one that does
  47. 47. Concern Diffusion over Modules
  48. 48. Concern Diffusion over Operations
  49. 49. Separation of Concern Metrics  Concern Diffusion over Lines of Code  # of transitions between one concern to another class C { class C { void m() throws … { void m() throws … { try { A.ejpHandler() { /* /* body body */ */ } catch(E e) { … } } } } } }
  50. 50. Concern Diffusion over LOC
  51. 51. % of handlers implemented by abstract aspects or EJP library Exception Handler Reuse
  52. 52. Reusable Exception Handler EJPs  Ignore exception  Print/log exception  Rethrow different exception or its cause  On exception set variable to value  Propagate exception if flagged 16 EJPs covered 74% of all handlers
  53. 53. Empirically, This Happens
  54. 54. Cooperative AOP Can Help AspectJ: 39 AspectBase couplings EJPs: 11 AspectInterface, 15 BaseInterface
  55. 55. Conclusions  Explicit Interfaces and EJP references:  Provided effective means for advice parameterization  Greatly increased aspect reusability  Must be carefully designed, ideally in advance  Greatest software quality achieved when using combination of obliviousness + EJPs
  56. 56. Future Work  JSR-308 includes proposal for annotations on statements  Study interactions between obliviousness and software quality in the presence of multiple cross-cutting concerns kjhoffma@cs.purdue.edu peugster@cs.purdue.edu Download papers, slides, and compiler at http://www.kevinjhoffman.com/
  57. 57. (SUPPORTING SLIDES)
  58. 58. Addressing EJP Explicitness  Use EJPs only when appropriate  Design EJPs so that their presence is minimal Base Code EJP Interfaces Aspects  Use aspects to reference EJPs as appropriate  Aspect-oriented code editors  Fluid AOP [Hon / Kiczales]
  59. 59. Empirical Metrics Formulated…  Coupling, Cohesion, Separation of Concerns  On the reuse and maintenance of Aspect-Oriented software: [Sant’Anna et. al. 2000]  AspectBase Code Coupling  Measuring the effects of software aspectization [Ceccato/Tonella 2004]  http://aopmetrics.tigris.org/
  60. 60. Empirical Studies Emerging…  Separation of Concerns in Multi-agent Systems: An Empirical Study [2004]  Modularizing design patterns with aspects: a quantitative study [AOSD’05]  Composing design patterns: a scalability study of aspect- oriented programming [AOSD’06]  Exceptions and aspects: the devil is in the details [FSE’06]  On the impact of aspectual decompositions on design stability: An empirical study [ECOOP’07]  Towards Reusable Components with Aspects [ICSE’08]  Evolving Software Product Lines with Aspects [ICSE’08]
  61. 61. Explicit Join Point Declarations abstract aspect TranConcern { scoped joinpoint void enterTrans(int isolation) throws TranException; } Keyword to Explicit Name to Associate Declare EJP with Abstract Semantics Optional Constraints Acting Explicit Value Modifiers Upon Base Code Parameterization
  62. 62. Referencing EJPs in Base Code abstract aspect TranConcern { scoped joinpoint void enterTrans(int isolation) throws TranException; joinpoint int defIso() = 1; Some policy aspect could } implement/override this EJP void someMethod() throws TranException { TranConcern.enterTrans(TranConcern.defIso()) { //block of code } Reference to scoped EJP; Reference to } entire block of code is advised EJP in base code
  63. 63. Advising EJPs in Aspects aspect TranConcernViaSomeLibrary { void around(int iso) throws TranException: call(ejpScope(TranConcern.enterTrans)) && args(iso) { TransContext t = …; t.beginTrans(); try { proceed(); /* calls original block of code */ t.commitTrans(); } catch(Throwable e) { t.abortTrans(); throw TranException(e); }}
  64. 64. Advising EJPs in Aspects aspect BillingComponentsTranPolicy { int around(): call(ejp(TranConcern.defIso)) && within (com.me.billing.*) { return 4; } //use a higher isolation level in billing pkg } aspect ForceIsolationLevel { int around(): call(ejp(TranConcern.defIso)) && cflow(call(* CreditCard+.*(..))) { return 5; } //anytime the call stack includes a method } //from the CreditCard class use iso level 5

×