Hans Schippers

A machine model for aspect-oriented programming

Aspect-oriented programming languages usually are extensions of object-oriented ones, and their compilation target is usually the (virtual) machine model of the language they extend. While that model elegantly supports core object-oriented language mechanisms such as virtual method dispatch, it provides no direct support for core aspectoriented language mechanisms such as advice application. Hence, current implementations of aspect-oriented languages bring about insufficient and inelegant solutions. This paper introduces a lightweight, objectbased machine model for aspect-oriented languages based on objectoriented ones. It is centered around delegation and relies on a very dynamic notion of join points as loci of late-bound dispatch of functionality. The model is shown to naturally support an important number of aspect-oriented language mechanisms. Additionally, a formal semantics is presented as an extension to the object-based δ calculus.

Delegation-based semantics for modularizing crosscutting concerns

We describe semantic mappings of four high-level programming languages to our delegation-based machine model for aspect-oriented programming. One of the languages is a class-based object-oriented one. The other three represent extensions thereof that support various approaches to modularizing crosscutting concerns. We explain informally that an operational semantics expressed in terms of the models concepts preserves the behavior of a program written in one of the high-level languages. We hence argue our model to be semantically sound in that sense, as well as sufficiently expressive in order to correctly support features such as class-based object-oriented programming, the open-classes and pointcut-and-advice flavors of aspect-oriented programming, and dynamic layers. For the latter, being a core feature of context-oriented programming, we also provide a formal semantics.

Leveraging UML Profiles to Generate Plugins From Visual Model Transformations

Model transformation is a fundamental technology in the MDA. Therefore, model transformations should be treated as first class entities, that is, models. One could use the metamodel of SDM, a graph based object transformation language, as the metamodel of such transformation models. However, there are two problems associated with this. First, SDM has a non-standardized metamodel, meaning a specific tool (Fujaba) would be needed to write transformation specifications. Secondly, due to assumptions of the code generator, the transformations could only be deployed on the Fujaba tool itself. In this paper, we describe how these issues have been overcome through the development of a template based code generator that translates instances of a UML profile for SDM to complete model transformation code that complies to the JMI standard. We have validated this approach by specifying a simple visual refactoring in one UML tool and deploying the generated plugin on another UML tool.

An implementation substrate for languages composing modularized crosscutting concerns

We present the implementation of several programming languages with support for multi-dimensional separation of concerns (MDSOC) on top of a common delegation-based substrate, which is a prototype for a dedicated MDSOC virtual machine. The supported MDSOC language constructs range from aspects, pointcuts and advice to dynamically scoped and activated layers. The presented language implementations show that the abstractions offered by the substrate are a viable target for high-level language compilers.

Towards an actor-based concurrent machine model

In this position paper we propose to extend an existing delegation-based machine model with concurrency primitives. The original machine model which is built on the concepts of objects, messages, and delegation, provides support for languages enabling multi-dimensional separation of concerns (MDSOC). We propose to extend this model with an actor-based concurrency model, allowing for both true parallelism as well as lightweight concurrency primitives such as coroutines. In order to demonstrate its expressiveness, we informally describe how three high-level languages supporting different concurrency models can be mapped onto our extended machine model. We also provide an outlook on the extended models potential to support concurrency-related MDSOC features.

Copying Subgraphs Within Model Repositories

The set of operations in state-of-the-art graph transformation tools allows one to conditionally create and remove nodes and edges from input graphs. Node attributes can be initialized or updated with information from other attributes, parameters or constants. These operations appear to be too restricted for expressing model refinements in a concise manner. More specifically, graph transformation lacks an operation for copying subgraphs (multiple connected nodes, including their attributes) to a new location in the host graph. This paper presents a case study that illustrates the need, a syntax and an informal semantics for such an operation. It also discusses how the operation was integrated in an existing graph transformation language. Finally, it indicates how our ongoing effort towards the implementation of a model transformation language based on graph transformation makes optimal reuse of evaluation code for existing language constructs.

A graph-based operational semantics for context-oriented programming

Context-oriented programming can be regarded as a technique aiming for an improved (multi-dimensional) separation of concerns (MDSOC). The delMDSOC (virtual) machine model describes a common target platform for a range of high-level MDSOC approaches. As it is based only on the well-known concepts of objects, messages and delegation, it provides a means to express the semantics of context-oriented programming using these same notions as well. An approach based on structured operational semantics (SOS) exists, but it has a number of drawbacks, including its implicit representation of program state and the lack of a simulation mechanism. In this paper we introduce a graph-based semantics for context-oriented programming built on top of a concurrent actor-based semantics of delMDSOC. The semantics consists of a number of graph rewrite rules which can be applied to sample graphs using the AGG tool. This allows for the visual simulation of context-oriented programs, which we demonstrate by means of an example.

Transformation techniques can make students excited about formal methods

Formal methods have always been controversial. In spite of the fact that the disbelief about their usefulness has been corrected by a growing number of applications and even more publications, it remains a challenge to demonstrate the strengths and weaknesses of formal methods within the time constraints of a typical semester course. This article reports on a new course at the University of Antwerp in which the introduction of a new formalism yields a better understanding of previously taught ones. While the exercises are designed to reveal the limitations of the formalisms used, students remain convinced that their formal models have more value than conventional source code.

Supporting inconsistency resolution through predictive change impact analysis

Today, model-driven software processes rely on consistency management approaches to deal with the multitude of inconsistencies that occur in large systems. To resolve a detected inconsistency, the software designer applies one resolution out of a set of resolution options to each inconsistency. To do so, the designer needs to understand the extent of changes posed by each resolution. In this paper we propose change impact analysis to support the designer in this task. We present a simple algorithm for predicting the impact of inconsistency resolutions by checking the instantiation of different meta-model relationships. Based on one small case study, we demonstrate that our algorithm provides a reasonable estimate for the number of changes that actually will be applied. We demonstrate the usage of impact analysis for inconsistency resolution and make a first step towards a decision support tool to help a software designer resolve inconsistencies.

Safely updating running software: tranquility at the object level

Software applications are updated frequently during their life cycle. In order to do so, they usually must be shut down, adapted and restarted. This causes periods of unavailability, which is not acceptable for some applications. Dynamic software updates (DSU) -- in which applications are updated at runtime -- is a technique that can be used to update software without the need to restart it. One of the problems of DSU is ensuring state consistency of the active application. Tranquility has been proposed as a necessary and sufficient condition for ensuring state consistency at the granularity of software components. As many object-oriented applications do not have a notion of software components, we aim to introduce tranquility at object granularity.