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
Kevin Sullivan, University of Virginia: Kevin Sullivan is Associate Professor and Endowed Faculty Fellow of Computer Science at the University of Virginia. Kevin received his Ph.D. in Computer Science from the University of Washington in Seattle, Washington in 1994. He received an NSF Career Award in 1995, the first ACM Computer Science Professor of the Year Award from undergraduate students in 1998, a University Teaching Fellowship in 1999, the Harold Morton Jr. Teaching Prize in 2000, and a Virginia Engineering Foundation Endowed Faculty Fellowship in 2003. He founded Exelix LLC, which commercializes Galileo, his software tool for advanced dynamic fault tree analysis. Among his professional activities are serving as associate editor for the Journal of Empirical Software Engineering and the ACM Transactions on Software Engineering and Methodology, and on the program and executive committees of numerous conferences, including the ACM SIGSOFT Symposium on the Foundations of Software Engineering (FSE), the International Conference on Software Engineering (ICSE), Aspect-Oriented Software Development (AOSD), the ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL), and the International Workshop on Economics-Driven Software Engineering Research. Sullivan is the author or co-author of four book chapters and over forty peer-reviewed journal and conference papers.