Bart Vanhaute

Portable Support for Transparent Thread Migration in Java

In this paper, we present a mechanism to capture and reestablish the state of Java threads. We achieve this by extracting a thread’s execution state from the application code that is executing in this thread. This thread serialization mechanism is implemented by instrumenting the original application code at the byte code level, without modifying the Java Virtual Machine. We describe this thread serialization technique in the context of middleware support for mobile agent technology. We present a simple execution model for agents that guarantees correct thread migration semantics when moving an agent to another location. Our thread serialization mechanism is however generally applicable in other domains as well, such as load balancing and checkpointing.

Security Through Aspect-Oriented Programming

Since many applications are too complex to be solved ad hoc, mechanisms are being developed to deal with different concerns separately. An interesting case of this separation is security. The implementation of security mechanisms often interacts or even interferes with the core functionality of the application. This results in tangled, unmanageable code with a higher risk of security bugs.

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.

Non-functional Policies

It is well known that a meta-object protocol (MOP) is a powerful mechanism to control the behavior of an application and to implement non-functional requirements such as fault-tolerance and distributed execution. A key feature of these architectures is the strict separation between the application at the base-level and the nonfunctional concerns at the meta-level. This makes it possible to develop generic meta-programs that can be reused for many applications. However, an important difficulty with this approach is the expression of application specific policies with respect to non-functional behavior. In this paper, we show a new approach that solves this problem by clearly separating policy from both application and meta-level. In our approach, policies are expressed at a high-level of abstraction as separate strategies. This results in highly reusable meta-programs that take application specific characteristics into account. We have validated our approach in the Correlate prototype.

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.

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.

A dynamic customization model for distributed component-based systems

Support for dynamic and client-specific customization of distributed services is required in many application areas. We present a distributed service as consisting of minimal functional core, implemented as a component based system, and an unbound set of potential extensions that can be selectively integrated within this core functionality. An extension to this core may be a new service, due to new requirements of end users. Another important category of extensions we consider are non-functional services such as authentication, which typically introduce interaction refinements at the application level. Each extension is implemented us a layer of decorator-like wrappers. The novelty of this work is that the composition logic, responsible for integrating extensions into the core system, is completely separated from the code of the core system, extensions and clients as well. Clients (end users, system integrators) can customize this composition logic dynamically on a per interaction basis by attaching extension identifiers to their interactions with the core system.