(Click to view a larger image.)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, andcombine efforts by increasing joint work.

Workshop Agenda

Monday, November 14, 2005

• 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 (XPIs)
  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

Tuesday, November 15, 2005

• 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

Workshop Location

Microsoft Corporation
West Campus, Building 113, Room 1021
14870 N.E. 31st Way
Redmond, WA 98052