PROG logo TRESE logo

Joint Belgian & Dutch AOP Workshop 2003


Welcome to the website of the Belgian & Dutch AOP Workshop which was held in January 2003 at the University of Twente. There are unfortunately no workshop proceedings available, but below you can still find some information on what was presented at the workshop. We hope all the participants enjoyed the day and left with some new insights. Perhaps we'll see you next year!

Dates & Deadlines

October 25th 2002 (extended) Deadline for sending in topic and abstract for presentation
November 8th 2002 (delayed) Invitations for presentation will be sent out
December 13th 2002 Precise date and schedule for the workshop will be announced
January 21st 2003 Workshop itself (changed)

Organization

The workshop is organized by members of the TRESE and PROG labs. The organizers are Joost Noppen & Kris Gybels, with co-organization by Maurice Glandrup & Johan Brichau. You can reach us at aopworkshop@prog.vub.ac.be.

Location

The workshop will be held at the University of Twente (Twente, The Netherlands)

You can find information on how to reach the university at the AOSD 2002 conference site.

There's also a PDF map available of the campus itself. Hotel Logica is nr. 26 on the map, Hotel Drienerburcht is nr. 15. The workshop itself is organized in building 9A. In building 9A there will be signs guiding you to the workshop rooms, which are L200 and L204.

Mailinglist

You can subscribe to the mailing list or change your subscription settings on the mailinglist page.

Schedule

9.00 - 9.30 Welcome messages, short Introduction and research Interest statement
9.30 - 10.45 Poster Session 1
10.45 - 12.00 Poster Session 2
12.00 - 13.30 Lunch
13.30 - 17.00 Camp AOSD
17.00 - 18.00 Wrap-up "What did I learn"

Abstracts for poster presentation

Below are the abstracts of the poster presentations that will be given at the workshop.

Is accounting a cross-cutting concern?

Bert-Jan van Beijnum

As a starting point, we present the results of a case-study on applying AspectJ for implementing an accounting system for a distributed Video Streaming Service. The service consists of client applications, a broker application, video server(s) and an accounting server. Four different accounting systems have been implemented using AspectJ based on different choices made for the measured resources usage and the flow of accounting information. The case study demonstrates that implementing accounting management can benefit from AOSD. Another line of reasoning that AOSD is useful could be as follows. Provisioning of a telematics service session implies the cooperation of several modules or components. For accounting, the usage of (potentially) each component needs to be captured or logged ( standard records exists for this purpose, such as Call Detail Records and IP Detail Record) the total charge for the session is based on the collected set of detail record. Giving the analogy between accounting and logging, and the fact that logging is the standard example of a cross-cutting concern, this 'proves' that accounting is a cross-cutting concern. Hence accounting falls in the class of problems for which AOSD provides a solution. However, this line of reasoning neglects the operational issues and area specific developments that are to be considered as well. In this contribution we identify and discuss a number of these, such as: legacy systems and protocols, inter-domain issues, interaction between accounting management and QoS management, emerging accounting architectures (e.g. TeleManagement Forum, IETF and IPDR Inc.). Finally, with the above in mind, we would like to bring forward a set of questions as to promote discussion during the workshop.

Conceptual model of concern-based design and software composition

Lodewijk Bergmans

A given design problem usually includes multiple concerns. The separation of concerns principle aims to provide guidelines for identifying and decomposing the problem into these concerns. Failing to achieve the right separation of concerns will directly result in increased complexity and reduced maintainability. We explicitly distinguish the category of compositions that are not composable by design,Êand the category where composabilty is fully supported at the design level, but not by specific composition mechanisms. ThisÊtalkpresentsÊa conceptual model of concern-based design and software composition, and a set ofrequirements that design-level concerns must fullfil to be composableÊat the programming language level at all (though not necessarily).

Dynamic Object replacement with Gilgul

Pascal Costanza

Gilgul is an extension of the Java programming language that allows for dynamic object replacement without consistency problems. This is possible in a semantically clean way because its model strictly separates the notions of reference and comparison that are usually subsumed in the concept of object identity. This paper sketches problems that occur in attempts at replacements of active objects and presents some solutions, including both variants that preserve consistency and those that trade consistency for timeliness. The latter are enabled by means of the new recall construct that even allows for the replacement of objects with non-terminating loops.

Aspect-Oriented Programming for Separating Business Rules

María Agustina Cibrán and Maja D'Hondt

