Theo D'Hondt

Reuse contracts: managing the evolution of reusable assets

A critical concern in the reuse of software is the propagation of changes made to reusable artifacts. Without techniques to manage these changes, multiple versions of these artifacts will propagate through different systems and reusers will not be able to benefit from improvements to the original artifact. We propose to codify the management of change in a software system by means of reuse contracts that record the protocol between managers and users of a reusable asset. Just as real world contracts can be extended, amended and customised, reuse contracts are subject to parallel changes encoded by formal reuse operators: extension, refinement and concretisation. Reuse contracts and their operators serve as structured documentation and facilitate the propagation of changes to reusable assets by indicating how much work is needed to update previously built applications, where and how to test and how to adjust these applications.

Tranquility: A Low Disruptive Alternative to Quiescence for Ensuring Safe Dynamic Updates

This paper revisits a problem that was identified by Kramer and Magee: placing a system in a consistent state before and after runtime changes. We show that their notion of quiescence as a necessary and sufficient condition for safe runtime changes is too strict and results in a significant disruption in the application being updated. In this paper, we introduce a weaker condition: tranquillity. We show that tranquillity is easier to obtain and less disruptive for the running application but still a sufficient condition to ensure application consistency. We present an implementation of our approach on a component middleware platform and experimentally verify the validity and practical applicability of our approach using data retrieved from a case study.

Aspect-Oriented Logic Meta Programming

We propose to use a logic meta-system as a general framework for aspect-oriented programming. We illustrate our approach with the implementation of a simplified version of the cool aspect language for expressing synchronization of Java programs. Using this case as an example we illustrate the principle of aspect-oriented logic meta programming and how it is useful for implementing weavers on the one hand and on the other hand also allows users of aop to fine-tune, extend and adapt an aspect language to their specific needs.

Ambient-Oriented programming in ambienttalk

A new field in distributed computing, called Ambient Intelligence, has emerged as a consequence of the increasing availability of wireless devices and the mobile networks they induce. Developing software for mobile networks is extremely hard in conventional programming languages because the network is dynamically demarcated. This leads us to postulate a suite of characteristics of future Ambient-Oriented Programming languages. A simple reflective programming language, called AmbientTalk, that meets the characteristics is presented. It is validated by implementing a collection of high level language features that are used in the implementation of an ambient messenger application.

Ambient-oriented programming in ambientTalk

A new field in distributed computing, called Ambient Intelligence, has emerged as a consequence of the increasing availability of wireless devices and the mobile networks they induce. Developing software for such mobile networks is extremely hard in conventional programming languages because of new distribution issues related to volatile network connections, dynamic network topologies and partial failures.

Automating Support for Software Evolution in UML

Disciplined support for evolution of software artifacts is important in all phases of the software life-cycle. In order to achieve this support, a uniform underlying foundation for software evolution is necessary. While, in the past, reuse contracts have been proposed as such a formalism in a number of different domains, this paper generalises the formalism, and integrates it into the UML metamodel. As such, support for evolution becomes readily available for many kinds of UML models, ranging from requirements to the implementation phase.

Ambient-oriented programming

A new field in distributed computing, called Ambient In-telligence, has emerged as a consequence of the increasing availability of wireless devices and the mobile networks they induce. Developing software for such mobile networks is extremely hard in conventional programming languages because the network is dynamically defined. This hardware phenomenon leads us to postulate a suite of characteristics of future Ambient-Oriented Programming languages. A simple re ective programming language kernel, called AmbientTalk, that meets these characteristics is subsequently presented. The power of the re ective kernel is illustrated by using it to conceive a collection of high level tentative ambient-oriented programming language features.

Declaratively codifying software architectures using virtual software classifications

Most current day software engineering tools and environments do not sufficiently support software engineers to declare or to enforce the intended software architecture. Architectures are typically described at a too low level, inhibiting their evolution and understanding. Furthermore, most tools provide little support to verify automatically whether the source code conforms to the architecture. Therefore, a formalism is needed in which architectures can be expressed at a sufficiently abstract level, without losing the ability to perform conformance checking automatically. We propose to codify declaratively software architectures using virtual software classifications and relationships among these classifications. We illustrate how software architectures can be expressed elegantly in terms of these virtual classifications and how to keep them synchronized with the source code.

Change-oriented software engineering

We propose a first-class change model for Change-Oriented Software Engineering (COSE). Based on an evolution scenario, we identify a lack of support in current Interactive Development Environments (IDEs) to apply COSE. We introduce a set of five extensions to an existing model of first-class changes and describe the desired behaviour of change-oriented IDEs to support COSE. With the help of an evolution scenario, we show why those extensions are required. Finally we describe ChEOPS: a prototypical implementation of a change-oriented IDE on top of VisualWorks and illustrate how it supports the extended first-class change model. ChEOPS is finally used to validate COSE as a solution for the shortcomings of existing IDEs.

KALA: Kernel Aspect language for advanced transactions

Transaction management is a known cross-cutting concern. Previous research has been conducted to express this concern as an aspect. However, this work uses general-purpose aspect languages which lack a formal foundation and are unable to express advanced models for transaction management. In contrast, we designed a domain-specific aspect language for advanced transaction management, called KALA, that is based on a formalism for advanced transactions. As a result, KALA covers the field of advanced transaction management while obtaining a much higher level of abstraction than is achieved with general-purpose aspect languages. In this paper we detail the creation process of KALA.