Microsoft Research AOP Goes .NET Workshop 2005

Microsoft Research hosted a one-and-a-half-day AOP Goes .NET workshop on Monday, November 14, 2005 and Tuesday, November 15, 2005 in Redmond, Washington. The topic of the workshop was aspect-oriented programming (AOP) with a focus on the Microsoft .NET platform. The workshop brought together academic and industrial researchers who are working on this topic. The goals for the meeting were to exchange knowledge on AOP in the .NET context, analyze and compare existing solutions, identify open problems and share challenges, describe ongoing work to address open problems, and combine efforts by increasing joint work.

8:30–9:15

Breakfast

9:15–9:30

Welcome

9:30–10:30

Session 1: General Presentations

9:30–10:00

Aspect-Oriented Programming: The Past, Present, and the Future
Mehmet Aksit, University of Twente

This talk will first give some industrial examples to motivate the applicability of Aspect Oriented Programming (AOP) techniques in practice. Second, an overview will be given on the evolution of AOP languages during the last decade. Third, based on the overview, AOP language models and concepts will be defined. Next, the Composition Filters model will be positioned in this context. This talk will be concluded by identifying some open research issues.

10:00–10:30

Modular Programming with Crosscut Programming Interfaces (XPI’s)
Kevin J. Sullivan, University of Virginia

Aspect-oriented languages, such as AspectJ and Eos, provide new mechanisms for decomposing systems into modules and composing modules into systems. Today, common ways of using these mechanisms result in aspects that are tightly coupled to complex and changeable implementation details. Wide-scale deployment of AOP to the .NET community requires a more modular approach to AOP. We introduce the concept of the crosscut programming interface (XPI) as a practical solution. This work is joint with William Griswold (UCSD) and our students.

10:30–11:00

Break

11:00–12:30

Session 2: Specific Approaches

11:00–11:30

Phx.Morph
Marc Eaddy, Columbia University

We extended Phoenix, Microsoft’s industrial-strength back-end compiler framework, to create Phx.Morph, a static byte-code weaver that enables Open Classes and Aspect-Oriented Programming. We describe how the development of the Phoenix project itself, a large application in its own right, helped motivate and validate our work. We discuss how Open Classes can improve the separation of concerns in Phoenix, including how it can provide a superior solution for client extensibility over traditional object-oriented solutions. We also describe how Phoenix provides a framework for building powerful program transformation tools.

11:30–12:00

Rapier-LOOM.NET — A Dynamic Aspect Weaver for .NET
Andreas Polze and Wolfgang Schult, Potsdam University

This presentation addresses dynamic updates on running applications. Such updates require mechanisms to bring applications into a reconfigurable state. Existing solutions typically use special frameworks, tools, or both, introducing new programming paradigms and rules. This complicates the software development process. The usage of dynamic aspect weaving enables us to perform updates transparently during runtime without additional compilation steps or programming constraints in the software development process, even in multithreaded environments. Runtime reconfiguration of software can be modularized as a cross-cutting concern. We demonstrate how our approach can be applied to an existing application by using our dynamic aspect weaving solution, Rapier-LOOM.NET.

12:00–12:30

Eos
Hridesh Rajan, Iowa State University

In this talk, I will discuss the implementation of Eos, an aspect-oriented extension of C# for .NET Framework. The key features of Eos include a unified language model, support for aspect-instantiation under program control, instance-level advising, advising as a generalized alternative to object-oriented method invocation and overriding, and provision of separate join point method binding construct.

12:30–13:30

Lunch

13:30–15:00

Session 3: Concepts

13:30–14:00

The Design of the Compose* Language Implementation for the .NET Platform
Lodewijk Bergmans, University of Twente

In this presentation we will address some of the challenges and design considerations regarding the implementation of the Compose* language for the .NET platform. Some of the key issues that will be addressed are: a language-agnostic aspect language, about the weaving model, the challenge of handling method introductions and other interface extensions, maximizing platform-independence, the extensible, repository-based, compile-time architecture and the flexible, interpreter-based, run-time architecture.

14:00–14:20

SetPoint
Alan Cyment, University of Buenos Aires

SetPoint has semantic pointcuts at the core of its structure. In opposition to what we call syntax-based pointcuts, SetPoint aims at making everyday AOP usage a little more intuitive by giving the developer the chance to write her pointcuts based on the different perspectives the system architect, analyst, or herself originally devised. Its main ideas are based on concepts heavily used by the Semantic Web, MDA, ADLs and, obviously, existing AOP projects.

14:20–14:40

Design Rules for Modularity
Eric Wohlstadter, University of British Columbia