The complexity of business domains is steadily increasing and it is becoming more important to explicitly capture the rapidly changing business policies and requirements as business rules. Business rules quite naturally lend themselves to be expressed explicitly and separately at the conceptual level of the business domain, and there are some approaches that advocate and support this separation at the design and implementation level. However, they fail to separate and encapsulate the code that links the business rules to the core application. We observe that this missing link crosscuts the core application and as a result cannot be encapsulated using traditional software development approaches, thus impeding software comprehension, maintenance, and reuse. We explore the requirements for a technology that links business rules to core application, encapsulates this link, and support its reuse. We report on a first experiment conducted using AspectJ for implementing the business rule link.

Design Patterns meet Aspect Orientation

Kris De Schutter

Through the work started by Erich Gamma et al. design patterns have become ubiquitous in the field of software engineering. Their use and solutions have been extensively debated, if mostly done from the firm basis of object orientation. Now, almost a decade after the first publication of the patterns by the Gang Of Four, a new programming paradigm is rapidly gaining recognition and maturity. Aspect Orientation is trying to actively solve some of the shortcomings in OO; most notably those of crosscutting concerns. This paper investigates the impact of these new AO constructs on the implementation of several widely known design patterns. We have tried to improve the established solutions through the introduction of aspects. It turns out that the exact gains differ from case to case. Setting up a solution to the Visitor pattern using AO techniques, for instance, is almost trivial. Iterator, however, enjoys virtually no gain from AO. Still, a single and quite straightforward aspect can provide simple support for NullIterators. We also find that investigating the applicability of aspect oriented programming in design patterns gives us a good indication of the current state of AO. It raises some questions of what we should consider AO, and what not. It lets us discover its strengths and weaknesses. Collisions through public introductions done by multiple aspects, for instance, are one problem we have frequently encountered and had to cope with.

Feature based composition of software products

Anton Jansen

We have observed that large software systems are increasingly defined in terms of the features they implement. Consequently there is a need to express the commonalities and variabilities between products of a product line in terms of features. Unfortunately, technology support for this is currently limited to the requirements level. There is a need to extend this support to the design and implementation level as well. Existing technologies such as AOP and SOP may be of use here. However, features are not first class citizens in these new paradigms. To address this and to explore the problems and issues with respect to feature composition at the implementation level, we have formalized the notion of features and the composition of features. In addition we have specified an algorithm for mapping features to Java classes. Using our model and composition algorithm, we can select a number of base components and a number of features from a software product line and derive a product. As a proof of concept we have experimented extensively with a partial Java implementation of our approach.

Generic Superimposition Introduction

Ralf Laemmel

We are faced with the following question: Given the syntax and semantics of a programming language, is there some systematic way to derive an enriched language with some generic support for superimposition so that extra functionality can be superimposed in all kinds of ways on certain join points arising from the available language constructs, and restricted by the semantical details of the constructs? A corresponding derivation is probably not done completely automatically. We rather have to further augment the language semantics to guide the enrichments in terms of reusable idioms for superimposition introduction.

GEMA: A Generic Model for AOP

Katharina Mehner and Awais Rashid

A common understanding of what is AOP is still missing and attempts are rare in literature. However, it is needed to determine whether a suggested approach is AOP. At the same time it can help in building many kinds of tools from weavers and interpreters to debuggers and analysers by identifying generalities, e.g., in the form of common architectures or data formats, and thereby help in avoiding adhoc-implementations. Our aim is to provide a model of AOP which draws upon established AOP techniques to capture essential features. For instance, it should allow drawing the line between a meta-object protocol and an AOP environment. The model should be generic in the sense that it captures basic yet essential commonalities but can adapt to variability (and also optional features). For instance, it should be instantiatable to approaches like AspectJ and Adaptive Programming. We take AOP literally, i.e., we focus on programming but not on other phases of software development. The intended scope of this work covers linguistic approaches to AOP and non-linguistic approaches, e.g., based on existing programming languages or reflection mechanisms. Most AOP approaches aim at improving separation of concerns with respect to existing programming languages such as OOP, functional or logic programming. This is achieved by capturing crosscutting code in one place, the so called aspect (or parts thereof). At the heart of each AOP approach lies a composition mechanisms for integrating the separated pieces of code. These two features which we denote as structuring and composition are the basic ideas on which every AOP approach builds and are therefore the starting point for our generic AOP model (GEMA). Each feature is classified according to several dimensions. The dimensions of structuring are abstraction, modularisation, encapsulation, information hiding, and hierarchy. The dimensions of composition are joinpoints, dominance (some approaches identify dominant components with which aspects are to be integrated while others treat all components equally), composition rules (including conflict resolution), and composition time. Each dimension can be further classified by facets. For instance, the joinpoints can take various forms. Many AOP techniques use method call interception, e.g., AspectJÕs advice weaves, which has been extended to more general runtime event interception lately. This facet is also called functional correspondence. We speak of component correspondence if behaviourally unrelated slices of data and functions are specified separately but are identified to belong, for instance, to the same class. This approach is supported by AspectJÕs introduction weaves and by HyperJ. Data correspondence occurs if the same entity is present in several components but has to be identified as one entity. This is present as a particular form of merge in HyperJ. Attaching traversal strategies to class graphs as found in Adaptive Programming can be seen as a more high-level correspondence between compositional entities. In the talk we will present the current state of our generic AOP model and insights into its derivation.

