Demonstrations

Demo Madness

A “blitz” demo overview where each demo presenter gets a
few minutes time to grab your attention and make you want to see their demo in full.

Pavilion Ballroom

Forum Demonstrations (45 min)

Junior A (Wednesday, Friday), Junior B (Thursday, Friday)

Marc Eaddy, Columbia University

Abstract (click)

At AOSD 2006, we presented Phx.Morph, a static byte-code weaver based on Microsoft's industrial-strength back-end compiler framework. This year we present Wicca, a dynamic weaver that uses Phx.Morph and the .NET 2.0 Edit-and-Continue API to weave .NET 1.0, 1.1, and 2.0 executables at runtime. Wicca employs a novel noninvasive breakpoint weaving approach that allows advice to be invoked in-process and to have access to join point context.

We reveal the power and flexibility of Wicca through a series of demos of static, dynamic, byte-code, and breakpoint weaving. We will also demonstrate our innovative Statement Annotation mechanism and show how it modularizes heterogeneous concerns and enables fine- grained advising. Here is a summary of the demos:

• SimpleDraw - I will use the same aspect to add display change notification to graphical objects for three different weaving scenarios: static byte-code weaving, dynamic byte-code weaving, and breakpoint weaving.
• Visitor - I will adapt a class hierarchy at runtime to support the visitor pattern.
• Concern Coverage - We show the result of a reverse engineering exercise where we annotated each statement of a program with the name of the concern(s) it implements. We then weave the program to collect concern coverage data for a test run.

Glassbox: Application Monitoring and Troubleshooting with AOP

Ron Bodkin, New Aspects of Software

Abstract (click)

Glassbox is an open source troubleshooting agent for Java applications that uses aspect-oriented programming to discover applications, track performance, and automatically diagnose common problems. Glassbox's goal is to automate the grunt work of troubleshooting common problems, and free the expert to solve core technical problems. Glassbox uses AspectJ to provide low overhead effective monitoring without needing to "bake in" instrumentation up front. Glassbox also provides an easy to install and easy to use AJAX Web client.

I will illustrate how Glassbox 2.0 identifies problems, how it works, and how to extend it with AspectJ, Spring AOP, and with Java code. Glassbox also provides a great platform on which to build application monitoring, allowing those with less experience to gain benefits from and to start learning AOP. Glassbox is modular, so it’s easy to add monitors for more problems, additional analysis and operations as desired as plugins or as open source contributions.

Glassbox uses aspects extensively, both for monitoring and in its internal implementation such as for handling feature variations (e.g., allowing application-specific plug-in extensions), to isolate errors, and for summarization. I will review how we use AOP and how we load-time weaving to deliver an effective solution.

D3:
Thu 14:00
Fri 11:00

MRAT: Multidimensional Requirements Analysis Tool

Robert Waters, Lancaster University
Ruzanna Chitchyan, Lancaster University
Awais Rashid, Lancaster University

Abstract (click)

The Multidimensional Requirements Analysis Tool (MRAT) is an Eclipse plug-in that supports composition and analysis of aspect-oriented requirements specifications. It consists of an editor and multiple views for cross-referencing, understanding and visualising mutual influences of requirements-level concerns. The analysis algorithm composes concerns and finds temporal problems, revealing the root cause and resolution for some conflict types.

This demonstration will briefly introduce the XML-based Requirements Description Language (RDL) supported by MRAT and focus on how MRAT supports analysis of crosscutting requirements. The RDL that MRAT uses is multidimensional in nature and hence makes no base / aspect distinction between requirements-level concerns. Crosscutting influences between concerns are specified in terms of structural and behaviour semantics of concerns. MRAT is able to reason about the implicit and explicit semantics of these influences by analysing the compositions. Analysis of multidimensional compositions (i.e., with no base / aspect distinction) is a non-trivial task since the potential number of interactions is very high. Besides, the compositions may contain 'hidden' implicit semantics with ambiguous and complex contexts. Given that errors in requirements cause exponential problems in later stages of systems engineering, MRAT's ability to identify hidden conflicts is helpful in reducing the potential of costly change and improving requirements correctness.

D4:
Thu 14:45
Fri 11:45

EA-Miner: a Tool for Identifying and Structuring Aspect-Oriented Requirements

Américo Sampaio, Lancaster University
Awais Rashid, Lancaster University

Abstract (click)

This demonstration presents how the EA-Miner tool, implemented as an Eclipse plug-in, provides automated support for mining various types of concerns from a variety of early stage requirements documents and how these concepts can be structured into specific aspect-oriented requirements models (e.g., viewpoints-based).

