Live demonstrations of systems that use or support aspect-oriented software development provide an opportunity for companies and universities to show their latest work to the growing number of people interested in adopting AOSD, and also an opportunity for those people to learn about emerging technologies through discussion of technical details with the developers themselves. Demonstrations will be presented by the developers, who will focus on technical details and be able to answer technical questions.

D1: FLiP -- Product Line Derivation Tool

Wed, 16:00-16:45
Fri, 11:45-12:30

Paulo Borba, Universidade Federal de Pernambuco
Fernando Calheiros, Meantime Mobile Creations
Vilmar Nepomuceno, Meantime Mobile Creations
Andrea Menezes, Meantime Mobile Creations
Sérgio Soares, Universidade de Pernambuco
Vander Alves, Lancaster University

With the growing academic and industrial interest in Software Product Lines, one area demanding special attention is tool support development, which is a pre-requisite for widespread software product lines practices adoption. In this demo, we present a suite of tools consisted of 3 modules: FLiPEx, FLiPG and FLiPC. FLiPEx is a refactoring tool that implements code transformations for extracting product variations from Java classes to AspectJ aspects. FLiPEx interacts with FLiPG, which integrates with Feature Model tool for updating a software product lines feature model accordingly to code transformations, which, for example, might turn mandatory into optional features. FLiPG interacts with the FLiPC tool that is responsible for using the information stored in FLiPG to build the final products. FLiP has been designed and tested in the context of real mobile game software product lines.

D2: Enforcing Principle of Least Authority on Existing Java Applications Through AspectJ

Wed, 14:00-14:45
Fri, 11:45-12:30

Brett Cannon, University of British Columbia
Eric Wohlstadter, University of British Columbia

An important property of secure, trusted applications is that they only make use of resources on a user’s machine in a way that is predictable and causes no harm. Our research is focused on supporting development of applications which are trusted in this respect but are composed of components which may have been developed without attention to ensuring a high level of trust in their use of resources. We propose a general approach based on AOP for monitoring program actions which imply some authority to be granted to less trusted third-party components. The approach is supported by a tool-driven, dynamic analysis for developers to create the aspect implementation during testing. We present a case study of applying the approach on a desktop application for browsing RSS news feeds, called RSSOwl.

D3: Current Developments in Context-oriented Programming

Wed, 11:45-12:30
Thu, 14:00-14:45

Pascal Costanza, Vrije Universiteit Brussel
Robert Hirschfeld, Hasso-Plattner-Institut Potsdam

There is an increased need for applications that can dynamically adjust their behavior to the context of use. Two years ago, we have introduced ContextL, our first language extension that explicitly supports Context-oriented Programming (COP). In COP, programs consist of partial class and method definitions that can be selected and combined at runtime as needed. Employing runtime adaptations to class and method definitions, COP encourages continually adjusting behavior of programs according to their context.

Since then, we have carried out a number of successful application and language experiments which show that the basic building blocks of COP remain stable. Among others, we have implemented multiple context-dependent views, coordination of screen updates, context-dependent discerning of phone calls, and selecting context-dependent billing schemes. In other settings, we have developed ContextS for Smalltalk/Squeak, and ContextJ for Java. We have also taken first steps towards design and the requirements engineering for context-aware applications.

In our demonstration, we will show the following: the basic language constructs for COP; the development of comprehensive non-trivial examples; the current state of the art in COP: language extensions, example applications and software development support; future work: promising next steps currently being undertaken in several research groups.

D4: Automatically Locating Framework Extension Examples

Wed, 16:00-16:45
Thu, 11:45-12:30

Barthélémy Dagenais, McGill University
Harold Ossher, IBM T.J. Watson Research Center

Using and extending a framework is a challenging task whose difficulty is exacerbated by the poor documentation that generally comes with the framework. Even in the presence of such documentation, developers often require implementation examples to help them understand their task. We propose an approach to automatically locating implementation examples from a code base given light-weight documentation of a framework. Based on our experience with concern-oriented documentation, we created a tool that uses the framework documentation as a concern template and that finds instances of this template in a code base using a greedy algorithm. The concern instances represent self-contained and structured implementation examples: the relationships and the roles of parts composing the examples are uncovered and explained. As an early step toward validation, we found that we were able to correctly identify 85% of the implementation artifacts of four Eclipse text editors based on a short tutorial.

