Detail

Aspectizing Design Patterns and Exception Handling: The Devil is in the Details

It is usually assumed that the implementation of certain kinds of
crosscutting concerns can be always better modularized by the use of
aspect-oriented programming (AOP). Exception handling and several
well-known design patterns are often cited in introductory AOP texts
as the “killer applications” of aspect-orientation. However, there is
no empirical evidence about the scalability of AOP in more realistic
scenarios, such as aspectual composition of design patterns and
aspectization of heterogeneous forms of exception handling. This talk
will present the results and conclusions of two in-depth
investigations of the adequacy of the AspectJ language for
modularizing error handling and design patterns. The studies consisted
in refactoring a number of existing realistic applications so that the
code responsible for implementing compositions of design patterns and
complicate error recovery strategies were moved to separate
aspects. The case studies are based on distinct application domains,
including a CVS plugin, a web-based information system, a reflective
middleware, and a measurement tool. We have performed quantitative
assessments of several systems based on five fundamental modularity
attributes, namely separation of concerns, coupling, cohesion, interface
simplicity, and conciseness. Our investigation also included a
multi-perspective
analysis of the refactored systems, including (i) the reusability of
the aspectized code, (ii) the beneficial and harmful aspectization
scenarios, and (iii) the scalability of AOP in the presence of complex
aspect interactions.