This work investigates an extension to the AspectJ pointcut language to allow developers to express design rules for modularity. The language allows the detection of patterns that constitute symptoms of bad modularity and “code smells.” We are developing a toolset that leverages the static analyses provided by the Microsoft Phoenix compiler.

14:40–15:00

A Language Extension for Compile-Time Reflection
Manuel Fahndrich, Microsoft Research

In this talk, I will present a relatively small extension to C# supporting the construction of program transforms. Program transforms allow programmers to generate code and other declarations in a simple declarative manner at compile-time. The transforms consist of a pattern and a template. When the pattern matches, the template produces new declarations and code in the context of the pattern match. The goal of the work is to provide a limited form of generative programming without the need for a reflection API and complicated code emission through MSIL. Instead, both patterns and templates are written as C# with meta-variables connecting matched artifacts in the patterns and templates. The templates can be type checked prior to their application and the resulting code should always be type correct.

15:00–15:30

Break

15:30–16:00

Discussion: Categorization and Assessment

16:00–17:00

Session 4: Technology

16:00–16:15

AspectDNG — A Static Aspect Weaver
Jean-Baptiste Evain, ESSAIM, France

AspectDNG is an Open Source aspect weaver targeting the .net framework. Its development started more than two years ago and we are now close to a 1.0 stable version. AspectDNG is built upon Mono.Cecil, a .NET assembly manipulation library.

16:15–16:30

The Orthogonal Weaving Model
Husein Armouti, Allstate Insurance Company

The Orthogonal Weaving Model (OWM) is a dynamic framework by which .NET developers can implement aspects. OWM does not add any language extensions and as such does not require any special source code parsing or attribute programming. Core functionality and aspect are both native .NET classes; advice can be any method of any class in any assembly. Weaving rules are configured in an XML file or programmatically. Weaving is done dynamically upon calling the AspectWeaver.NewInstance() function on a type for the first time; System.CodeDom and System.Reflection namespaces are utilized to generate an in-memory assembly to host the woven class, which acts as interceptor. OWM provides state-dependent advice activation where advice methods are conditionally activated. Componentized aspects eliminate the need to redeploy or shutdown the system when a change is required; a file system watcher monitors the weaving rules file for changes.

16:30–16:45

XL-AOF—An Extensible Lightweight Aspect-Oriented Framework for Distributed Applications
Fabian Schmied, Vienna University of Technology

In distributed application development, a high number of cross-cutting concerns can be found. AOP is an excellent paradigm to capture requirements like transaction safety, security, or persistence. Unfortunately, the adoption of AOP for distributed applications is often hampered by technological necessities, for example, special compilers or platforms, difficult application deployment, or new programming languages. Our approach is therefore to provide a lightweight aspect environment for the .NET platform. By using existing language and runtime concepts, such as custom attributes, code generation, and anonymous methods, we build an aspect-oriented environment that is easily adoptable, but powerful enough to facilitate distributed application development.

16:45–17:00

Debugging Support for AOP
Mike Stall, Microsoft

We present some relevant parts of the CLR Debugging Services. In particular, we discuss what debugging technologies are available for enabling AOP .NET debugging scenarios. That is, we discuss the debuggability of different CLR technologies for rewriting IL, restrictions on the PDBs, and the split between the platform API and the debugger application.

17:00–17:30

Break

17:30–18:30

Panel: Are We Ready for AOP in the .NET Platform?
Panelists: Mehmet Aksit, University of Twente; Edward Jezierski, Microsoft; Lars Mehrmann, Siemens; Kevin J. Sullivan, University of Virginia; Pierre van de Laar, Philips; Allen Wirfs-Brock, Microsoft
Moderator: Ralf Lammel, Microsoft

The panelists and the audience will engage in a discussion about Aspect-Oriented Programming (AOP) and the .NET platform. In particular, we hope to cover questions like the following:

• What’s the potential of AOP if it became more mainstream in .NET?
• What .NET features and capabilities are readily related to AOP?
• Why is AOP technology currently not yet an integral part of the .NET platform?
• What is the technical and conceptual maturity level of existing approaches?
• How would .NET need to develop to become a strong AOP platform?
• What are the risks, if any, of adding AOP support to .NET?

The panelists are expected to bring forward the various — sometimes contrarian — views on these questions. The audience is asked to challenge the panelists by means of controversial questions.

19:00

Bus departs

19:30

Dinner

8:30–9:15

Breakfast

9:15–10:15

Walkaround Demonstrations

10:15–10:30

Form Breakout Groups

10:30–11:00

Break

11:00–12:00

Breakout Groups
Topic examples: Survey or comparison of technology, survey or comparison of language concepts, barriers or research agenda of future work

12:00–12:15

Report from Breakout Groups

12:15–12:30

Workshop Wrap-up