Andreas Ulbrich

Rapid Prototyping for Pervasive Applications

VisualRDK is a high-level programming language for prototyping pervasive applications. Context is tightly integrated into the language itself, so developers can attach functionality to locations, persons, or situations instead of the device. Pervasive computing appliances range from consumer devices over embedded sensor boards to PCs and large-scale context servers. Because these devices vary tremendously in their capabilities, application developers must create different programming models for every class of device. This makes rapid prototyping infeasible as soon as more than one class of devices is involved. Rapid prototyping therefore requires a programming model that hides the environments heterogeneity.

Model metamorphosis

Model driven architectures (MDA) will become practical only if transformations from platform-independent to platform-specific models can be largely automated. Kafka, an extensible rule-based transformation language, and the Kase modeling tool enable automated, customized transformations that support round-trip engineering. With Kafka and Kase, developers can construct transformations without detailed knowledge of metamodels.

Self-stabilizing publish/subscribe systems: algorithms and evaluation

Most research in the area of publish/subscribe systems has not considered fault-tolerance as a central design issues. However, faults do obviously occur and masking all faults is at least expensive if not impossible. A potential alternative (or sensible supplementation) to fault masking is self-stabilization which allows a system to recover from arbitrary transient faults such as memory perturbations, communication errors, and process crashes with subsequent recoveries. In this paper we discuss how publish/subscribe systems can be made self-stabilizing by using self-stabilizing content-based routing. When the time between consecutive faults is long enough, corrupted parts of the routing tables are removed, while correct parts are refreshed in time, and missing parts are inserted. To judge the efficiency of self-stabilizing content-based routing, we compare it to flooding, which is the naive implementation of a self-stabilizing publish/subscribe system. We show that our approach is superior to flooding for a large range of practical settings.

Programming Abstractions for Content-Based Publish/Subscribe in Object-Oriented Languages

Asynchronous event-based communication facilitates loose coupling and eases the integration of autonomous, heterogeneous components into complex systems. Many middleware platforms for event-based communication follow the publish/subscribe paradigm. Despite the usefulness of such systems, their programming support is currently limited. Usually, publish/subscribe systems only exhibit low-level programming abstractions to application developers. In this paper we investigate programming abstractions for content-based publish/subscribe middleware in object-oriented languages, how they can be integrated in applications, and their implications on middleware implementation. We focus on the definition of filters and their implementation, the handling of notifications and meta-data, and programming support for composite events. We have implemented the presented approach for our content-based publish/subscribe middleware Rebeca.

Quality of service in middleware and applications: a model-driven approach

Quality of service (QoS) management has become an important requirement for middleware platforms and distributed applications. Early QoS engineering attempts focused on single-category extensions to standard middleware. In recent years generic middleware frameworks have been proposed in order to facilitate multicategory QoS management. Our experience with such a framework has revealed that QoS management cannot be shielded from the applications. Applications need to be designed in a QoS-aware manner and application QoS requirements need to be translated into appropriate middleware extensions. Therefore we propose a comprehensive, model-driven development process for QoS-enabled distributed applications on top of QoS-enhanced middleware platforms. Our approach builds on OMGs Model-Driven Architecture (MDA). We demonstrate the mapping from the platform-independent to the platform-specific model, and we show how the design approach is applied targeting a .NET-based QoS-enabled middleware.

Scripting your home

Our homes and lives are as individual as ourselves. Many aspects, such as technical equipment, furniture, and usage patterns in these surroundings differ. Thus, personalization of applications that operate in such environments is required. The challenge for tools and programming paradigms is to provide a powerful but yet easy-to-use platform. In this paper we illustrate how our visual scripting language puts these requirements for programming ubiquitous computing environments into action.

QoS mechanism composition at design-time and runtime

In this paper we present a model-driven approach to the composition of QoS mechanisms. The support of multiple QoS categories as well as runtime adaptation requires the ability to change the message path of a middleware on the fly This leads to a new set of problems regarding the composition of individual mechanisms to a functioning message path. Especially the order in which messages are passed through the QoS mechanisms is of great importance. We show how QoS mechanisms and their composition constraints can be modeled using the UML. Furthermore, a mapping from these UML models to our NET Remoting based QoS management framework DotQoS is presented.

DotQoS: a QoS extension for .NET remoting

The concern for Quality of Service (QoS) management in middleware has been an area of active research for many years. We present a novel QoS management framework for .NET, called DotQoS, which adds generic QoS management to .NET in an architecturally conforming way. It is shown how built-in .NET features such as reflection, interception, and custom meta-data facilitate the QoS integration. Throughout the paper we compare the design and implementation of DotQoS to a CORBA-based QoS framework that we developed in a previous project. Our experience with the two frameworks reveals general insights into the principles of middleware QoS engineering.

Quality of service engineering with UML, .NET, and CORBA

The concern for non-functional properties of software components and distributed applications has increased significantly in recent years. Non-functional properties are often subsumed under the term Quality of Service (QoS). It refers to quality aspects of a software component or service such as real-time response guarantees, availability and fault-tolerance, the degree of data consistency, the precision of some computation, or the level of security. Consequently, the specification and implementation of QoS mechanisms has become an important concern in the engineering of distributed applications. In this tutorial the attendees will learn how non-functional requirements can be engineered in a systematic way into applications on top of distribution platforms such as CORBA and .NET The tutorial focuses on two major subjects areas: (1) Specification of QoS properties and (2) implementation of QoS mechanisms in middleware. We present a comprehensive, model-driven approach. It starts with a platform-independent model (PIM) in UML that captures the application QoS requirements. This model is mapped by a tool to a platform-specific model (PSM) tailored for a specific middleware, which is extended with the corresponding QoS mechanisms. Finally, the PSM is translated to code. Participants in this tutorial will get a thorough understanding of general QoS requirements, QoS modeling alternatives and QoS mechanism integration in respect to popular distributed object middleware. Furthermore, we will discuss the pros and cons of CORBA and .NET for QoS engineering. A tool will be demonstrated that eases substantially the modeling stages and the code generation.

Modellierung und Zusicherung nicht-funktionaler Eigenschaften bei Entwurf, Implementierung und zur Laufzeit verteilter Anwendungen

Zusammenfassung Wir stellen einen Software-Entwicklungsprozess fur komponenten-basierte verteilte Anwendungen vor, der Mehrkategorie-Dienstgute wahrend des Designs, der Implementierung und zur Laufzeit berucksichtigt. Fur das Design haben wir die UML um Konzepte zur Dienstgute-Modellierung erweitert. Das Modell wird fur die Implementierung weitgehend automatisch auf unser .NET Remoting-basiertes Dienstgute-Rahmenwerk abgebildet. Zur Laufzeit unterstutzt das Rah-menwerk die Erbringung und Uberwachung der Dienstgute. Desweiteren unterstutzt unser Prozess eine mehrstufige Abbildung von anwendungsspezifischen Dienstguten auf Betriebsmittel, um fur eine konkrete Dienstgute die notigen Betriebsmittel zu bestimmen.