Integrating aspect-oriented ideas into component based software development.

Wim Vanderperren and Davy Suvée

We propose a novel approach that combines ideas from visual component based software development and aspect-oriented software development. Our approach addresses both the implementation and the design level by introducing an aspect-oriented programming language called JAsCo and a visual component composition environment called PacoSuite. JAsCo is inspired on the ideas of AspectJ and Aspectual Components and is tailored for the component based field. The JAsCo language stays as close as possible to the regular Java syntax and introduces two concepts: aspect beans and connectors. An aspect bean describes concerns that would normally crosscut a component based application, independent of a specific context. Connectors on the other hand, are used to deploy aspect beans within a given application. To make the JAsCo language operational, a new component model is introduced. The JAsCo beans component model is a backward compatible extension of the Java Beans component model and allows run-time aspect application and removal. PacoSuite is our approach for visual component based development. PacoSuite allows easy plug-and-play application development, by composing a set of pre-manufactured components. The compatibility of a given component configuration is verified and the glue-code that makes the composition work is automatically generated. PacoSuite however suffers from concerns that can not be confined into a single module and that have to be spread among several PacoSuite entities. To model a crosscutting concern in our visual component composition environment, we introduce an invasive composition adapter, implemented in the JAsCo language. An invasive composition adapter can be visually applied on a given composition of components. The changes described by an invasive composition adapter are automatically inserted using finite automaton theory. To deploy the JAsCo implementation of an invasive composition adapter onto the appropriate components, a connector is automatically generated from the visually wired composition. In this way, a component composer is able to visually wire aspects into a component-based application without in-depth technical knowledge of the composed components and aspects.

Aspect Weaving with Rewriting Strategies and Concrete Object Syntax in Stratego/XT

Eelco Visser

In the original vision of aspect-oriented programming aspects were defined in seperate aspect languages. Aspect programs would be woven into full blown programs by means of program transformations. Although AOP seems to concentrate on join-point programming, the more general vision is still interesting to pursue. In order for this vision to become practice, technology is required to support the rapid development of new aspect languages and aspect weavers. In this talk I will explain how Stratego/XT, a language + toolset for program transformation, can be used to develop aspect languages and implement accompanying weavers.

Participant List

