Does Aspect-Oriented Programming Increase the Development Speed for Crosscutting Code? An Empirical Study Stefan Hanenberg, Sebastian Kleinschmager, Manuel Josupeit-Walter University of Duisburg-Essen, 2009 Presenter: Olivier Clerc ETH Zürich 1
Logging void foo() { bar(); } void bar() { baz(); } void baz() { System.out.println(“Hello, world!“); } Extend the program such that each method call is written to a log 2
OOP Solution void foo() { Logger.log("foo"); bar(); } void bar() { Logger.log("bar"); baz(); } void baz() { Logger.log("baz"); System.out.println(“Hello, world!“); } Add logging instruction at beginning of each method Tedious if number of methods is large The logging behavior is dependent on the program 3
Cross-cutting Concerns Logging is a prime example of a cross-cutting concern Definition: A behavior that affects multiple modules in traditional OOP 4
Aspect-Oriented Programming (AOP) Programming paradigm that addresses cross- cutting concerns Separation of a software system‘s cross- cutting concerns from its core logic Aspect = a cross-cutting concern Base code = the core logic (traditional OOP) Program = base code + set of aspects 5
AOP Solution public aspect LoggerAspect { Pointcut: „WHEN?“ pointcut methodInvocation() : execution(* *(..)); before() : methodInvocation() { MethodSignature signature = (MethodSignature) thisJoinPoint.getSignature(); Logger.log(signature.getMethod().getName()); } Advice: „WHAT?“ } Logging is represented as a new aspect Completely decoupled from the rest The aspect can be reused for any other OO program 6
Intent of the Paper Proponents of AOP claim... It provides better modularization It is more readable It is more maintainable (suggested by another study) What about the development time? The paper tries to answer: “Under what circumstances does AOP reduce the development time ?“ Important: this question is only asked for cross-cutting concerns 7
Assumption of the Authors Assumption: “The more code targets a cross -cutting concern affects, the more it pays out to use AOP“ Rationale: For logging only 3 methods it is easier to simply add 3 lines of code, instead of writing an aspect. 8
Experimental Setup 1 target application (small game of 9 classes) 20 subjects (students with 1.5h AOP experience) 9 tasks (extensions) to be implemented To be done using both AOP (AspectJ) and OOP (Java) Development time for a task was measured from the first code change until all test cases pass 9
Tasks Task # code Code targets sim. ≠ 1. Logging 110 ≠ 36 2. Parameter Null = 3. Synchronization 52 = 4. Player Check 4 = 5. Notify Observers 19 = 6. Observers Null 15 ≠ 7. Refresh Constraint 8 ≠ 8. Label Value Check 6 = 9. Level Check 7 10
Variance Analysis “What causes the different development times?“ The development time potentially depends on two factors : the task the language • Result of 2-factor ANOVA ( an alysis o f va riances) : The task has an important effect The language has an effect The effect of the language depends on the task (interaction effect) 11
Variance Analysis (2) Effect F value p value Main effect of task 55.02 ~0 Main effect of language 13.75 0.001 Interaction effect of task and language 9.85 ~0 12
Equality of Development Times “For what tasks does the choice of language result in different development times?“ For each task there are 20 samples of the AO and OO development time A Wilcoxon test was performed to check which of the following hypotheses hold: H 0 : the development times for AO and OO are equal H 1 : they are not equal 13
Task # code Code targets sim. ≠ 1. Logging 110 ≠ 2. Parameter Null 36 = 3. Synchronization 52 = 4. Player Check 4 5. Notify = 19 Observers = 6. Observers Null 15 7. Refresh ≠ 8 Constraint 8. Label Value ≠ 6 Check = 9. Level Check 7 n/a n/a All tasks as one 14
Task # code Code All targets sim. devs ≠ + 1. Logging 110 ≠ + 2. Parameter Null 36 = 3. Synchronization 52 0 = - 4. Player Check 4 5. Notify = - 19 Observers = - 6. Observers Null 15 7. Refresh ≠ - 8 Constraint 8. Label Value ≠ - 6 Check = 9. Level Check - 7 n/a n/a - All tasks as one 15
Task # code Code All Fast Slow targets sim. devs OO OO devs devs ≠ + + 1. Logging 110 0 ≠ + 2. Parameter Null 36 0 0 = - 3. Synchronization 0 0 52 = - - - 4. Player Check 4 5. Notify = - - - 19 Observers = - - - 6. Observers Null 15 7. Refresh ≠ - - - 8 Constraint 8. Label Value ≠ - - - 6 Check = 9. Level Check - - - 7 n/a n/a - All tasks as one n/a n/a 16
Task # code Code All Fast Slow Fast Slow targets sim. devs OO OO AO AO devs devs devs devs ≠ + + + 1. Logging 110 0 0 ≠ + 2. Parameter Null 36 0 0 0 0 = - - 3. Synchronization 0 0 0 52 = - - - - - 4. Player Check 4 5. Notify = - - - - - 19 Observers = - - - - - 6. Observers Null 15 7. Refresh ≠ - - - - - 8 Constraint 8. Label Value ≠ - - - - - 6 Check = - 9. Level Check - - - 0 7 n/a n/a - All tasks as one n/a n/a n/a n/a 17
Threats to Validity Authors: The experiment was done in different sessions Not all received exactly the same tutorial Learning curve of subjects ignored Are the tasks representative? My opinion: Are the statistics expressive? (only 20 samples) Subjects were all AOP novices (only 1.5h of learning) What about other AOP languages apart from AspectJ? 18
Conclusion “Under what circumstances does AOP reduce the development time ?“ 1. if the developers are experienced ; 2. if the number of code targets is large (≥36); 3. if the OOP code snippets to be inserted are different from each other. 19
Questions? 20
Recommend
More recommend
