Engineering Self-Organising Applications 

(SNF 21-68026.02)


The growing diffusion of personal devices connected to Internet is promoting the development of pervasive and wireless applications, as well as those that are to be deployed on a Grid or on a P2P network. These applications are based on mobility of code and computation on networks with highly dynamic topologies. A characteristic of these applications is their self-organized and decentralized nature. They are made of several components and act without any central control. The global behaviour emerges then from the interactions of the different components. In addition, these applications should have the ability to modify their behaviour on a context-awareness basis (evolutive and survivable); and should have the ability to capture experiences for later recall.

Decentralized software raises engineering questions that techniques defined for traditional systems cannot answer: How can such an application not simply crash when part of the network is down or unreachable? Exception handling may be no longer sufficient for an autonomous component that needs to continue its execution despite failures. How can the different components interact and coordinate properly without run-time errors? Syntactical type checking needs to be assisted by a semantical description of behaviours and interactions. How to be sure that the application as a whole behaves correctly and delivers the desired (or a minimal) functionality in every situation? Design time model checking or testing need to be completed by run-time verification and guidance.  What is the best way to design and program these applications? How can we perform the separation of concerns? How to engineer the applications such that a verification becomes possible?

Currently, these applications are developed in an ad hoc manner, leading to solutions that do not exploit entirely the decentralized aspect of the application, and consequently do not benefit from the whole network potentiality.  There is a clear need for infrastructures that go beyond syntactical conformance at design time, and which enable to engineer autonomous components such that they have, at run-time, the necessary knowledge for engaging correct interoperable operations.

The goal of this project is to define innovative concepts for programming autonomous components able to check semantical conformance of each other at run-time, i.e., to understand the desired functionality and expected behaviour of other components, and to evaluate the issue of an interaction. We will use formal techniques as a basis for reliability, and correctness at run-time.  This project intends to investigate formal theories for defining the semantics of behavioural description; and techniques for verifying local/global behaviour at run-time. From a software engineering point of view, the project will consider separating the different concerns: functionality, behavioural description, and interactions.


In order to make the components adaptable (robust), interoperable, and to ensure correct compositions, we will identify concepts for structuring and designing the components and their interactions. In addition to well-thought concepts, we intend to consider formal techniques as a basis for reliability, and correctness at run-time.  

Since there is no central element which pilots the other components, each entity has to be self-sufficient. Therefore, it must incorporate more information than its operational behaviour, and publish more data than its signature. What we want at the end is to be able to program a component with a functional part (traditional behaviour), and a non-functional part describing all the necessary semantical information enabling composition and correct compositional behaviour.  The idea is to program seperately, for each component, a functional part implementing the behaviour of the component - the traditional program code; and an abstract description of the component's behaviour - the semantical behavioural description (specification);

These two information are intended to be publicly available at run-time by other components.  This extra information (description and correctness) is the glue, embedded in the component, and used to combine the components at run-time. It provides to other components, the necessary meaningful representation of the current component, which will allow run-time discovery of components and correct composition.

Current realisations:

Ongoing Work


PhD Thesis

Additional Activities

This project started October 2002 and ends September 2004. See A Social Semantical Infrastructure Supporting Ambient Intelligence for a follow-up.

G. Di Marzo Serugendo
September 2004.