Hella Seebach

Design and construction of organic computing systems

The next generation of embedded computing systems will have to meet new challenges. The systems are expected to act mainly autonomously, to dynamically adapt to changing environments and to interact with one another if necessary. Such systems are called organic. Organic Computing systems are similar to autonomic computing systems. In addition Organic Computing systems often behave life-like and are inspired by nature/biological phenomena. Design and construction of such systems brings new challenges for the software engineering process. In this paper we present a framework for design, construction and analysis of organic computing systems. It can facilitate design and construction as well as it can be used to (semi-)formally define organic properties like self-configuration or self-adaptation. We illustrate the framework on a real-world case study from production automation.

Constraining Self-organisation Through Corridors of Correct Behaviour: The Restore Invariant Approach

Self-organisation aspects and the large number of entities in Organic Computing (OC) systems make them extremely hard to predict and analyse. However, the application of OC principles to, e.g., safety critical systems, is usually not conceivable without behavioural guarantees. In this article, a rigorous approach called the Restore Invariant Approach is presented, which provides a specification paradigm and a formal framework that allows to give guarantees for a system despite of self-organisation. The approach provides a method for specifying unwanted system states by constraining the system and defining a corridor of correct behaviour. Furthermore, a decentralised algorithm for monitoring and restoring the invariant based on coalition formation is presented.

A Universal Self-Organization Mechanism for Role-Based Organic Computing Systems

An Organic Computing system has the ability to autonomously (re-)organize and adapt itself. Such a system exhibits so called self-x properties (e.g. self-healing) and is therefore more dependable as e.g. some failures can be compensated. Furthermore, it is easier to maintain as it automatically configures itself and more convenient to use because of its automatic adaptation to new situations. On the other hand, design and construction of Organic Computing systems is a challenging task. The Organic Design Pattern (ODP) is a design guideline to aid engineers in this task. This paper describes a universal reconfiguration mechanism for role-based Organic Computing systems. If a system is modeled in accordance with the ODP guideline, reconfiguration can be implemented generically on the basis of an of-the-shelf constraint solver. The paper shows how Kodkod can be used for this and illustrates the approach on an example from production automation.

Towards Testing Self-organizing, Adaptive Systems

The characteristics of self-adaptive, self-organizing systems lead to a significant higher flexibility and robustness against a changing environment. This flexibility makes it hard to test these systems adequately. To assure their quality, however, it is inevitable to do so. We introduce a new approach for systematically testing these self-* systems based on a feedback control-oriented system architecture called Corridor Enforcing Infrastructure (CEI). Thus, it is possible to examine particular situations, where the system is forced to reorganize or adapt to new situations. This is where the self-* mechanisms come into play and can be tested separately.

A generic software framework for role-based Organic Computing systems

An Organic Computing system has the ability to autonomously (re-)organize and adapt itself. Such a system exhibits so called self-x properties (e.g. self-healing) and is therefore more dependable as e.g. some failures can be compensated. Furthermore, it is easier to maintain as it automatically configures itself and more convenient to use because of its automatic adaptation to new situations. Design and construction of Organic Computing systems are, however, challenging tasks. The Organic Design Pattern (ODP) is a design guideline to aid engineers in these tasks. This paper introduces a generic software framework that allows for easy implementation of ODP-based Organic Computing Systems. The communication and service infrastructure of the multi-agent system Jadex is leveraged to provide interaction facilities and services to the application. The concepts of ODP are provided as generic, extensible elements that can be augmented with domain-specific behavior. The dynamic behavior of an ODP system is implemented and a generic observer/controller facility is provided. A real-world case study shows the applicability of the proposed approach and the handling of the software.

A Software Engineering Guideline for Self-Organizing Resource-Flow Systems

When introducing self-organization into a system, its developer aims to reduce the system’s complexity, during development as well as during operation. More often than not, the self-organization mechanism is ingenious, highly tweaked for the system under construction and not reproducible or reusable by other developers or in other projects. This paper introduces a software engineering guideline for self-organizing resource-flow systems along with an elaborated pattern that describes the elements of the system under construction and their collaboration. Together, guideline and pattern are the basis for a well-defined approach for the design and construction of systems in this class, which includes, among others, logistics applications, and adaptive production systems. They therefore allow developers to achieve reproducible results within a documented design framework, leverage the possibilities of the underlying formal approach and reuse self organization mechanisms tailored for the system class. The paper demonstrates the application of the guideline with a running example.

Designing self-healing in automotive systems

Self-healing promises to improve the dependability of systems. In particular safety-critical systems like automotive systems are well suited application, since safe operation is required in these systems even in case of failures. Prerequisite for the improved dependability is the correct realization of the self-healing techniques. Consequently, self-healing activities should be rigorously specified and appropriately integrated with the rest of the system. In this paper, we present an approach for designing self-healing mechanisms in automotive systems. The approach contains a construction model which consist of a structural description as well as an extensive set of constraints. The constraints specify a correct system structure and are also used in the self-healing activities. We exemplify the self-healing approach using the adaptive cruise control system of modern cars.

Formal Modeling and Verification of Self-* Systems Based on Observer/Controller-Architectures

Self-* systems have the ability to adapt to a changing environment and to compensate component failures by reorganizing themselves. However, as these systems make autonomous decisions, their behavior is hard to predict. Without behavioral guarantees their acceptance, especially in safety critical applications, is arguable. This chapter presents a rigorous specification and verification approach for self-* systems that allows giving behavioral guarantees despite of the unpredictability of self-* properties. It is based on the Restore Invariant Approach that allows the developer to define a corridor of correct behavior in which the system shows the expected properties.

Developing Self-Organizing Robotic Cells Using Organic Computing Principles

Nowadays industrial robotics applications, which are often designed and planned with a huge amount of effort, have a fixed behavior during runtime and cannot react to changes in their environment. Failures can hardly be compensated and often can only be repaired by human involvement. The idea of Organic Computing is to enable systems to possess life-like properties, such as self-organizing or self-healing. In this chapter we present a layered architecture to bring these two worlds together. Further it is discussed what are the requirements of the respective layers to allow to engineer self-x properties into such systems. The presented approach allows for developing self-organizing robotic applications that are able to take advantage of Organic Computing principles and therefore are more robust and flexible during runtime.

Runtime Model-Based Safety Analysis of Self-Organizing Systems with S#

Self-organizing systems present a challenge for model-based safety analysis techniques: At design time, the potential system configurations are unknown, making it necessary to postpone the safety analyses to runtime. At runtime, however, model checking based safety analysis techniques are often too time-consuming because of the large state spaces that have to be analyzed. Based on the S# frameworks support for runtime model adaptation, we modularize runtime safety analyses by splitting them into two parts, modeling and analyzing the self-organizing and non-self-organizing parts separately. With some additional heuristics, the resulting state space reduction facilitates the use of model checking based safety analysis techniques to analyze the safety of self-organizing systems. We outline this approach on a self-organizing production cell, assessing the self-organizations impact on the overall safety of the system.