Frank Matthijs

Customization of object request brokers by application specific policies

This paper presents an architectural framework for customizing Object Request Broker (ORB) implementations to application-specific preferences for various non-functional requirements. ORB implementations are built by reusing a domain-specific component-based architecture that offers support for one or more non-functional requirements. The domain-specific architecture provides the mechanism that allows the ORB to reconfigure its own implementation at run-time on the basis of application-specific preferences. This mechanism is based on a run-time selection between alternative component implementations that guarantee different service-levels for non-functional requirements. Application-specific preferences are defined in policies and service-level guarantees are defined in component descriptors. Policies and component descriptors are expressed using descriptive languages. This gives application programmers an easy and powerful tool for customizing an ORB implementation. To validate the feasibility of our architectural framework we have applied it in the domain of robotic control applications.

A survey of customizability in operating systems research

An important goal of an operating system is to make computing and communication resources available in a fair and efficient way to the applications that will run on top of it. To achieve this result, the operating system implements a number of policies for allocating resources to, and sharing resources among applications, and it implements safety mechanisms to guard against misbehaving applications. However, for most of these allocation and sharing tasks, no single optimal policy exists. Different applications may prefer different operating system policies to achieve their goals in the best possible way. A customizable or adaptable operating system is an operating system that allows for flexible modification of important system policies. Over the past decade, a wide range of approaches for achieving customizability has been explored in the operating systems research community. In this survey, an overview of these approaches, structured around a taxonomy, is presented.

An AOP Case with Static and Dynamic Aspects

Aspect-oriented-programming (aop) is a promising new approach where the description of a complex system/application is enhanced with various aspects, related to communication properties, distribution, synchronization, etc. All aspects can be described separately and are brought together by using a so-called weaver. Mostly, this is performed at compile-time, what makes that aspects disappear in the final software version. We argue that in some cases aspects should remain run-time entities in order to capture the dynamic properties of an application [MJV97]. We believe there is a need for dynamic aspects, e.g. strongly related to objects, which are clearly run-time entities.

Position summary. DiPS: a unifying approach for developing system software

In this position paper we unify three essential features for flexible system software: a component oriented approach, self-adaptation and separation of concerns. We propose DiPS (Distrinet Protocol Stack), a component framework, which offers components, an anonymous interaction model and connectors to handle non-functional aspects such as concurrency.

A Security Architecture for Electronic Commerce Applications

On the Internet many electronic commerce applications can be used today, but most of them provide only weak security or even none whatsoever. A major cause of this problem is the variety of technologies used to create such applications. Most existing security architectures are not designed to work in different environments.

Components for Non-Functional Requirements

Building distributed applications is very hard as we not only have to take care of the application semantics, but of non-functional requirements such as distributed execution, security and reliability as well. A component-oriented approach can be a powerful technique to master this complexity, and to manage the development of such applications. In such an approach, each non-functional requirement is realised by a single component. In this extended abstract we describe how the metalevel architecture of Correlate can be used to support such an approach.

Automatic composition of systems from components with anonymous dependencies specified by semantic-unaware properties

In this paper, we discuss a method of composing a system from components with anonymous dependencies. We make observations based on our experience with defining and implementing a composition mechanism for layered architectures. We propose a manner of specifying component descriptions by means of semantic-unaware properties, an application-domain independent formalism for describing the client-specific configuration requests in terms of desired properties, and a composition algorithm that works well in these conditions.

Open Implementation of a Mobile Communication System

This extended abstract applies the concept of open implementation. In object-oriented programming an open implementation is often realized by means of a so-called Meta-Object Protocol (MOP). We are using this technique in the scope of the telematica project SMove. This extended abstract presents two cases in which a MOP may be used, namely in device selection logic and in replication protocols.

A Metaobject Protocol for Correlate

Distributed applications are complex software systems that need support for non-functional requirements such as reliability and security. Often these non-functional requirements are mixed with the application semantics resulting in an overly complex system. A promising solution that cleanly separates the application from the non-functional requirements is the use of a language with a metalevel architecture. In this extended abstract, we briefly present the metalevel architecture of Correlate, a concurrent language extension to Java.

On flexible support for mobile objects

CORRELATE is a concurrent object-oriented language with a flexible run time system that enables the instantiation of application specific run time objects. We have exploited this capability in the development of mobile agents for large scale distributed computing systems, such as the Internet. We discuss some key elements of the run time system. We illustrate how the system architecture supports mobile objects, we discuss what it requires from the operating system and how we aim at evolving towards more flexibility.