One line of research within PLEIAD is the topic of Aspects, Dependencies and Interactions. Johan has been co-organiser of the ADI workshops at ECOOP 06 07 08

AO Requirements modeling in the Slot Machine Domain

We have studied the expressive capabilities for aspect interactions of selected AORE approaches. Our first case study is the Slot Machine (SM) domain. This has been published as part of ACM SAC 2009 [1]. Below you will find links to the requirements for SMs and the output resulting from the application of two AORE approaches: Theme/Doc [2] and Multi-Dimensional Separation of Concerns for Requirements Engineering [3].

The complete requirements list is separate in its own page.

The application of Theme/Doc is separate in its own page.

The application of MDSOCRE is separate in its own page.

[1] A. Zambrano, J. Fabry, G. Jacobson, and S. Gordillo. Expressing aspectual interactions in requirements engineering: experiences in the slot machine domain. In Proceedings of the 2010 ACM Symposium on Applied Computing (SAC 2010), pages 2161–2168. ACM Press, 2010 (doi pdf)

[2] E. Baniassad and S. Clarke. Theme: An approach for aspect-oriented analysis and design. In ICSE ’04: Proceedings of the 26th International Conference on Software Engineering, pages 158–167, Washington, DC, USA, 2004. IEEE Computer Society

[3] A. Moreira, A. Rashid, and J. Araujo. Multi-dimensional separation of concerns in requirements engineering. In Proc. 13th IEEE International Conference on Requirements Engineering, pages 285–296, 29 Aug.–2 Sept. 2005.

AO Design in the Slot Machine Domain

In the Slot Machine domain, we also studied the expressive capabilities for aspect interactions of selected AO Design appraches: Theme/UML [1] and Motorola WEAVR [2]. The results of this study: "Expressing Aspectual Interactions in Design: Experiences in the Slot Machine Domain" have been published at MODELS 2011. Most strikingly, we found that none of both approaches are suitable to express all kinds of aspect interactions we are faced with.

[1] S. Clarke, E. Baniassad: Aspect-Oriented Analysis and Design. The Theme Approach. Object Technology Series, Addison-Wesley, Boston, USA(2005)

[2] T. Cottenier, A. van den Berg, T. Elrad: Motorola weavr: Aspect and model- driven engineering. Journal of Object Technology 6(7), 51–88 (2007)

AspectMaps: A Scalable Visualization of Join Point Shadows

The implicit invocation mechanism of AOP introduces an additional layer of complexity in the construction of a system. This can make it harder to understand how base system and aspects interact and thus how the system will behave. For example, when writing pointcut definitions, it is not always clear for a developer where the aspect will intervene in the base code. This can then lead to situations where the pointcut either captures too many join points (false positives), or where certain join points that were intended to be captured, are not (false negatives). One variant of this problem is the so-called fragile pointcut problem (Kellens, ECOOP 2006).

AspectMaps is a software visualization tool built to aid the understanding of aspect-oriented software systems. It provides a scalable visualization of implicit invocation. AspectMaps visualizes selected join point shadows (a.k.a. shadow points): locations in the source code that at run-time produce a join point. AspectMaps visualizes the shadow points where an aspect will execute, and if multiple aspects will execute, the order in which they are specified to run. This results in a visualization that clearly shows how aspects cross-cut the base code, as well as how they interact at each join point. AspectMaps is a scalable visualization mainly due to its use of selective structural zooming. The structure of source code is shown at different levels of granularity, as specified by the user.

More information on AspectMaps can be found here

Aspect Coordination for Web Applications in Java and Ruby

This work is by Arturo, which extends previous work on coordinating aspect behavior at runtime. It shows a scenario where aspect coordination is needed in the context of collaborative web applications. It analyses the trade-offs derived from applying our coordination approach using two different platforms for the implementation of such applications: Java and Ruby. Implementing aspect oriented systems in these platforms is substantially different. These differences make it necessary to perform an in-depth analysis of each feature needed for aspect coordination, evaluating the abilities of each platform.

This work is reported in the paper with the same name, accepted at the XXVIII Conferencia Internacional de la Sociedad Chilena de Ciencia de la Computación. The full version (10 pages) is available here.