We will show how EA-Miner utilizes natural language processing techniques to automate the identification and structuring of the candidate elements (e.g., viewpoints, early aspects) which are presented to the user using different visualisation mechanisms in Eclipse. The visualizations enable the user to see the requirements allocated to the concerns as well as inspect the crosscutting relationships between concerns showing where a specific concern affects others (e.g., over which requirements of several viewpoints a security aspect is applied).

Moreover, we will also present how initial specification documents such as a word file containing an initial AORE description of the requirements can be generated as well as how the tool can be integrated with other AORE tools (e.g., the multi-dimensional requirements analysis tool, MRAT).

D5:
Wed 14:00
Fri 11:45

SoQueT: Query-Based Documentation of Crosscutting Concerns

Marius Marin, Delft University of Technology
Leon Moonen, Delft University of Technology & CWI
Arie van Deursen, Delft University of Technology & CWI

Abstract (click)

SoQueT aims to support consistent documentation of crosscutting concerns in source code by using a set of pre-defined queries. Each query describes a typical relation and implementation idiom of crosscutting concerns, which we recognize as a concern *sort*. A sort query can be parameterized in a dedicated user-interface to document crosscutting concerns in the system under investigation as sort instances. Such instances are building blocks that can be composed in a concern model to describe more complex relations or design decisions in the code. The tool allows the user to load existing concern models, to (re-)run queries describing sort instances, and to navigate the results of the query (i.e., the participants in the concern implementation).

The demo will show how SoQueT can be used to document crosscutting concerns, and how this documentation is useful for program comprehension and software evolution purposes. We will show SoQueT on JHotDraw - a model application and popular drawing framework.

D6:
Wed 14:45
Wed 16:45

Made in MAKAO

Bram Adams, Ghent University

Abstract (click)

Besides source code, a software system consists of a myriad of other artifacts, of which the build process has a prominent role. Without it, the system is useless. This means it needs to evolve in parallel with the source code in order to build, and hence deploy and test, the whole system. As such, the build system closely mimics the architecture of the system under consideration. Yet, as it lies at the meta-level, it has to deal with totally different, lower-level (build) concerns. And here lies the catch: little tool support exists to help people bridge the gap between the source-code dimension and the build process. We present MAKAO (Makefile Architecture Kernel for Aspect Orientation), a re(verse)-engineering framework for build systems. Its goals are to represent a build’s dependency graph in a digestible way, to enable flexible querying of all build-related data and to allow efficient re-engineering of the build and even of configuration scripts. For the latter, we applied the aspect-oriented notions of join point, advice, pointcut and weaving to the build domain. MAKAO can deal with a wide range of build-related problems, but this demo focuses on the integration of new tools in a legacy system.

D7:
Wed 11:00
Fri 11:00

Modeling and detecting aspect composition conflicts using graph
transformations

Wilke Havinga, University of Twente
Tom Staijen, University of Twente
Lodewijk Bergmans, University of Twente

Abstract (click)

Aspect-interaction is currently a hot topic in the AOSD community. In particular, multiple aspects composed may have unintended effects on the augmented system. We demonstrate tools to automatically detect composition conflicts. Our work consists of two different parts. The first focuses -currently- on conflicts caused by AspectJ introductions. The second focuses on semantic conflicts among aspects at shared join points in Composition Filters. Both parts use a very similar approach based on graph transformations. Both approaches use a start graph and a set of graph transformation rules as input. The graph is generated from a program’s source code. The transformation rules are a general (or formal) specification of the composition semantics. In this demonstration we show that it is relatively easy to specify composition semantics in graph transformation rules. Then we will illustrate that given these specifications only a small step is needed for detecting aspect-composition conflicts.

Guiding aspect-oriented service composition in WS-BPEL and Padus

Mathieu Braem, Vrije Universiteit Brussels
Niels Joncheere, Vrije Universiteit Brussels
Kristof Geebelen, Katholieke Universiteit Leuven
Kris Verlaenen, Katholieke Universiteit Leuven

Abstract (click)

Current languages for web service composition suffer from poor support for separation of concerns. In this demo we present our approach that improves on current state-of-the-art aspect-oriented technology for web service composition. We show our visual service creation environment and our aspect-oriented extension for the WS- BPEL language, named Padus.

