Aspectual Collaborations: Combining Modules and Aspects

Abstract

Complex behavior often resists clean modularization in object-oriented languages. Aspectoriented programming tackles this problem by providing ¤exible module boundaries that can span and partition classes. However, in order to achieve this ¤exibility, valuable modularity mechanisms, such as encapsulation and external composition, are lost. The ability to separately compile or reason about a modular unit is also compromised. We propose that this tradeoff is not necessary, and that by expressing aspects as part of our modules, we can restore lost modular properties while maintaining aspectual features. As a concrete demonstration, we present the main features of Aspectual Collaborations, and show how these interact to combine modularity with aspectual behavior. The expressiveness of Aspectual Collaborations, AspectJ, and Hyper/J are compared using a challenge problem, allowing us to estimate the effectiveness of the approach.

Open Modules: Modular Reasoning About Advice

“…Lieberherr et al describe Aspectual Collaborations, a construct that allows programmers to write aspects and code in separate modules and then compose them together into a third module [15]. Since they propose a full aspect-oriented language, their system is much richer and more flexible than ours, but its semantics are not formally defined.…”

MAO: Ownership and Effects for More Effective Reasoning About Aspects

“…These interfaces are computed from a whole program's configuration and provide a bi-directional mapping from methods to associated advice, and from advice to advised methods. This 23 certainly is helpful in reasoning about control effects of advice that may apply at a given join point or program point. As such it could be used in conjunction with MAO's annotations to determine whether the advice being applied has potential control effects.…”

“…Generally, these systems attach interfaces to base code elements that either permit or prohibit advice from being applied, or describe what advice has been applied. So, Pointcut Interfaces [17], Open Modules [1,26], Aspectual Collaborations [23], and XPIs [15,31] all require code to declare or specify the join points to which aspects may be attached. In contrast our focus is on specifying aspects and their effects.…”

Controlling the complexity of software designs

“…This is one way of limiting the power of aspects and still gaining significant benefits from them. Other approaches are presented in [6,33,50]. We also need mechanisms so that code can protect itself from aspects without interfering too much with the power of aspects.…”