D5: Model-Driven Theme/UML

Wed, 16:00-16:45
Thu, 14:45-15:30

Cormac Driver, Trinity College Dublin
Andrew Carton, Trinity College Dublin
Andrew Jackson, Trinity College Dublin
Siobhán Clarke, Trinity College Dublin

The Model-Driven Theme/UML tool integrates aspect-oriented design with model-driven engineering. The tool was motivated by a desire to address complexity in the design of ubiquitous computing systems through modularisation while addressing platform heterogeneity though transformations. We also wished to investigate round-trip engineering with a view to addressing the fragile pointcut problem.

The tool facilitates automatic transformation from requirements to Theme/UML, an aspect-oriented modelling language, and supports concern composition, model-to-model transformations and model-to-code synthesis to address platform heterogeneity. A set of concerns designed with Theme/UML can be composed to form an object-oriented or aspect-oriented platform-independent model (PIM). Object-oriented PIMs can be automatically transformed to J2ME and .NET CF platform-specific models (PSMs) and subsequently to source code. An aspect-oriented PIM can be synthesised directly to AspectJ code. The tool supports evolution of the aspect-oriented code, PIM and requirements through round-trip engineering to address the fragile pointcut problem.

Our demo will illustrate the aspect-oriented, model-driven software development process facilitated by the Model-Driven Theme/UML tool. The demo will showcase the capabilities of the tool at each stage of the process, from requirements engineering and Theme/UML system modelling, to object and aspect-oriented model transformations, source code generation and code/model evolution.

D6: The Object Teams Development Tooling: an Aspect-Oriented JDT

Wed, 14:00-14:45
Fri, 11:00-11:45

Stephan Herrmann, Technische Universität Berlin
Marco Mosconi, Technische Universität Berlin

Software development using vi and a command line compiler is a thing of a distant past. Even loosely integrating a custom compiler into Eclipse will not meet the expectations of today’s developers, who are accustomed to a plethora of convenience and assistance features made available in a consistent UI. In this regard Eclipse’s Java Development Tooling (JDT) sets a standard for Java development. The Object Teams Development Tooling leverages the high quality of the JDT and consistently extends its functionality and UI for development with the aspect-oriented and role-based programming language ObjectTeams/Java (OT/J).

This demonstration will present how the original functionality of the JDT can seamlessly be applied in OT/J development, too. We will put special emphasis on how the JDT in its entirety has been extended to account for the new concepts and features of OT/J.

We will conclude with a brief look at the realization of the OTDT, which is significantly facilitated by using OT/J for the OTDT itself. This implementation utilizes the OT/Equinox technology, which enabled us to non-invasively adapt the JDT. As a result in the OTDT Java and OT/J don’t exist side by side, but within the OTDT the JDT actually fully supports OT/J.

D7: The Aspect Manager 2010 — An Infrastructure for Reusable Aspects

Wed, 11:00-11:45
Fri, 11:00-11:45

Uwe Hohenstein, Siemens AG
Iris Groher, University of Linz
Regine Meunier, Siemens AG
Daniel Wiese, Siemens AG

Aspect-orientation (AO) has obviously a high potential for reuse. But there is still a lack of aspect repositories and adequate infrastructures. This means that currently a lot of manual configuration work is necessary to setup Eclipse and build tools in order to benefit from aspect repositories. Moreover, using pre-defined aspects often requires a lot of AO knowledge. In this demonstration, we present the Aspect Manager, an infrastructure based upon Eclipse, AJDT, and Maven2, supporting reuse of aspects effectively. The Aspect Manager relies on a repository for downloadable, reusable and pre-defined aspects. The demonstration shows how to use the Aspect Manager to improve an existing application: Pre-defined aspects help to improve the bad performance by using caching and asynchronous method invocation. Another aspect helps to implement Undo/Redo management in a minute.

Our approach puts emphasis on ease of usage. Applying aspects can easily be done by annotating methods. Particularly, no manual configuration of Eclipse and Maven is necessary. The essential part is an Eclipse plug-in that allows programmers to select an aspect. Thanks to the Aspect Manager, the code is automatically downloaded from an aspect repository server so that aspects become immediately applicable — without any manual work.

D8: JQueryScapes: customizable Java code perspectives

Wed, 14:00-14:45
Thu, 11:45-12:30

Lloyd Markle, University of British Columbia
Kris De Volder, University of British Columbia

