James Hawthorne

Embedding Dynamic Behaviour into a Self-configuring Software System

This paper describes a methodology for embedding dynamic behaviour into software components. The implications and system architecture requirements to support this adaptivity are discussed. This work is part of a European Commission funded and industry supported project to produce a reconfigurable middleware for use in automotive systems. Such systems must be trustable against illegal internal behaviour and activity with external origins, additional devices for example. Policy-based computing is used here as an example of embedded logic. A key contribution of this work is the way in which static and dynamic aspects of the system are interfaced, such that the behaviour can be changed very flexibly (even during run-time), without modification, recompilation or redeployment of the embedded application code. An implementation of these concepts is presented, focussing on achieving trust in the use of dynamic behaviour.

A Run-Time Configurable Software Architecture for Self-Managing Systems

This paper describes a highly flexible component architecture, primarily designed for automotive control systems, that supports distributed dynamically- configurable context-aware behaviour. The architecture enforces a separation of design-time and run-time concerns, enabling almost all decisions concerning runtime composition and adaptation to be deferred beyond deployment. Dynamic context management contributes to flexibility. The architecture is extensible, and can embed potentially many different self-management decision technologies simultaneously. The mechanism that implements the run-time configuration has been designed to be very robust, automatically and silently handling problems arising from the evaluation of self- management logic and ensuring that in the worst case the dynamic aspects of the system collapse down to static behavior in totally predictable ways.

A Methodology for the Use of the Teleo-Reactive Programming Technique in Autonomic Computing

Previous work on the use of the Teleo-Reactive technique in high level software development has shown it to be a viable approach for autonomic systems. A T-R program can recover from unexpected events without knowing the underlying source or cause of the problem and thus reduces the maintenance costs of software projects where unexpected events are a likely and frequent occurrence. Previous work has also highlighted the difficult nature of designing and structuring the high level logic in a T-R program and so this work aims to reduce the problem by providing a software engineering strategy that will both drive the program development and reduce the occurrence of logic problems.

Flexible and Robust Run-Time Configuration for Self-Managing Systems

This paper describes a methodology for deploying flexible dynamic configuration into embedded systems whilst preserving the reliability advantages of static systems. The methodology is based on the concept of decision points (DP) which are strategically placed to achieve fine-grained distribution of self-management logic to meet application-specific requirements. DP logic can be changed easily, and independently of the host component, enabling self-management behavior to be deferred beyond the point of system deployment. A transparent Dynamic Wrapper mechanism (DW) automatically detects and handles problems arising from the evaluation of self-management logic within each DP and ensures that the dynamic aspects of the system collapse down to statically defined default behavior to ensure safety and correctness despite failures. Dynamic context management contributes to flexibility, and removes the need for design-time binding of context providers and consumers, thus facilitating run-time composition and incremental component upgrade.

A Middleware Approach to Dynamically Configurable Automotive Embedded Systems

This paper presents an advanced dynamically configurable middleware for automotive embedded systems. The layered architecture of the middleware, and the way in which core and optional services provide transparency and flexible platform independent support for portability, is described. The design of the middleware is positioned with respect to the way it overcomes the specific technical, environmental, performance and safety challenges of the automotive domain. The use of policies to achieve flexible run-time configuration is explained with reference to the core policy technology which has been extended and adapted specifically for this project. The component model is described, focussing on how the configuration logic is distributed throughout the middleware and application components, by inserting ‘decision points’ wherever deferred logic or run-time context-sensitive configuration is required. Included in this discussion are the way in which context information is automatically provided to policies to inform context-aware behaviour; the dynamic wrapper mechanism which isolates policies, provides transparency to software developers and silently handles run-time errors arising during dynamic configuration operations.

Practical Implementation of a Middleware and Software Component Architecture Supporting Reconfigurability of Real-Time Embedded Systems

In the current drive towards dynamic self-managing systems, a particular challenge is the development of coherent architectures of context-aware middleware and components. The embedded class of systems brings the additional challenges of resource limitations and difficulty to upgrade deployed code.This paper describes a complete implementation of middleware and component architecture that facilitates flexible run-time configuration via embedding of dynamically replaceable decision logic into software components An automotive air conditioning system application is described illustrating the approach, using a variety of context sources.

Using a Teleo-Reactive Programming Style to Develop Self-healing Applications

A well designed traditional software system is capable of recognising and either avoiding or recovering from a number of expected events. However, during the design phase it is not possible to envision and thus equip the software to handle all events or perturbations that can occur; this limits the extent of adaptability that can be achieved. Alternatively a goal-oriented system has the potential to steer around generic classes of problems without the need to specifically identify these.

Using a teleo-reactive approach in building self-managing systems

The Teleo-Reactive programming style has been demonstrated as an effective and robust way to design the logical processes of autonomous agents. This robustness is largely due to an approach to achieve goals and deal with unexpected events which is much more like the human thought process than traditional programming techniques, as it works at a higher, more abstract level. We find that this approach is as effective in producing much higher level autonomous applications, providing the same benefits as the technique does for lower level robotics and autonomous agents. The technique embraces unexpected change, accepting that events and errors are inevitable and instead of attempting to preempt these possibilities, simply moves the current state back or forward through the program accordingly. We have built a framework to assist in engineering applications using this technique. Using this framework, we develop self-managing programs that demonstrate our claims.

A reconfigurable component model using reflection

Providing a method of transparent communication and interoperation between distributed software is a requirement for many organisations and several standard and non-standard infrastructures exist for this purpose. Component models do more than just provide a plumbing mechanism for distributed applications, they provide a more controlled interoperation between components. There are very few component models however that have support for advanced dynamic reconfigurability. This paper describes a component model which provides controlled and constrained transparent communication and inter-operation between components in the form of a hierarchical component model. At the same time, the model contains support for advanced run-time reconfigurability of components. The process and benefits of designing a system using the presented model are discussed. A way in which reflective techniques and component frameworks can work together to produce dynamic adaptable systems is explained.