Replacing Object-Oriented Design Patterns with Intrinsic ...vranic/pub/AO-OOPatterns-pres.pdfAddison-Wesley, 1995. 3/23. Replacing Object-Oriented Design Patterns with Intrinsic Aspect-Oriented

Replacing Object-Oriented Design Patterns with Intrinsic Aspect-Oriented Design Patterns

Replacing Object-Oriented Design Patterns withIntrinsic Aspect-Oriented Design Patterns

Pavol Bača Valentino Vranić

Institute of Informatics and Software EngineeringFaculty of Informatics and Information TechnologiesSlovak University of Technology, Bratislava, Slovakia

[email protected]

ECBS-EERC 2011, September 5–6, 2011, Bratislava, Slovakia

1 / 23


Overview

1 Object-Oriented Design Patterns and Aspect-OrientedProgramming

2 Replacing Object-Oriented Patterns

3 Evaluation: Design Pattern Composition

4 Summary

2 / 23


Object-Oriented Design Patterns and Aspect-Oriented Programming

Design Pattern Composition

Object-oriented design patterns—and especially GoF1

patterns—are a part of software developers’ everydayvocabularyPatterns are applied mostly individually (contradictory to theidea of pattern languages), but they are often composedThe very application of an object-oriented pattern involves itbeing interleaved with application logicComposition makes patterns interleaved with each other

1E. Gamma. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley,1995.

3 / 23



A Pattern as a Concern: How to Separate It

A pattern may be viewed as a concernWe’d like to have concerns separatedBut patterns appear to crosscut application logic concernsWhere object-orientation can’t help anymore, there comesaspect-orientation: separation of crosscutting concernsAspect-oriented reimplementations of object-oriented patternsresolve pattern crosscutting of application logic concerns2

A qualitative and quantitative assessment showed this is not sowith respect to pattern composition3

2J. Hannemann and G. Kiczales. Design pattern implementation in Java and AspectJ. In Proc. of17th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, andApplications, OOPSLA 2002, Seattle, Washington, USA. ACM, 2002.

3N. Cacho et al. Composing design patterns: A scalability study of aspect-oriented programming. InProc. of 5th International Conference on Aspect-Oriented Software Development, AOSD 2006, Bonn,Germany. ACM, 2006.

4 / 23



Aspect-Oriented Patterns and Composition

There are patterns intrinsic to aspect-oriented programming:not applicable in object-oriented programmingThese patterns often can be composed by simply includingthem in the implementation without having to modify itWe observed that some aspect-oriented reimplementations ofobject-oriented patterns actually represent intrinsicaspect-oriented patterns

5 / 23



Use Intrinsic Aspect-Oriented Patterns Instead

Our idea: use intrinsic aspect-oriented patterns to benefit fromtheir simple and separated compositionThis involved

Finding intrinsic aspect-oriented patterns that correspond toaspect-oriented reimplementations of object-oriented patternsEvaluating them in composition to see whether they behave asthe original object-oriented patterns

We worked with three aspect-oriented patternsDirectorWorker Object CreationCuckoo’s Egg

6 / 23


Replacing Object-Oriented Patterns

The Director Case

Director was our original inspiration for its ability to replacemany object-oriented patterns, but. . .It actually addresses the problem of separating the genericreusable behavior from the specific implementation in classesThis is done by enforcing the corresponding roles of behaviorto classesKey parts of the GoF patterns “replaced” by Director remainDirector is actually just oblivious to the problems addressed bythese patterns and can’t be counted as their substitution

7 / 23



Worker Object Creation (1)

Worker Object Creation4 separates the functionality frommanaging its execution by enveloping it into a worker objectA worker object is then sent for execution to a differentcontext—usually in another thread

