SEKE 2012 Proceedings - Knowledge Systems Institute

some previous work [2, 7], this work did not propose a concrete
model for advice execution in threads. Most popular
AOP languages effectively ignore concurrency; in AspectJ
the thread that reaches a joinpoint will execute the advice,
and nothing is specified beyond that. Ansaloni and Binder
[2] introduced a framework that enables asynchronous advice
execution by collecting advice invocations in a buffer
and executing the advices in a separate thread. Douence
et al. [9] created Concurrent Event-based AOP (CEAOP)
which defines concurrent AOP using labeled transition systems,
and overcomes some of the limitations of synchronization
and thread communications. CEAOP supports concurrency
in the underlying program, and concurrent execution
of advice with the base program by allowing the advice
body executions in parallel.
5. Conclusion
Fundamental to AOP is the notion of a joinpoint, which
has traditionally been thought of as a point in the program
execution that can practically be mapped to points in the
program itself. We argued here that the notion of a joinpoint
really should be a defined interval of program execution
whose defining conditions may or may not be related
to loci in the program itself. This change better captures
existing usage of AOP, in particular with the around advice
application and the treatment of threads, and it allows thinking
about new and novel directions for AOP. We also argue
here that this change in joinpoint thinking also helps to better
separate advice execution from pointcut definition, and
allows the imagination of new types of advice execution that
have wide applicability in the software engineering field.
In this paper we are only presenting ideas of how the abstractions
in AOP might be generalized and expanded. We
are not attempting to claim that it is straightforward to put
these ideas into practice. Indeed the existing ideas within
AOP are arguably there because it was somewhat obvious
how to implement them efficiently. Other ideas have followed
similar paths. The idea of tracematches as joinpoint
designators was introduced first, then followed by work in
optimizing their detection [6].
Working out other details as well, such as how to create
a usable advice language that embodies these ideas without
overwhelming the user, may be problematic. Certainly
some of the success of AOP, as with other technologies,
is found in the combination of power and simplicity. Yet
the continuing research in AOP should consider breaking
away from ideas that limit what can be imagined and implemented,
and should explore radical new and novel approaches
to AOP.
References
[1] M. Achenbach and K. Ostermann. A Meta-Aspect Protocol
for Developing Dynamic Analyses. In Proc. 1st Int’l Conf.
on Runtime Verification, pages 153–167, Berlin, Heidelberg,
2010. Springer-Verlag.
[2] D. Ansaloni, W. Binder, A. Villazón, and P. Moret. Parallel
Dynamic Analysis on Multicores with Aspect-Oriented Programming.
In 2010 Conference on Aspect-Oriented Software
Development (AOSD), pages 1–12, 2010.
[3] T. Aotani and H. Masuhara. SCoPE: an AspectJ Compiler for
Supporting User-Defined Analysis-Based Pointcuts. In Proc.
6th Int’l Conf. on Aspect-Oriented Software Development,
pages 161–172, New York, 2007. ACM.
[4] P. Avgustinov, T. Ekman, and J. Tibble. Modularity First:
A Case for Mixing AOP and Attribute Grammars. In Proc.
7th Int’l Conf. on Aspect-Oriented Software Development,
AOSD ’08, pages 25–35, New York, 2008. ACM.
[5] W. Binder, P. Moret, D. Ansaloni, A. Sarimbekov,
A. Yokokawa, and E. Tanter. Towards a Domain-Specific
Aspect Language for Dynamic Program Analysis: Position
Paper. In Proc. 6th Workshop on Domain-Specific Aspect
Languages, pages 9–11, New York, 2011. ACM.
[6] E. Bodden, L. Hendren, and O. Lhoták. A Staged Static
Program Analysis to Improve the Performance of Runtime
Monitoring. In ECOOP, pages 525–549, 2007.
[7] W. Cazzola, A. Cicchetti, and A. Pierantonio. Towards a
Model-Driven Join Point Model. In Proceedings of the 2006
ACM Symposium on Applied Computing, SAC ’06, pages
1306–1307, New York, 2006. ACM.
[8] F. Chen and G. Roşu. MOP: an Efficient and Generic Runtime
Verification Framework. In OOPSLA ’07: Proc. 22nd
ACM SIGPLAN Conf. on Object Oriented Programming,
Systems, and Applications, pages 569–588, New York, NY,
USA, 2007. ACM.
[9] R. Douence, D. Le Botlan, J. Noyé, and M. Südholt. Concurrent
Aspects. In Proceedings of the 5th International Conference
on Generative Programming and Component Engineering,
GPCE ’06, pages 79–88, New York, 2006. ACM.
[10] R. Dyer and H. Rajan. Nu: a Dynamic Aspect-Oriented Intermediate
Language Model and Virtual Machine for Flexible
Runtime Adaptation. In Proc. 7th Int’l Conf. on Aspect-
Oriented Software Devel., pages 191–202. ACM, 2008.
[11] G. Kiczales and M. Mezini. Aspect-Oriented Programming
and Modular Reasoning. In Proceedings of the 27th International
Conference on Software Engineering, ICSE ’05, pages
49–58, New York, 2005. ACM.
[12] S. Kojarski and D. H. Lorenz. Modeling Aspect Mechanisms:
a Top-Down Approach. In Proc. 28th International
Conference on Software Engineering, pages 212–221, New
York, 2006. ACM.
[13] E. Marques, L. Veiga, and P. Ferreira. An Extensible Framework
for Middleware Design Based on Concurrent Event-
Based AOP. In Proc. 9th Int’l Workshop on Adaptive and
Reflective Middleware, pages 26–31, New York, 2010. ACM.
[14] H. Masuhara, Y. Endoh, and A. Yonezawa. A Fine-Grained
Join Point Model for More Reusable Aspects. In Proc.
Fourth ASIAN Symposium on Programming Languages and
Systems, (LNCS 4279), pages 131–147, Nov. 2006.
157