Pierre Verbaeten

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.

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.

Numerical solution of the Abel integral equation

A numerical method for the solution of the Abel integral equation is presented. The known function is approximated by a sum of Chebyshev polynomials. The solution can then be expressed as a sum of generalized hypergeometric functions, which can easily be evaluated, using a simple recurrence relation.

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.

Bridging the gap between web application firewalls and web applications

Web applications are the Achilles heel of our current ICT infrastructure. NISTs national vulnerability database clearly shows that the percentage of vulnerabilities located in the application layer increases steadily. Web Application Firewalls (WAFs) play an important role in preventing exploitation of vulnerabilities in web applications. However, WAFs are very pragmatic and ad hoc, and it is very hard to state precisely what security guarantees they offer.The main contribution of this paper is that it shows how, through a combination of static and dynamic verification, WAFs can formally guarantee the absence of certain kinds of erroneous behaviour in web applications. We have done a prototype implementation of our approach building on an existing static verification tool for Java, and we have applied our approach to a medium-sized J2EE based web application.

The automatic construction of pure recurrence relations

A method is presented for the construction of pure recurrence relations for functions related to generalized hyper-geometric functions. It is an improvement of a technique by Fasenmeyer, and is suitable for automatic computer programming. Our method has an easy geometrical interpretation and also gives a constructive proof for the existence of a pure recurrence relation.

DAVIM: Adaptable Middleware for Sensor Networks

Middleware services facilitate sensor-network application development. DAVIM is adaptable middleware that enables dynamic management of services and isolation between simultaneously running applications.

An agent design method promoting separation between computation and coordination

The development of (internet) agents is often a tedious and error-prone task resulting in poorly reusable designs, since both the internal computation of the agent as well as the coordination support are developed in an ad hoc fashion. To improve the process of agent-oriented software development, we propose an agent design method that imposes the separation of internal computation from coordination aspects. This method comprises two dimensions: a design formalism and an agent design process. As an illustration of the presented method, we present the design of an internet agent that is entitled to deploy a distributed service in a computer network, without breaking the consistency of that network. The presented design method has resulted in the development of ACF (Agent Composition Framework), a component framework to build flexible internet agents. We argue that the presented design method combined with this infrastructure can promote a modular and easy to manage approach to the design and development of internet agent applications.

Petri charts: an alternative technique for hierarchical net construction

We present a new formalism for modelling concurrent systems, called Petri charts. It is based on Petri nets and statechart principles. It aims at benefiting from the power of both methods in order to provide a modelling method that has substantial expressive power and abstraction functionalities. These appear to be necessary for introducing a formal method into the field of modelling real-world applications. Intuitively, one can say that Petri charts enhance Petri nets by introducing depth: a place (transition) may be refined by a subnet, retaining the original place (transition) as a super-place (super-transition). Besides being a high-level modelling technique, Petri charts allow the combination net refinements and net composition operators, two mechanisms for the modular development of Petri nets. Basic formal definitions and the Petri chart method are presented. We also define a transformation on Petri charts yielding Petri nets. It enables the reuse of the available research results in the area of P/T nets, which is an important benefit.

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.