Service Management

Today enterprises must rely on an it-architecture which is as flexible as its course of business. Changes in the enterprise’s workflows, vendors, accounting and documents directly leads to changes in its enterprise software. In order to fullfil the current demands, the software architecture has to be able to be changed, updatet and administrated without limiting the course of business. A Service Oriented Architecture (SOA) is the current state of the art software architecture which fullfils these demands. The software design paradigma inside a SOA is implementing business logic as services which are accessible over the network. Services are bulding blocks for the enterprise’s workflows and resources and are manageable at runtime.

Service Management is the key for the flexibility in an it-architecture.
Services inside a SOA have a loose coupling between service consuming applications and services. Currently a SOA can be seen as a complex system with manifold service functionalities as well as dependabilties between services and application. Multiple applications are in need of service functionality and a SOA may contain multiple or none services with the required funtionality. Services can be restarted, replaced or updatet at runtime without affecting the applications. Thus, service management achieves a high relyable and flexible it-architecture by ensuring the service’s availability and scaleability without disturbing the course of business.

Adaptive Systems

Applications in dynamically changing execution environments, such as mobile computing and ubiquitous computing, need to react to context changes and adapt appropriately. The context of an application comprises environmental conditions (e.g. location, temperature, brightness), system state (e.g. CPU load, communication bandwidth, battery capacity) as well as situational user preferences. The development and execution of adaptive applications raises many open research questions that we tackle in our projects

Cooperative Autonomous Systems

Our research project targeting autonomous structures cover both, autonomous hardware and software systems.

In the software part we are interested in autonomous agent structure and agent-based middleware systems. Self-organization and adaptation are also part of our research here.

In terms of auronomous hardware systems, we conduct research in autonomous robotics. We set up a autonomous robot soccer team which takes part in the RoboCup tournaments. The main focus is on efficient vision processing concepts, collaborative behavior, and secure communication.

Genetic Programming

The Distributed Genetic Programming Framework (DGPF) is a scalable Java
environment for heuristic, simulation-based search algorithms of any
kind and Genetic Algorithms in special. We use the broad foundation of
a search algorithms layer to provide a Genetic Programming system which
is able to create Turing-complete code.

The main focus of our project is put on the automated creation of
programs that should drive sensor networks. Such programs are
instantiated on many automata which are able to communicate with each
other wirelessly in an unreliable manner. Therefore, network simulators
able to simulate whole networks of such automata are used. By doing so,
we hope to be able to create emergent behaviors and self*-properties in
large scale distributed systems.

Our system is not bound to Genetic Programming, nor even bound to
Genetic Algorithms at all. You can easily implement other search
algorithms (like Simulated Annealing or such and such) and use the
distribution utilities to distribute them over a network. In the near
future we will implement many of these algorithms ourselves and provide
them here.

While the system can run on a single computer, one of its main
strengths is its distribution-ability. Different search algorithms using
different distribution mechanisms can easily implemented. You can find
versatile implementations of Genetic Algorithms driven by a Genetic
Engine in the Genetic Algorithms layer.

We support four different types of distribution of computational load for our
genetic algorithms:

1.local: The whole population runs local, no tasks are distributed.
2.peer-to-peer / island hopping: Big virtual populations can be created
if peer-to-peer nodes cooperate in a network.
3.client-server/master-slave: A genetic engine (client/master) uses different
servers/slaves to perform the work of reproducing and evaluating
individuals. This way, even populations of complicated-to-evaluated
individuals can be handled in reasonable time.
4.p2p/cs-hybrid: P2P-networks of genetic engines using the client-server
distribution approach can co-operate (event with pure p2p-genetic engines).

This Open-Source research project is licensed under LGPL,
a license even more liberate than the GPL. More information can be found at