T13: Modular AOP Using Design Rules and XPIs

Sunday, Oct 22, from 13:30 to 17:00, E143

The term aspect-oriented refers to emerging programming mechanisms and software design practices that are meant to enable and achieve improved separation of concerns (abstraction and modularity) in computer program design and implementation. Researchers and practitioners in this field (henceforth AOP) are responding to significant observed shortcomings in the abilities of traditional object-oriented programming languages and design concepts to enable effective separation of concerns. Put simply, some important aspects of program behavior should be represented in separate modules, but traditional classes and associated composition mechanisms are not flexible enough to enable such decompositions. AOP languages provide new mechanisms for program decomposition and module composition, significantly expanding the spaces of available design architectures and modularly representable abstractions. Unfortunately, not all of the new possibilities are better and some are clearly much worse (a fact that has been a source of much skepticism regarding AOP). Moreover, some widely popularized ideas about how to use AOP clearly have the strong potential to lead designers astray, i.e., to program designs with dangerously poor modularity properties. Recent research on generalized concepts of modularity in software design, based on notions of design rules and design structure matrices (DSMs) have significantly improved our understanding of how to use AOP mechanisms in ways that are better grounded in fundamental concepts of software engineering to achieve improved separation of concerns without running amok.

In this tutorial we will introduce the problem that AOP is intended to solve; introduce the mechanisms of languages such as AspectJ and show how they expand the space of architectural possibilities and introduce some earlier, and in some ways problematical, ideas on how to use these mechanisms. We will explain how certain AOP strategies that have been widely advocated have the strong potential to lead designers astray. We will then introduce a generalized model and representational framework for modeling modularity in software design, based on notions of design rules and design structure matrices. We will then explain not only how these ideas dramatically clarify the nature of the problem with some earlier thinking on AOP, but in fact how they lead to a new solution in the concept of the crosscut programming interface, or XPI. We will make these ideas concrete with a range of examples, from toy systems to more complex networking middleware for self-healing overlay networks. In a nutshell, we will build up to presenting, and will present, recent work on XPIs -- the theoretical background and practical ways of applying the theory in languages such as AspectJ.

Intermediate: The tutorial will assume a reasonable sophisticated understanding of OOP but no deep knowledge of AOP. It will be self-contained. The background material will be of less interest to experienced AOP researchers and practitioners, but the more advanced material on design rules, on design structure matrices, and on the interpretation of these ideas to arrive at the notion of the XPI should be of interest to both researchers and advanced practitioners. 

Format: Powerpoint and hands on using attendees' laptops