Pascal Costanza costanza@web.de University of Bonn - Dynamic Object Replacement
- Aspects and Design Patterns
- Language Design Issues
Johan Brichau johan.brichau@vub.ac.be Vrije Universiteit Brussel Interessed in approaches dealing with composition problems of aspects. I am generally interested in the composition of code generators, of which aspect-weavers are a good example. Can show an example of my aspect-weaver composition system in logic metaprogramming.
Katharina Mehner mehner@upb.de University of Paderborn foundations: classification of AOP/AOSD approaches, formalsemantics
Dennis Wagelaar dennis.wagelaar@vub.ac.be Vrije Universiteit Brussel - Aspect-Oriented Design/Conceptual Modelling
- Generative techniques applied to the field of Aspect Orientation
- Aspects in Component-Based Development
Maurice Glandrup glandrup@cs.utwente.nl University of Twente Just a few key-words: -Requirements engineering
-Domain engineering
-Process for aspect-oriented software development
-Aspect Oriented Design
Laemmel, Ralf ralf@cwi.nl CWI and VU Amsterdam semantics, language design, formal methods
Lodewijk Bergmans lbergmans@acm.org University of Twente * .NET implementations
* CAT (from IBM TJ Watson) implementations
* composition problems/anomalies
Bart De Win bart.dewin@cs.kuleuven.ac.be KULeuven, Belgium - aspect composition mechanisms, in particular for building generic aspects (what are joinpoints and how to specify them, aspect parametrization, aspect ordering, desired OO properties of aspects and their relation to composition, ...)
- guarantee of compostion wrt security (~= tracebility)
Wouter Joosen wouter.joosen@cs.kuleuven.ac.be KULeuven, Belgium - aspect composition mechanisms, in particular for building generic aspects (what are joinpoints and how to specify them, aspect parametrization, aspect ordering, desired OO properties of aspects and their relation to composition, ...)
- guarantee of compostion wrt security (~= tracebility)
Istvan Nagy nagyist@cs.utwente.nl University of Twente
Wim Vanderperren wvdperre@vub.ac.be Vrije Universiteit Brussel - Combining AOSD with component based software development. If people are interested we can present our approach JAsCo and the visual component composition environment PacoSuite which uses JAsCo.
- Does AOP work? I would like to discuss more involved case-studies than the usual logging and co.
Davy Suvee dsuvee@vub.ac.be Vrije Universiteit Brussel My main interest is the application of aspect-oriented ideas within component-based software-development. For instance, should aspects be described in a seperate language, like it is the case in the current technologies? Or should aspects and components both be described in some base-language and the link between them be provided by some connector-language.
Jilles van Gurp jilles@cs.rug.nl University of Groningen feature dimension in development
Anton Jansen A.G.J.Jansen@cs.rug.nl Rijksuniversiteit Groningen Feature based software construction / variability management
Maria Agustina Cibran mcibran@vub.ac.be Vrije Universiteit Brussel Suitability of current AOSD approaches for the decoupling of business rules and their subsequent connection with the core application
Arend Rensink rensink@cs.utwente.nl University of Twente Graph rewriting for aspects
Eelco Visser visser@cs.uu.nl Universiteit Utrecht
Joost Noppen noppen@cs.utwente.nl University of Twente Aspect Oriented Design and Methodologies
Concern Identifaction and Assessment in the requirements stage
Evolving concerns
Bert-Jan van Beijnum beijnum@cs.utwente.nl University of Twente - fundamental discussion on whether accounting is a crosscutting concern
(or just a convenient development paradigm for accounting) - status and applicability of AOP/AOSD run-time environments
Note: I have to give a lecture from 13:45 to 15:30 so I will partly miss the afternoon.
Kris Gybels kris.gybels@vub.ac.be Vrije Universiteit Brussel I am interested in discussing the fundamentals of aspect languages and can show a protype implementation of my advanced crosscut language which is based on a logic language.

Call for participation

Please note that some of the dates mentioned in the call for participation have been changed since the call was sent out. (Check the dates&deadlines section)

Joint Belgian & Dutch AOP Workshop 2003 -- call for participation

Dear colleagues,

The Programming Technology Lab (PROG) from the Vrije Universiteit Brussel and Twente Research on Education and Software Engineering (TRESE) from the University of Twente will organise the second Belgian/Dutch Workshop on "Aspect Oriented Programming" (AOP) and "separation of concerns" in general. The goal of this workshop is to bring together researchers and practitioners in Belgium and the Netherlands who are contributing to the area of AOP, and to provide a Belgian/Dutch platform where knowledge transfer, exchange of ideas, and collaboration in this area are facilitated. We would like to reach as many people as possible, so please distribute this e-mail to whomever you think would be interested.

We encourage people that are active in the domain of AOP and "separation of concerns" to participate in this workshop. We sollicit topics related, but not limited to:

The intention is to have a one-day workshop, during which a number of invited speakers will present their contributions to AOP, alternated with discussions. Prospective presenters are invited to express their interest by sending an email to aopworkshop@prog.vub.ac.be before October 11th. You should include in your mail a topic and a short abstract of the material you would like to present. The organizers will select the actual presentations to be given at the workshop on the basis of these topics and abstracts, and will notify the presenters before November 8th.

On December 13th the organizers will distribute the invitations and the final schedule.

Those who would like to stay informed about this workshop, but do not plan on actively participating in the workshop, are invited to subscribe to our mailinglist via the website http://prog.vub.ac.be/misc/bdaop2003

The Belgian/Dutch AOP Workshop will be held at the University of Twente on January 23th 2003. The cost of participation will be kept to a minimum to facilitate participation. If you have any questions, mail us at aopworkshop@prog.vub.ac.be . If you know other interested institutes, please forward this email to them.

Important dates:

Waiting for your reactions,

Kris Gybels, Vrije Universiteit Brussel, Belgium
Joost Noppen, University of Twente, The Netherlands
Johan Brichau, Vrije Universiteit Brussel, Belgium
Maurice Glandrup, University of Twente, The Netherlands


PS: Since we want to reach people in Flanders, Wallonie and the Netherlands, and because we realise many research labs and companies employ foreigners, we chose to write this email in English. You may, however, respond in Dutch or French.