On top of Padus, a framework supporting the definition of concern- specific languages (CSLs) is developed. This allows for the easy creation of languages that are specific to a single concern, like billing, security, or logging. The framework translates CSL aspects to Padus aspects, which can then be woven into WS-BPEL processes. Both Padus and the CSL framework are integrated in a high-level visual service composition environment, which guides the service developer in creating valid service compositions.

In this demo, we demonstrate the procedure that is followed from designing a composition to deploying it on a web service orchestration engine. We design an abstract composition using a graphical web service composition editor. The resulting composition is then visually configured with concrete services, and verified for compatibility with these services. Next, we deploy both Padus aspects and concern-specific aspects on the composition. Finally, the concern- specific aspects are translated to Padus, the aspects are woven into the composition, and the resulting composition is visualized. This composition is then ready for deployment on any standard WS-BPEL engine.

Tabletop Demonstrations (30 min)

Junior A

Hans-Arno Jacobsen, University of Toronto
Michael Gong, University of Toronto

Abstract (click)

This software demonstration showcases the aspect-oriented C programming language extension and supporting compiler developed by the Middleware Systems Research Group at the University of Toronto.

The compiler translates code written in the aspect-oriented language extension into ANSI-C code. The resulting code can be compiled by any ANSI-C compliant compiler, like for example gcc.

The demonstration shows:

1. Aspect-oriented C code snippets to illustrate various features of the language extension.
2. How to model various aspects in the implementation of a binary search tree (based on the GNU libavl library) including the configuration and build process involved in building various version of the library (with and without aspects.) The aspects shown include multi-threading, parent pointer support, memory and performance profiling, and tracing of tree operations.
3. How to develop system calls, tracing and profiling concerns for the OS/161 teaching operating system running on the SYS/161 MIPS-1 hardware emulator.
4. How to model the trace concern in NUT/OS, an embedded, real-time operating system. This is shown by running a test program on the embedded system with and without the aspect present.

More information about the project can be found at the project web site: http://www.aspectc.net

Pascal Durr, University of Twente
Lodewijk Bergmans, University of Twente
Mehmet Aksit, University of Twente

Abstract (click)

In this demo we will present the latest incarnation of Compose*: StarLight. This version has been partially funded by a large company in the Netherlands. The sole purpose of this funding is to maturate Compose*, to apply it in a large scale industrial context. In this demo we will present several crosscutting concerns we encountered in this industrial context. Secondly we show which key requirements we addressed during the introduction of the Compose* tool. We also show the new features we introduced into the tooling, most notably: performance improvements through code generation. Before, Compose* was perceived with interest for its unique features, but the interpreter based implementation prohibited industrial acceptance. With the new code generation facilities of StarLight, these limitations were removed and the tool has been accepted by a large company in the Netherlands. We will also present other new features like debugging support and integration with Visual Studio 2005. Finally, we will show how one easily adds a new filter type to the Compose* environment.

Lingdong Ye, University of British Columbia
Kris de Volder, University of British Columbia

Abstract (click)

Writing correct AspectJ pointcuts is hard. This is partly because of the complexity of the pointcut language and also partly because it requires understanding how the pointcut matches across the entire code base.

In this demonstration we present PointcutDoctor, an extension of AJDT tools which helps developers write correct pointcuts by providing immediate diagnostic feedback.

PointcutDoctor provides several kinds of information for a given pointcut. Firstly it shows which join points (shadows) the pointcut matches or doesn’t match. This helps a developer to verify whether her pointcut is correct. Furthermore, PointcutDoctor also provides an explanation of why the pointcut matches or does not match a given join point(shadow). This information helps a developer diagnose the cause of problems—unintended matches or failures to match certain join points—in her pointcut.

Jonas Bonér, Terracotta
Eugene Kuleshov, Terracotta

Abstract (click)

Clustering (and caching) is a crosscutting infrastructure service that has historically been implemented with API-based solutions. As a result, it has suffered from the same code scattering and tangling problems as other crosscutting concerns.

In this demonstration we will show how Aspect-Oriented Programming (AOP) can help to modularize clustering and turn it into a runtime infrastructure Quality of Service. We will show how AOP can be used to plug in directly into the Java Memory Model, which allows us to maintain the key Java semantics of pass-by-reference, garbage collection and thread coordination across the cluster, e.g. essentially cluster the Java Virtual Machine (JVM) underneath the user application instead of the user application directly.

We will also show you tools that allows you to get runtime visibility into your clustered application, viewing shared state, transaction rates, cache hits etc. as well as developer tools for declarative clustering of arbitrary Java application.