Allan Raundahl Gregersen

Towards a dynamic-update-enabled JVM

This paper advocates that de facto dynamic updates of Java applications will eventually require a dynamic-update-enabled Java virtual machine. We argue that our approach for dynamic updates of component-based Java applications complements the new module system planned for upcoming Java releases. We conclude that simple extensions to an existing JVM can bring full flexibility and transparency to dynamic updates in Java.

Javeleon: An Integrated Platform for Dynamic Software Updating and Its Application in Self-*Systems

Practical dynamic updating of modern Java applications requires tool support to become an integral part of the software development and maintenance lifecycle. In this paper we present Javeleon, an easy-to-use tool for dynamic updates of Java applications. To support integration with specific frameworks, component systems and application servers, Javeleon currently provides tight integration with the NetBeans Platform, facilitating dynamic updating for applications built on top of the NetBeans Platform in an unconstrained manner. Javeleon supports state-preserving unanticipated runtime evolution including dynamic changes to the type hierarchy of classes without modifying a JVM and without utilizing new language constructs. In addition to the obvious benefits of using Javeleon during development, we argue that Javeleon is a strong candidate for being useful in other research fields. In order to substantiate this argument, we present an overview of an ongoing research that applies Javeleon in the development of Self-systems.

Run-time phenomena in dynamic software updating: causes and effects

The development of a dynamic software updating system for statically-typed object-oriented programming languages has turned out to be a challenging task. Despite the fact that the present state of the art in dynamic updating systems, like JRebel, Dynamic Code Evolution VM, JVolve and Javeleon, all provide very transparent and flexible technical solutions to dynamic updating, case studies have shown that designing dynamically updatable applications still remains a challenging task. This challenge has its roots in a number of run-time phenomena that are inherent to dynamic updating of applications written in statically-typed object-oriented programming languages. In this paper, we present our experience from developing dynamically updatable applications using a state-of-the-art dynamic updating system for Java. We believe that the findings presented in this paper provide an important step towards a better understanding of the implications of dynamic updating on the application design.

Extending eclipse RCP with dynamic update of active plug-ins

While the dynamic linking mechanism of modern programming languages, such as Java, allows loading of classes dynamically, it does not allow class reloading. Hence, dynamic linking facilitates development of component platforms, such as eclipse RCP, which supports dynamic loading but not dynamic updates of components, since this requires reloading. This paper presents an approach that enhances eclipse RCP with dynamic updating capability. It overcomes the version barrier imposed by Javas dynamic linking, while maintaining the security and type safety of Java. The feasibility of the approach validates through a modified implementation of the eclipse RCP run-time system. Analysis indicates that our approach imposes a moderate performance penalty relative to the unmodified platform.

Implications of modular systems on dynamic updating

Module systems have been acknowledged as software development and maintenance boosters. Likewise, dynamic updating, meaning the ability to evolve a software system at runtime, not only has the potential to increase developer productivity, but also to significantly reduce production system downtime. However, widely adopted module systems for Java inherently enforces assumptions that make dynamic updates of modules difficult, even with the recent prominent advances in dynamic updating systems for Java applications. In this paper, we explain why it requires much more than just updating the set of Java classes that constitute a patched version of a running module. In addition, we provide a set of well-defined integration points to which developers of dynamic updating systems need to hook into in order to support correct dynamic updating in a module system. We show how our dynamic updating system has been integrated with the NetBeans Platform with a modest integration effort, thus showcasing that practical state-preserving runtime updates of modules can be achieved in a modern module system setup.

Towards dynamic plug-in replacement in Eclipse plug-in development

Although the Eclipse IDE offers an extremely useful built-in support for developing Eclipse plug-ins, it lacks the ability to perform dynamic updates of plug-ins in a running instance of the application being developed. Because of the nature of the Eclipse architecture and its strict class-loader delegation, plug-ins can only communicate through well-defined APIs. By applying a novel dynamic update approach to the eclipse plug-in development environment that exploits this knowledge, a new API are defined, namely the Dynamic API. This paper discusses some of the ordinary binary compatible changes that lead to erroneous program behaviour if not properly handled. Furthermore, it discusses how applying a dynamic update approach at development time gives developers a unique chance to experiment with dynamic updates without risking a costly shutdown of a real-life application.

Using Runtime State Analysis to Decide Applicability of Dynamic Software Updates.

Updating application code while it is running is a popular approach to the dynamic software update problem. But in many cases the behavior of the updated application bears side effects of the update in the form of a runtime phenomena that breaks application state assumptions leading to unwanted complications. We present a runtime state analysis system, Genrih, that enhances a dynamic system update solution and automatically decides if the state transformation functions of a DSU solution are sufficient for the given update. Genrih analyzes the atomic changes in the updated code compared to the already running version and based on these changes automatically determines whether updating the system’s runtime state will lead to the observable runtime phenomena. The designed system does not break the update procedure, but observes the state and produces notifications for enhanced analysis and crash management. The practical evaluation shows that the designed system imposes acceptable overhead and can help the developer be aware of several kinds of runtime

Applying genetic self-architecting for distributed systems

Current trends in information technology emphasize the need of flexible systems that are able to adapt to their changing environment. The aim of this paper is to develop an infrastructure for architecture level self-adaptation, and to study its applicability in the case of distributed systems. The approach is based on dynamically inserted and removed design solutions. The built infrastructure provides UML based architectural reflection and a genetic engine for optimizing the architecture at run-time with respect to efficiency and reliability, according to changes in the environment. The implementation builds on Javeleon, a Java-based platform supporting dynamic updates of classes. The approach is applied to develop a self-adapting system that mimics a shop security control system.

Genrih, a Runtime State Analysis System for Deciding the Applicability of Dynamic Software Updates

Dynamic Software updating (DSU) systems enable applications to be upgraded without service interruption. However, the implications of changed program assumptions may result in unwanted runtime phenomena after the dynamic update if the momentary state of the application does not satisfy those changed assumptions. Hence, in order to enable dynamic updates in a safe manner, the updating mechanism needs to reason about the runtime state at update time.

JRebel.Android: runtime class- and resource reloading for android

Developers writing Android applications suffer from a dreadful redeploy time every time they need to test changes to the source code. While runtime class reloading systems are widely used for the underlying programming language, Java, there is currently no support for reloading code on the Android platform. This paper presents a new tool, JRebel.Android that enables automatic runtime class- and resource reloading capabilities for Android. The target of this paper is the Android developer as well as the researcher for which dynamic updating capabilities on mobile devices can serve as a basic building block within areas such as runtime maintenance or self-adaptive systems. JRebel.Android is able to reload classes in much less than 1 second, saving more than 91% of the total redeploy time for small apps, more than 95% for medium size apps, and even more for larger apps.