void around() : <pointcut> {Runnable worker = new Runnable () {

public void run() {proceed();

}invoke.Queue.add(worker); // execution − possibly deferred

}

4R. Laddad. AspectJ in Action: Enterprise AOP with Spring Applications. Second edition, Manning,2009.

8 / 23




A popular application: catch the calls to GUI controls in Swingand have them executed in its event dispatching thread

EventQueue.invokeLater(new Runnable() {public void run() {

. . .}

});

Proxy shields the functionality of an object by another, proxyobjectThis can be done at object creation time by providing theproxy object

9 / 23




An example: optimizing toolbar creation

public aspect ToolbarProxy {public ToolbarImpl.new(ToolbarProxy a) {}ToolbarImpl around(): call(ToolbarImpl.new()) {

return new ToolbarImpl(this) { // the proxy classprivate ToolbarImpl toolbarImpl;

public void setVisible(boolean visible) {if (toolbarImpl == null)

toolbarImpl = proceed();

toolbarImpl.setVisible(visible);}... // other methods using the original class instance

};}

} 10 / 23



Cuckoo’s Egg

Cuckoo’s Egg5 enables to exchange an object of one type withan object of another typeThis is achieved by capturing constructor or factory methodcallspublic aspect MyClassSwapper {

public pointcut myConstructors(): call(MyClass.new());

Object around(): myConstructors() {return new AnotherClass();

}}

Applied instead of three GoF patterns: Singleton, AbstractFactory, and FlyweightSingleton: catch a constructor and look up an existing instance

5R. Miles. AspectJ Cookbook. O’Reilly, 2004.11 / 23



Cuckoo’s Egg Instead of Abstract Factory

Abstract Factory is used to provide an interface for creatingfamilies of objects without specifying the classesAbstract factory methods can be introduced by an aspect

12 / 23



Cuckoo’s Egg Instead of Flyweight

Flyweight is used to avoid a huge memory consumption by anumber of equal objectsLike Singleton, but involves checking the existence of eachinstance

13 / 23


Evaluation: Design Pattern Composition

The Study

To check that our pattern replacements are valid beyond theirisolated application, we conducted a small study based on theimplementation of a toy graphic tool6

The tool supports drawing simple geometric shapes andwriting text2D and 3D mode statically configured before the tool is startedThe toolbar, tool buttons, and image gallery created upon auser demand

6http://fiit.stuba.sk/~vranic/proj/dp/Baca/aoOoPatterns.zip

14 / 23

http://fiit.stuba.sk/~vranic/proj/dp/Baca/aoOoPatterns.zip



The Patterns

The study provided an opportunity to implement six pairs ofpattern compositions

Abstract Factory + SingletonProxy + Abstract FactoryProxy + SingletonSingleton + FlyweightAbstract Factory + FlyweightProxy + Flyweight

These have been implemented in three ways by1 Object-oriented original pattern implementation2 Aspect-oriented pattern reimplementation3 Intrinsic aspect-oriented patterns

15 / 23



Aspect-Oriented Reimplementation

The aspect-oriented reimplementation was developed todemonstrate an aspect-oriented solution is indeed possibleHannemann–Kiczales7 aspect-oriented reimplementations ofGoF patterns have been applied

7J. Hannemann and G. Kiczales. Design pattern implementation in Java and AspectJ. In Proc. of17th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, andApplications, OOPSLA 2002, Seattle, Washington, USA. ACM, 2002.

16 / 23



Implementation with Intrinsic Aspect-Oriented Patterns

Aforementioned intrinsic aspect-oriented patterns have beensuccessfully applied in the paired compositions of GoF patternsA few deviations from the original object-orientedimplementation showed up:

No explicit Singleton implementation: the only instance ofAbstract Factory—i.e., the Cuckoo’s Egg aspect—is ensuredby an implicit issingleton() aspect instantiation modifierA conflict between the pointcuts implemented in Cuckoo’s Eggand Worker Object Creation: resolved by a declare precedencestatement

17 / 23



Observations

Intrinsic aspect-oriented patterns are less generic than theaspect-oriented reimplementations of object-oriented patterns(many based on Director)But it seems intrinsic aspect-oriented patterns affect otherpatterns in composition to a lesser degree resulting

Simpler compositionA pattern is removed by simply excluding it from the build

18 / 23



Quantitative Assessment

Improved composability reflects significantly in separation of(crosscutting) concernsThus, the most relevant metrics for this study are those aboutseparation of concernsHowever, coupling and cohesion are also important becausethey express how modular the implementation isWe applied metrics used by Garcia et al.8 and Cacho et al.9

8A. Garcia et al. Modularizing design patterns with aspects: A quantitative study. In Proc. of 4thInternational Conference on Aspect-Oriented Software Development, AOSD 2005, Chicago, Illinois,USA. ACM, 2005.

9N. Cacho et al. Composing design patterns: A scalability study of aspect-oriented programming. InProc. of 5th International Conference on Aspect-Oriented Software Development, AOSD 2006, Bonn,Germany. ACM, 2006.

19 / 23



Metrics

Separation of concerns:Concern Diffusion over Components (CDC)Concern Diffusion over Operations (CDO)Concern Diffusion over Lines of Code (CDLOC)

Coupling:Coupling Between Components (CBC)Depth Inheritance Tree (DIT)

Cohesion:Lack of Cohesion in Operations (LCOO)

Size:Lines of Code (LOC)Number of Attributes (NOA)Weighted Operations per Components (WOC)

20 / 23



Quantitative Assessment: Results

In general, intrinsic aspect-oriented patterns had better results

21 / 23


Summary

Summary (1)

Intrinsic aspect-oriented design patterns can be used toimplement object-oriented design patternsThey achieve a better composability compared to both originalimplementations of object-oriented design patterns and theiraspect-oriented reimplementationsWorker Object Creation can be successfully used instead ofProxyCuckoo’s Egg can replace Singleton, Abstract Factory, andFlyweightDirector is not a substitutionThe validity of these substitutions has been confirmed in apattern composition studyBetter composability of intrinsic aspect-oriented patterns hasbeen observed and measured

22 / 23


Summary

Summary (2)

However, the study was limited in sizeOnly four GoF patterns have been successfully substituted byintrinsic aspect-oriented patternsFurther work:

Extend the study to other patternsEmploy other aspect-oriented languagesExplore how replacement of object-oriented patterns fits intothe context of refactoring

23 / 23

Documents

Replacing Object-Oriented Design Patterns with Intrinsic ...vranic/pub/AO-OOPatterns-pres.pdfAddison-Wesley, 1995. 3/23. Replacing Object-Oriented Design Patterns with Intrinsic Aspect-Oriented