Brown-Northeastern Aspects Day

Organizers

Kevin Sullivan, Unifying Aspect-Oriented and Object-Oriented Language Design

I will present the dissertation work of my PhD student, Hridesh Rajan, on the design, implementation, and early evaluation of a programming language design that unifies aspects in the style of AspectJ and traditional object-oriented classes. The problem we address is that current aspect language designs and methods are unduly complicated and contrained by an unnecessary distinction between class and aspect modules. We present a unification of aspect- and object-oriented approaches based on an extension of the traditional class. The unified model does not compromise the expressiveness of the state-of-the-art aspect languages; it improves the conceptual integrity of aspect language designs; and it significantly improves module compositionality, enabling the use of aspect mechanisms to separate integration concerns and higher order concerns effectively. I will describe the design and implementation of Eos-U, an AspectJ-like language based on C# that supports our unified class and aspect construct as the basic unit of modularity. The underpinnings of Eos include support for aspect instantiation under program control, instance-level advising, advising as a generalized alternative to object-oriented explicit and implicit invocation and overriding, and provision of a separate join-point-method binding construct.

Mario Südholt, Aspect Languages: AspectJ and Beyond

Aspect-Oriented Programming promises means for the modularization of so-called crosscutting concerns of large-scale applications. Central to this endeavor is the definition of aspect languages whose main constructs are pointcuts (which define where to an aspect modifies an application) and advices (which define the modification itself). Currently, most aspect languages employ the abstractions similar to those of AspectJ, the best-known aspect-oriented language. However, recently a number of different, partially more expressive aspect languages have been put forward.

In this talk, we first introduce the principal characteristics of aspect languages from a language design point of view. In a second part, we motivate why extensions of the AspectJ model are useful in the context of different crosscutting concerns of several large-scale applications, including e-commerce applications, system-level applications and concerns involving the Linux kernel. Finally, we survey a set of proposals for language constructs (and corresponding implementation mechanisms) for such crosscutting concerns.

Daniel Jackson, Are Aspects New?

Everyone knows that the problem that aspect-oriented programming (AOP) addresses is an old one—indeed, perhaps the fundamental problem of software development. Fewer people know about some of the interesting attempts at aspect-like modularity that preceded AOP. I'll explain some of them, and speculate on why there weren't successful (and maybe on whether AOP will be).

Robert Filman, Wrappers, Aspects, Quantification and Events

 For many applications, most code is not devoted to implementing the primary input-output functionality, but instead addresses other concerns, such as reliability, availability, responsiveness, performance, security, and manageability. Conventional programming practice requires the programmer to keep all these other "ilities" in mind while coding and to explicitly invoke behavior at exactly the right places to achieve them.

Aspect-Oriented Programming (AOP) is an emerging technology for allowing the separate specification and coding of multiple concerns, while nevertheless providing mechanisms to automatically meld these separate expressions into working programs.

This talk traces my increased understanding of the possibilities for Aspect-Oriented System Development (AOSD). I begin by describing our past work on the Object Infrastructure Framework (OIF). OIF is a distributed object technology that implements separate concerns as dynamic wrappers on object components. Interesting elements of OIF include its mechanisms for application and aspect communication, its dynamic nature, and its language for expressing where aspects apply to base code.

OIF was an early AOP system. The second part of the talk examines the characteristics of AOP and AOSD, leading to quantification/obliviousness observation and focusing attention on the join point models of aspect systems.

In the concluding part of the talk I describe our current work on Trinity, a ``most general join point'' system for AOP.