Kevin Sullivan
ABSTRACT
Aspect-oriented (AO) methods and languages seek to enable the preservation of design modularity through mappings to program structures, especially where common (object-oriented) languages fail to do so. The general claim is made that AO approaches enable the modularization of crosscutting concerns. The problem that we address is that it is unclear to what extent such claims are valid. We argue that there are meaningful bounds on the abilities of past, present, and future languages to succeed in this regard---bounds that we need to understand better. To make this idea concrete we exhibit a significant bound: Component integration (Sullivan & Notkin 1992, 1994) is not adequately modularizable in AspectJ
- Xerox Corporation, AspectJ Team, The AspectJ Programming Guide, 2001, available at URL http://www.aspectj.org/ as of this writing.Google Scholar
- Elrad, T., R. E. Filman and A. Bader, guest editors, Communications of the ACM 44, 10, Special Issue on Aspect-Oriented Programming, October 2001. Google ScholarDigital Library
- Gamma, Helm, Johnson and Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994. Google ScholarDigital Library
- Kalet, I. J., J. P. Jacky, M.M Austin-Seymour, S. M. Hummel, K. J. Sullivan and J. M. Unger, "Prism: a New Approach toGoogle Scholar
Index Terms
- Non-modularity in aspect-oriented languages: integration as a crosscutting concern for AspectJ
Recommendations
An object-oriented framework for aspect-oriented languages
AOSD '12: Proceedings of the 11th annual international conference on Aspect-oriented Software DevelopmentAspect-orientation is a mechanism for modularizing cross-cutting concerns that has been added to many existing software engineering languages. The implementations of aspect-oriented language extensions, however, are typically tied to a specific base ...
Aspect-Oriented workflow languages
ODBASE'06/OTM'06: Proceedings of the 2006 Confederated international conference on On the Move to Meaningful Internet Systems: CoopIS, DOA, GADA, and ODBASE - Volume Part IMost available aspect-oriented languages today are extensions to programming languages However, aspect-orientation, which is a paradigm for decomposition and modularization, is not only applicable in that context In this paper, we introduce aspect-...
Incremental aspect weaving: an approach for faster AOP learning
SAC '15: Proceedings of the 30th Annual ACM Symposium on Applied ComputingAspect oriented programming (AOP) is a programming paradigm that provides mechanisms for encapsulating cross-cutting concerns. Developers who want to learn AOP often experiment with aspects and different Pointcuts on their existing code bases to try and ...
Reviews
Mario Kupries
This paper focuses on unsubstantiated design issues and the lack of modularization in currently applied aspect-orientated languages. The position taken by the authors is that aspect-oriented languages enforce modularity, and, thus, enable the modularization of crosscutting concerns. Aspect-oriented languages attempt to overcome the inherent nonmodularity of object orientation and other traditional programming paradigms. An extension of the Java language, AspectJ, is intended to be successful at preserving modularity and reducing crosscutting issues in the development and reuse of software systems. The analysis of aspects between existing and under-development programming languages is intended to further the evolution of modular design. In fact, a vast majority of programming languages suffer from crosscutting. As an explanation of this drawback, the authors attempt to show that the bounds of aspect-orientation are not necessarily currently substantiated. The paper offers a solid understanding and a systematic explanation of the topic at hand; modularity and aspects are defined and explained consistently, followed by assessment techniques for modularity, and techniques for integrating aspects into object-oriented languages. The authors' explanations are illustrated by an example of an abstract, describing relationships between arbitrary units in a modular structure, and a concrete program-technical realization in the form of AspectJ code. The examples are supplemented with figures. Especially beneficial are the enumerations of the consequences of lacking modularity and of prominent aspect-oriented languages that lack modularity implementations. This abundance of detail, combined with the authors' ability to discuss each part and to connect the parts in a logical way, makes the paper come across as a product of careful, precise, and extensive thought about the subject. Overall, this paper is insightful in showing the benefits of addressing modularity and aspects using AspectJ, but at the same time proving its limitations: aspect integration is not fully modularized in AspectJ, due to limited aspect instances. Online Computing Reviews Service
Access critical reviews of Computing literature here
Become a reviewer for Computing Reviews.
Comments