Due to their modular design, component-based applications are relatively well-suited to supporting run-time evolution. However, replacing a component at run time without halting the application remains a difficult task. The main cause of this complexity can be found in transferring the state between two versions of a component. We have developed a methodology to perform run-time adaptations on component-based applications. This paper briefly introduces our methodology and then continues with a detailed study of our approach to state transfer. By exploiting the strong encapsulation of components, we conduct an analysis of the (object-oriented) source code of different versions of a component. A classification is presented which introduces different categories of change, according to the impact of the change on the set of objects that make up the component. We then describe different heuristics that are used to identify equivalent data structures between different versions. We show how these techniques are implemented in a tool called DeepCompare. An evaluation of our tool using two examples (an academic toy component and a real-life application), demonstrates that our process successfully identifies the vast majority of corresponding structures in a typical evolution scenario.

Abstract not found

While there exists a fair number of partial solutions to enabling dynamic updating in arbitrary applications, none of them have proved to be superior. This paper does not suggest "yet another " dynamic updating system that no one will use in the end anyway. Instead, we dig deep into the heart of software development, and examine what dynamic updating and static evolution is all about. We identify bottle necks and sources of complications, and come up with suggestions as to how these can be fundamentally solved. We present two novel concepts that could improve the updatability and adaptability of applications; the sequence model for dealing with code, and entity-oriented programming for dealing with data and object-orientation. In order to demonstrate these, as well as tie in even more improvements for updatability and general programming flexibility, we introduce an updatable programming language. Some of the previous work in the field has developed dynamic updating systems by refining some existing programming language. Our approach is not just "our own " implementation of such an approach. Our approach is different and novel, because it constructs the whole programming language from ground up based on updatability demands. To ensure that this language is useful enough, we make it superficially look like popular object-oriented languages. This paper is a revision of the Master's thesis "Rethinking Software Updating; Concepts for Improved Updatability".

In this paper we investigate the applicability of different methods for dynamic updating to component-oriented embedded systems. The systems for dynamic updating that exist today vary widely in method, conception and applicability. After reviewing the state-of-the-art, common problems in the domain of live updating are given and the solutions that currently available systems provide are discussed. We summarize this discussion in an overview table. Then we discuss to what extent existing methods for dynamic updating are suitable for component-oriented embedded systems and examine whether it is desirable to modify available techniques to update those systems.

Abstract not found