[aosd-announce] AO Tutorial at OOPSLA: XPI's and the Net Options Value of Modularity in Design

[Kevin Sullivan]

Dear Friends: I've been asked to alert you to an upcoming tutorial that I'll
be giving at OOPSLA. Here's the most recent abstract. I hope to see many of
you there. I believe we can have an excellent discussion. 

 

Kind Regards,

Kevin Sullivan

University of Virginia

 

Abstract:

 

The term aspect-oriented refers to programming methods and mechanisms meant
to improve modularity in software design and implementation. The  field of
"AOP" is a response to shortcomings in the way that procedural and
object-oriented abstraction techniques tend to separate concerns. In some
important cases where it would be profitable to represent key aspects of
program behavior in separate modules, traditional methods end up scattering
them across multiple classes, resulting in a loss of technically and
economically valuable modularity. AOP provides a set of new ideas and
programming mechanisms that expand the space of available modular design
architectures so as to enable and promote modularization of these typically
crosscutting concerns, and thus the creation of economically more valuable
software systems. 

 

Unfortunately, not all of the newly enabled design structures are better,
and some are much worse-a fact that has been a source of skepticism
regarding AOP. In a nutshell, it's easy to go awry when using AOP
mechanisms, leading to programs with much worse modularity properties than
they would have had had they been designed in traditional ways. The deeper
insight is that we are just beginning to understand how to manage the use of
new and expressive AOP mechanisms to gain the expected benefits without the
obvious problems. Recent research on generalized concepts of the structure
and economic value of modularity in software design, based on the notions of
design rules and design structure matrices (DSMs) of Baldwin and Clark of
the Harvard Business School, and adapted to software design by Sullivan (the
presenter) and Griswold, have recently led to significant improvements in
our understanding of how to use AOP in ways that are now grounded in
fundamental concepts of information hiding modularity in software
engineering. 

 

This tutorial will teach participants both about AOP, per se, and about this
new way of reasoning about and using it. Topics to be covered will include
the following: the problems that AOP is intended to solve; the novel
mechanisms of languages such as AspectJ; how they create valuable new
architectural possibilities; the dangerous tradeoffs involved in a number of
popular approaches to using these mechanisms, e.g., the idea of
obliviousness; the concept of design rules and the economic value of
modularity in design; design structure matrices and how we can use them to
understand traditional OO and novel AOP strategies in simple unified way;
how DSM's help to reveal the problematical aspects of oblivious AOP; how
DSMs and the idea of design rules leads to a new concept of explicit
interfaces for modular AOP, namely the crosscut programming interfaces, or
XPIs, of Sullivan and Griswold. The tutorial will make these ideas concrete
with examples from both simple systems (e.g., figure editor) and complex
network middleware for self-healing overlay networks (Liebeherr's Hypercast
system). In a nutshell, we will build up to presenting, and will present,
recent work on XPIs, including theoretical background and practical ways of
applying the theory in languages such as AspectJ. Participants will gain
exposure not just to AOP, per se, but also to the very important ideas of
Baldwin and Clark on the economics of modularity design architectures.

 

 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: /pipermail/announce_aosd.net/attachments/20060922/24481384/attachment.html