JQueryScapes is a flexible, query-based source code browser, developed as an Eclipse plug-in. JQueryScapes builds on top of JQuery. Like with JQuery a JQueryScapes user can define his or her own code views on-the-fly by formulating logic queries and running them against the source code. In this manner, JQuery provides the developer with a wide variety of crosscutting as well as non-crosscutting views within a single tool. Additionally, JQueryScapes allows the developer to create an unlimited number of JQuery views and link these views together into complex, multi-paned browsing perspectives called “JQuery scapes”. We will demonstrate how JQueryScapes allows a developer to very quickly prototype a full-featured browsing environment tailored to visualizing and navigating crosscutting concerns based on project and situation specific structural queues such as coding idioms, naming conventions and custom Java 1.5 annotations.

D9: An Overview of Mirjam and WeaveC: an Industrial-strength Aspect-oriented Language and Weaver for C

Wed, 11:45-12:30
Fri, 11:00-11:45

István Nagy, ASML Netherlands B.V.
Remco van Engelen, ASML Netherlands B.V.
Steven de Brouwer, ASML Netherlands B.V.

In this demonstration, we elaborate on the features of an industrial-strength aspect-oriented programming language and weaver for large-scale software development. First, we give an overview about the requirements of a general purpose aspect-oriented language that can handle crosscutting concerns in ASML software. We also outline a strategy on working with aspects in large-scale software development processes. In our design, we both re-used existing aspect-oriented language abstractions and proposed new ones to address the issues that we identified in our analysis. After the introduction, we are going to present the features of the language (with a special focus on expressiveness) and weaver (with a special focus on robustness and performance) through a running example.

D10: Omniscient Debugging of Aspects with TOD

Wed, 11:00-11:45
Thu, 11:45-12:30

Guillaume Pothier, University of Chile
Éric Tanter, University of Chile

Debugging is a tedious and costly process that demands a profound understanding of the dynamic behavior of programs. Debugging aspect-oriented software is even more difficult: to implement the semantics of aspects, a number of implicit activities are performed at runtime, whose relation to source code is not direct to grasp.

In this demonstration we show how omniscient debugging, a technique that consists in recording the activity of a program to later navigate in its history, can be extended to suit the particularities of aspect-oriented software. We implemented three new user interface abstractions for debugging AspectJ programs on top of the Eclipse plugin of the TOD omniscient debugger: collapsable event lists that permit to hide unwanted details of AOP activities, activity icons that to help understand AOP activities, and dynamic crosscutting views that help understand the interplay between aspects and base code at runtime.

By enhancing program understandability, improvements to the tooling associated with aspect orientation will encourage the widespread acceptance of this emerging paradigm.

D11: ALFAMA: Automatic DSLs for using Frameworks by combining Aspect-oriented and Meta-modeling Approaches

Wed, 16:45-17:30
Thu, 14:45-15:30

André Santos, University of Lisbon

At AOSD’07, a paper entitled “Framework Specialization Aspects” proposed a technique based on AOP for decomposing the extension points of an object-oriented framework into specialization aspects, enabling framework-based applications to be built in cohesive modules that can be mapped one-to-one to application concepts. Frameworks are enhanced with reusable abstract aspects, in order that applications can be built in concrete aspects which extend the former.

By taking advantage of the modularity benefits offered by specialization aspects, the task of developing a domain-specific language (DSL) for using the framework becomes facilitated, because the transformation of DSL concepts into application code becomes straightforward. ALFAMA is an Eclipse-based tool prototype that is capable of generating a DSL (defined as a modeling language in EMF) from a set of specialization aspects. The generated DSLs are capable of producing framework-based applications using the specialization aspects. The Eclipse RCP (Rich Client Platform) is used in the demonstration as the framework for which a DSL is generated.

D12: M4JPDD — Tool-Support for Modeling Join Point Designation Diagrams

Wed, 14:45-15:30
Fri, 11:45-12:30

Dominik Stein, University of Duisburg-Essen
Stefan Hanenberg, University of Duisburg-Essen

The design of join point selections is a pivotal task in Aspect-Oriented Software Development (AOSD). Join point selections designate those points in/of a program at which an aspect should take affect. The expressive means of pointcut languages of current aspect-oriented programming languages are usually limited in one or the other respect. Join Point Designation Diagrams (JPDDs) have been presented as a means to overcome this situation. They permit developers to render join point selections in a conceptually appropriate manner — despite of the capabilities of the particular pointcut language in use.

