Abstract not found

This dissertation makes the case that programs can be updated while they run, with modest programmer effort, while providing certain update safety guarantees, and without imposing a significant performance overhead. Few systems are designed with on-the-fly updating in mind. Those systems that permit it support only a very limited class of updates, and generally provide no guarantees that following the update, the system will behave as intended. We tackle the on-the-fly updating problem using a compiler-based approach called dynamic software updating (DSU), in which a program is patched with new code and data while it runs. The challenge is in making DSU practical: it should support changes to programs as they occur in practice, yet be safe, easy to use, and not impose a large overhead. This dissertation makes both theoretical contributions—formalisms for reasoning about, and ensuring update safety—and practical contributions—Ginseng, a DSU implementation for C. Ginseng supports a broad range of changes to C programs, and performs a suite of safety analyses to ensure certain update safety

This article presents Proteus, a core calculus that models dynamic software updating, a service for fixing bugs and adding features to a running program. Proteus permits a program’s type structure to change dynamically but guarantees the updated program remains type-correct by ensuring a property we call con-freeness. We show how con-freeness can be enforced dynamically, and how it can be approximated via a novel static analysis. This analysis can be used to assess the implications of a program’s structure on future updates in order to make update success more predictable. We have implemented Proteus for C, and briefly discuss our implementation which we have tested on several well-known programs.

Producing high quality software, on time, and keeping costs within reasonable bounds have been three major goals from the very beginning of software engineering as an engineering science. Hardly ever are deployed systems either error-free or fully functionally satisfactory. The result is that, once brought into operation, systems undergo a series of "patches", "fixes", modifications, and changes. At the same time, increasingly many functions dependent on software in business, industry, and at home depend on being immediately available. Having these services unavailable due to updating the software is annoying for users. And there are other types of systems -- real-time systems -- that cannot afford to be taken down, for instance, telecommunication systems, command-andcontrol systems, and any other systems requiring continuous operation. This paper presents the Java Distributed Run-time Up- date Management System (JDRUMS). JDRUMS is meant to deal with the above mentioned problems, specifically for Java. It provides functionality for the introduction of new versions of existing Java classes on the fly, while pre- serving the internal state of objects.

This paper presents POLUS, a software maintenance tool capable of iteratively evolving running software into newer versions. POLUS’s primary goal is to increase the dependability of contemporary server software, which is frequently disrupted either by external attacks or by scheduled upgrades. To render POLUS both practical and powerful, we design and implement POLUS aiming to retain backward binary compatibility, support for multithreaded software and recover already tainted state of running software, yet with good usability and very low runtime overhead. To demonstrate the applicability of POLUS, we report our experience in using POLUS to dynamically update three prevalent server applications: vsftpd, sshd and apache HTTP server. Performance measurements show that POLUS incurs negligible runtime overhead: a less than 1% performance degradation (but 5 % for one case). The time to apply an update is also minimal. 1.

Pervasive devices get more and more powerful. More powerful devices imply more complex software. In turn this implies bugs and requirements of new features. This paper presents a technique that allows Java programs to be updated during run-time. The Java program needs no preparation to be updateable. The software is updated during normal operation and requires no user interaction. A prototype system that demonstrates the technique is also presented. INTRODUCTION As computers become more and more powerful, their software becomes more and more complex. And as software become more complex, the number of patches increases. This paper introduces a technique, the Java Distributed Run-time Update Management System (JDRUMS), to update Java programs without any need of user interaction. Using JDRUMS, systems can even be updated while they are operating. The software in a cellular phone can for example be updated during a phone call. JDRUMS is not limited to small patches, but can also be u...

The primary goal of active networking is to increase the pace of network evolution. The approach to achieving this goal, as well as the goal of enhancing customizability, is to allow network nodes to be extended by dynamically loaded code. Most active network implementations employ plug-in extensibility, a technique for loading code characterized by a concrete, pre-defined abstraction of future change. After giving examples of plug-in extensibility, we argue that while it is flexible and convenient, it is not sufficient to facilitate true evolution of the network. To remedy this problem, we propose the use of dynamic software updating. Dynamic software updating reduces the a priori assumptions of plug-in extensibility, improving flexibility and eliminating the need to pre-plan extensions. However, this additional flexibility results in additional complexity and creates issues involving validity and security. We discuss these issues, and describe the state-of-the-art in systems that su...

Abstract not found

The authors of this paper have all developed a framework that allows runtime adaptation of software systems. Based on our experiences, we wish to summarize common pitfalls concerning dynamic software evolution. Systems for dynamic adaptation typically follow a certain process which is used as a starting point in this paper. The problems that occur in the different steps of this evolution process are given and a suggestion is made on how these problems can be tackled. The reader will notice that the solution to most of the pitfalls lies in the use of reflection, meta-data and meta-object protocols. We conclude that reflection or meta-object protocol manipulations are indispensable in the process of dynamic software evolution and that better language support is needed.

This position paper describes ongoing work in which the Java-based SEESCOA component system is extended with functionality for run-time evolution. First, an assessment is made of the state-of-the-art in dynamic updating, and the applicability of existing systems for dynamic updating is examined. Then a new approach is presented, in which the concept of ports is used to redirect messages between components. The problem of class-file reloading in the JVM is avoided by modification of the classes at load-time to include version information. The predictability requirement of embedded systems is assured by updating all component instances at once.