In this demonstration, a modeling tool for JPDDs is presented. It permits developers to draw control flow-based, state-based, workflow/dataflow-based, as well as structural join point selections. The demonstration will show when to use which kind in order to appropriately express the underlying conception of a join point selection. Furthermore, the tool permits to transform JPDDs into program code (for prevailing aspect-oriented programming languages). The tool has been implemented as an Eclipse-plugin. The demonstration will show how the tool may be used seamlessly in an aspect-oriented software development process based on the Eclipse-based development tools of prevailing aspect-oriented programming languages (e.g. AJDT, JAsCoDT, etc.).

D13: Deriving AO Software Architectures using the AO-ADL Tool Suite

Wed, 11:00-11:45
Thu, 14:00-14:45

Juan Valenzuela, University of Málaga
Luis Fernández, University of Málaga
Mónica Pinto, University of Málaga
Lidia Fuentes, University of Málaga

This demo will show how to describe aspect-oriented software architectures using the AO-ADL language and its tool support. This language allows us applying the separation of concern principle in the early phases of the development (early aspects). Besides, with the use of the MDD/MDA technologies, the AO-ADL Tool Suite provides the feature of establishing a relationship between the software architecture represented with the AO-ADL language and an equivalent model in UML 2.0, using the Ecore metamodel of AO-ADL for making the transformation. The primary aim is to show how to develop aspect-oriented software architectures by reusing previously developed components and connectors and by instantiating existing connector templates, being aided by our tools. Firstly, the software architect must import from the Component & Connector repository, or describe from scratch, the interfaces, components and connectors that will be part of the software architecture. After that, the software architect is able to describe a specific architecture using the elements stored in the repository. Following the software development life cycle, the user can finally generates an equivalent UML 2.0 description of the AO-ADL architecture created with the AO-ADL editors. This UML 2.0 model will be the input for the later detailed design process (out of the scope of this demo).

D14: Aquarium: Aspect-Oriented Programming for Ruby

Wed, 14:45-15:30
Thu, 14:45-15:30

Dean Wampler, Object Mentor, Inc.

Aquarium is an Aspect-Oriented Framework for the Ruby language. Built on top of Ruby’s metaprogramming facilities, it allows the programmer to implement aspects in Ruby without tricky metaprogramming. This demonstration will show examples of the Aquarium “Domain-Specific Language” and how it can be used to reduce the complexity of code examples taken from some well-known Ruby toolkits, such as Ruby on Rails.

Some of the goals for Aquarium include (i) demonstrating that even when a language has good metaprogramming facilities, explicit support for aspects provides the programmer improved productivity and code clarity, (ii) aspects are important in dynamically-typed languages as well as statically-typed languages, (iii) aspects are a useful tool for implementing Domain Specific Languages, and (iv) using aspects and writing pointcuts, in particular, should not be so difficult that only “expert” programmers can use them.

D15: Celadon: A Change Impact Analysis Tool for Aspect-Oriented Programs

Wed, 16:45-17:30
Thu, 14:00-14:45

Sai Zhang, Shanghai Jiao Tong University
Zhongxian Gu, Shanghai Jiao Tong University
Yu Lin, Shanghai Jiao Tong University
Jianjun Zhao, Shanghai Jiao Tong University

Aspect-oriented software development (AOSD) is gaining popularity with the wider adoption of languages such as AspectJ. However, after a long editing session, it may be tedious for programmers to find the change impacted parts in the program, due to the extensive use of sub-typing or dynamic dispatch in object-oriented programming language and the inherent semantic intricacies of aspectual features. To reduce the manual effort of assessing potential affected parts, we have developed a framework called Celadon to automate the change impact analysis for AspectJ programs. Celadon is implemented in the context of the Eclipse environment and designed as a plugin. It analyzes the source code of two AspectJ program versions, and decomposes their differences into a set of atomic changes together with their dependence relationships. Change impact is reported in terms of impacted program parts and affected tests. For each affected test, Celadon also identifies a subset of affecting changes that are responsible for the test’s behavior change.

This demonstration summarizes the technique and introduces the Celadon framework. We present how Celadon can help programmers improve change impact analysis during software evolution.



Hosted by Sponsored by In cooperation with

Instant Feedback