Dynamic Software Updating Research Articles

Identifying Alterability States of a Single Track Railway Line Control System

In the context of automation and deployment of computer based control systems, a specific application on French railway line is proposed on low traffic single track railway lines. The issue of updates requires thorough consideration. In the case of low traffic single track railway lines, handling the removal of a shunting track, which role is to allow trains to circulate in both directions of a same line, the issue of timing the update to the control system is particularly critical. Indeed, a wrongly timed update could lead to a deadlock, while one or more trains are expected to travel while respecting safety constraints on the blocked infrastructure. This paper studies the application of works from the field of dynamic software updating, specifically the works of Panzica La Manna et al. [12]. Using their results on a graph based model of a single track rail line, it identifies alterability states that ensure safety constraints are respected at all times without causing deadlocks. These results are then used to discuss the pertinence of using concepts from dynamic software updating in the context of railway systems.

SoREn, How Dynamic Software Update Tools Can Help Cybersecurity Systems to Improve Monitoring and Actions

Because stopping a service to apply updates raises issues, Dynamic Software Updating studies the application of updates on programs without disrupting the services they provide. This is acheived using specific mechanisms operating updating tasks such as the modification of the program state. To acheive transparency, Dynamic Software Updating systems use pre-selected and pre-configured mechanisms. Developers provide patches that are transparently converted to dynamic updates. The cost of such transparency is often that applied patches cannot modify the general semantic of the updated program. Allowing dynamic modification of the general semantic of a running program is rarely considered. In the context of protection of communications between moving vehicles and uncontrolled infrastructure, SoREn (Security REconfigurable Engine) is designed to be dynamically reconfigurable. Its semantics can transparently be modified at runtime to change the security policy it enforces. Administrators can supply new policies to trigger a reconfiguration, without developing new components. This paper details and discusses the design of SoREn, its meta-model linked to cybersecurity business concepts and its automatic reconfiguration calculator allowing transparent application of reconfigurations.

Editorial

It is with great pleasure that I welcome you to our first regular issue in 2022, which contains 5 very relevant and new articles on various topics in computer science. Looking back over the past year, we had a successful relaunch of the J.UCS platform hosted by Pensoft Publishers Ltd. on their ARPHA Publishing Platform. Thanks to the combined efforts of the Pensoft team and the J.UCS publishing team, we are listed and indexed in more than 40 indexing services worldwide, including DOAJ, Web of Science, and Scopus. Increased visibility and social media presence have also continued to increase page views and article downloads, as well as the number of articles submitted and special issue proposals. We are also very proud to report that the journal's Impact Factor continued to improve. The Web of Science Impact Factor increased to 1.139 and the Scopus Science Score to 2.0. We are proud to present a total of 12 issues with 64 articles on new aspects of various topics in computer science; more precisely, 40 articles were published in 6 special issues and 24 articles in 6 regular issues. These great achievements were only possible through the commitment and interest of the community, the valuable support of the Editorial Board, and the support of the members of the J.UCS Consortium. In particular, I would like to thank Dr. Ulrike Krießmann from the Library of the Graz University of Technology, Prof. Klaus Tochtermann from the ZBW, Prof. Christian Eckhardt from California Polytechnic State University, and Prof. Krzysztof Pietroszek from the American University in Washington DC for their generous support in offering an open-content journal without charging authors for their articles. I would also like to thank the J.UCS team, Johanna Zeisberg for taking care of the publication process, Aleksandar Bobic for his social media support, and Alexander Nussbaumer for his technical support, as well as Pensoft Publishers Ltd. for hosting our journal. I look forward to continuing to work with our editors, editorial team and technical support to maintain the success of J.UCS. I would be very grateful for suggestions and feedback on how we can make J.UCS even better and develop it further in the future. In this regular issue, I am very pleased to introduce 5 accepted articles from 5 different countries. Roberto Cavicchioli, Riccardo Martoglia and Micaela Verucchi from Italy report on an innovative framework aiming to facilitate the design of advanced Big Data analytics workflows for smart cities. Sébastien Martinez, Christophe Gransart, Olivier Stienne, Virginie Deniau, and Philippe Bon from France focus in their article on aspects of dynamic software updating, specifically they present SoREn - Security REconfigurable Engine – in the context of moving vehicles. In their article, Rodolfo Medeiros, Sílvio Fernandes, and Paulo G. G. Queiroz from Brazil perform a systematic review of the literature to bring together middleware solutions for the Internet of Things, identify the requirements and communication protocols used, and finally point out some gaps and directions for future research in IoT middleware development. Canan Tastimur and Erhan Akin form Turkey focus on the challenging problem of classifying highly similar objects by exploring the Siamese Convolution Neural Network, a similarity measurement-based network, and applying it to classify different types of screws, nuts, and bolts. In a research collaboration between Argentina and Brazil, Florencia Vega, Guillermo Rodríguez, Fabio Rocha and Rodrigo Pereira dos Santos present and discuss Scrum Watch, a tool for monitoring the performance of Scrum-based work teams.

Dynamic software updating: a systematic mapping study

Dynamic software updating (DSU) is shifting gears to modify software systems without a halt. Even though extensive research has been conducted on DSU, it is necessary to synthesise and map the results of recent studies on DSU for prospective research highlights. This study aims to highlight the current state-of-the-art, to recognise trends, and to identify existing open issues in DSU. A systematic mapping study (SMS) was conducted with a set of six research questions. A total of 1066 papers published from 2005 to 2019 were recorded. After a filtering process, 112 primary studies were selected and inspected. This study highlights the current state-of-the-art of DSU including approaches, tools, models, and techniques. Also, this study outlines application domains, research type, and contributions type facets in DSU. In addition, this study demonstrates benchmarks, datasets, evaluation metrics, and existing open issues for future research in DSU. The results of this investigation can be used to highlight current state-of-the-art of DSU, to show trends of DSU, and to demonstrate existing open issues in DSU.

Preserving instance state during refactorings in live environments

An important activity of software evolution consists in applying refactorings to enhance the quality of the code without changing its behaviour. Having a proper refactoring tool is a must-to in any professional development environment. In addition, live programming allows faster development than the usual edit-compile-debug process. During live programming sessions, the developer can directly manipulate instances and modify the state of the running program. However, when a complex refactoring is performed, instances may be corrupted (i.e., their state is lost). For example, when pushing an instance variable to a superclass there is a moment where the superclass does not have yet acquired the new instance variable and the subclass does not have it any more. It means that the value assigned to this instance variable in existing instances is lost after the refactoring. This problem is not anecdotal since 36% of the refactorings described in Fowler’s catalogue corrupt instances when used in a live programming context. There is a need to manually migrate, regenerate or reload instances from persistent sources. This manual fix lowers the usefulness of live programming.In this context of live programming, we propose, AtomicRefactoring, a new solution based on Dynamic Software Update to preserve the state of the application after performing refactorings. We provide a working extension to the existing refactoring tool developed for the language Pharo (a new offspring inheriting from Smalltalk), allowing application developers to perform complex refactorings preserving the live state of the running program.

Challenges in Dynamic Software Updating

Challenges in Dynamic Software Updating

The Effects of Static Analysis for Dynamic Software Updating: An Exploratory Study

Dynamic software updating (DSU) is the act of modifying software without stopping its execution. DSU is employed to preserve the high availability in the deployed software systems. Although significant investigations have been conducted on static analysis (SA) to determine DSU errors, no particular study exists that explores the effects of SA for dynamic software updating. The objective of the study presented in this paper is to explore the effects of static analysis for DSU. In this exploration, four evaluation metrics were declared including the number of update operations, the number of violations, the cyclomatic complexity, and the patch size. Also, a novel framework was introduced and 18 versions of baseline target programs were employed to explore the effects of static analysis for DSU. The results have explained that static analysis can detect violations of DSU. It may affect the complexity of the new versions of the target programs and having optimization can further reduce those violations. In addition, the results show that the SA may change the number of update operations and the patch size for DSU. Overall, the results have proved that SA for dynamic software updating could affect the complexity of the target programs, the number of update operations, and the patch size. Furthermore, this exploration has offered a novel framework and four evaluation metrics for measuring the effects of static analysis for DSU.

Dynamic Software Update from Development to Production.

Dynamic Software Update (DSU) solutions update applications while they are executing. These solutions are typically used in production to minimize application downtime, or in integrated development environments to provide live programming support. Each of these scenarios presents different challenges, forcing existing solutions to be designed with only one of these use cases in mind. For example, DSUs for live programming typically do not implement safe point detection or instance migration, while production DSUs require manual generation of patches and lack IDE integration. Also, these solutions have limited ability to update themselves or the language core libraries, and some of them present execution penalties outside the update window. We propose a DSU (gDSU) that works for both live programming and production environments. Our solution implements safe update point detection using call stack manipulation and a reusable instance migration mechanism to minimize manual intervention in patch generation. Moreover, it also offers updates of core language libraries and the update mechanism itself. This is achieved by the incremental copy of the modified objects and an atomic commit operation. We show that our solution does not affect the global performance of the application and it presents only a run-time penalty during the update window. Our solution is able to apply an update impacting 100,000 instances in 1 second. In this 1 second, only during 250 milliseconds the application is not responsive. The rest of the time the application runs normally while gDSU is looking for the safe update point. The update only requires to copy the elements that are modified.

μ-DSU: A Micro-Language Based Approach to Dynamic Software Updating

Today software systems play a critical role in society’s infrastructures and many are required to provide uninterrupted services in their constantly changing environments. As the problem domain and the operational context of such software changes, the software itself must be updated accordingly.In this paper we propose to support dynamic software updating through language semantic adaptation; this is done through use of micro-languages that confine the effect of the introduced change to specific application features. Micro-languages provide a logical layer over a programming language and associate an application feature with the portion of the programming language used to implement it. Thus, they permit to update the application feature by updating the underlying programming constructs without affecting the behaviour of the other application features.Such a linguistic approach provides the benefit of easy addition/removal of application features (with a special focus on non-functional features) to/from a running application by separating the implementation of the new feature from the original application, allowing for the application to remain unaware of any extensions. The feasibility of this approach is demonstrated with two studies; its benefits and drawbacks are also analysed.

Dynamic Software Update of Stateflow Charts using Erlang Runtime System

Reprogramming the controller of an industrial automation system usually requires to halt the system. In this paper, a novel method that allows reprogramming a controller at runtime is presented. The control behavior is modeled using parallel finite state machines, Stateflow being used as an example of modeling tool. Automatic translation to Erlang code is implemented and Dynamic Software Update is enabled using Erlang Runtime System. The presented method is applied and evaluated on a case study as a proof of concept.

A formal verification of dynamic updating in a Java-based embedded system

Dynamic software updating (DSU) consists in updating running programs on the fly without any downtime. This feature is interesting in critical applications that must run continuously. Because updates may lead to safety errors and security breaches, the question of their correctness is raised. Formal methods are a rigorous means to ensure the correctness required by applications using DSU. In this paper, we present a formal verification of correctness of DSU in a Java-based embedded system. Our approach is based on three major contributions. First, a formal interpretation of the semantic of update operations to ensure type safety of the update. Secondly, we rely on a functional representation of bytecode, the predicate transformation calculus and a functional model of the update mechanism to ensure the behavioural correctness of the updated programs. It is based on the use of Hoare predicate transformation to derive a specification of an updated bytecode. Thirdly, we use the functional representation to model the safe update point detection mechanism. This mechanism guarantees that none of the updated methods are active. This property is called activeness safety. We propose a functional specification that allows to derive proof obligations that guarantee the safety of the mechanism.

A Framework for Practical Dynamic Software Updating

Dynamic software updating (DSU) enables a program to be patched on the fly without being shutdown. This paper addresses the practicality problem of the recent research on DSU systems, and presents Replus, a new DSU system that balances practicality and functionality. Replus aims to retain backward binary compatibility and support multi-threaded programs. In addition, it does not require customers to have developer-level software knowledge. More importantly, without specific compiler support, Replus can patch programs that are difficult to be updated at runtime, as well as programs that may incur an indefinite delay in DSU. The key technique of our solution is to update the stack elements for the patched program using two new mechanisms: Immediate Stack Updating , which immediately updates the stack of a thread, and timely stack updating , which only updates the stack frames of the necessary functions without affecting others. Replus also develops an Instruction Level Updating mechanism, which is more efficient for certain security patches. We used popular server applications as test suites to evaluate the effectiveness of Replus. The experimental results demonstrated that Replus can successfully update all the test suites with negligible impact on application performance.

Dynamic Rebinding for Concurrent Object Groups: Theory and practice

In this paper we propose a new mechanism for Dynamic Rebinding, a particular kind of Dynamic Software Updating that focuses on modifying the workflow of a program. This mechanism is built upon the concurrency model of Concurrent Object Groups that is adopted in programming languages like Coboxes, Creol or ABS. Using this model, which extends and solves some of the limitations of Active Objects, it becomes possible for an update to wait for the program to reach a local quiescent state and then perform the update without creating any inconsistency in the program's state. We validate our mechanism by formally proving that i) no updates are performed when the program has not reached a local quiescent state, ii) an update is guaranteed to be applied if we first wait for the program to reach a local quiescent state, and iii) it is possible to perform different updates atomically. We also provide a type system that checks the good usage of the rebinding operator. We implemented a prototype supporting our mechanism in the toolchain of the ABS language, and we tested the implementation by supporting dynamic changes in the server policy of an industrial case study from the eCommerce Fredhopper platform, offered by SDL. Without our rebinding mechanism, supporting such dynamic changes in a provably correct manner would not have been so simple. Finally, we developed an implementation of type checking for the ABS language extended with our rebinding primitives, and successfully tested it for the case study discussed in the paper.

MUC: Updating cloud applications dynamically via multi-version execution

Cloud applications usually need to provide service continuously, however, updating them to fix bugs or add new features will interrupt the service. Conventional Dynamic Software Updating (DSU) systems try to update applications while running, but they are hardly able to consider the communication of the application to be updated with other programs, and could then lead to some inconsistency. Therefore, the DSU systems could not be directly applied into cloud where one application normally interacts with the other side.We propose an improved DSU system to update cloud applications dynamically, and utilize the multi-version execution approach to handle the inconsistent issue. When a new update arrives, instead of updating the application to the new version, we fork a new process of the old version and dynamically update it to the new version, then make these two versions run concurrently until the update finishes. To show the feasibility of the proposed solution, a prototype system called MUC (Multi-version execution for Updating of Cloud) is implemented on Linux, and MUC is applied to update three cloud applications, Redis, Memcached, and Icecast.

Safe reconfiguration of Coqcots and Pycots components

Software systems have to face evolutions of their running context and users. Therefore, the so-called dynamic reconfiguration has been commonly adopted for modifying some components and/or the architecture at runtime. Traditional approaches typically stop the needed components, apply the changes, and restart the components. However, this scheme is not suitable for critical systems and degrades user experience. This paper proposes to switch from the stop/restart scheme to dynamic software updating(DSU) techniques. Instead of stopping a component, its implementation is replaced by another one specifically built to apply the modifications while maintaining the best quality of service possible. The major contributions of this work are: (i) the integration of DSU techniques in a component model; (ii) a reconfiguration development process including specification, proof of correctness using Coq, and; (iii) a systematic method to produce the executable script. In this perspective, the use of DSU techniques brings higher quality of service when reconfiguring component-based software. Moreover, the formalization allows ensuring the safety and consistency of the reconfiguration process.

C‐strider: type‐aware heap traversal for C

SummaryResearchers have proposed many tools and techniques that work by traversing the heap, including checkpointing systems, heap profilers, heap assertion checkers, and dynamic software updating systems. Yet building a heap traversal for C remains difficult, and to our knowledge, extant services have used their own application‐specific traversals. This paper presents C‐strider, a framework for writing C heap traversals and transformations. Writing a basic C‐strider service requires implementing only four callbacks; C‐strider then generates a program‐specific traversal that invokes the callbacks as each heap location is visited. Critically, C‐strider is type aware – it tracks types as it walks the heap, so every callback is supplied with the exact type of the associated location. We used C‐strider to implement heap serialization, dynamic software updating, heap checking, and profiling, and then applied the resulting traversals to several programs. We found that C‐strider requires little programmer effort, and the resulting services are efficient and effective. Copyright © 2015 John Wiley & Sons, Ltd.

Kitsune

Dynamic software updating (DSU) systems facilitate software updates to running programs, thereby permitting developers to add features and fix bugs without downtime. This article introduces Kitsune, a DSU system for C. Kitsune’s design has three notable features. First, Kitsune updates the whole program, rather than individual functions, using a mechanism that places no restrictions on data representations or allowed compiler optimizations. Second, Kitsune makes the important aspects of updating explicit in the program text, making the program’s semantics easy to understand while minimizing programmer effort. Finally, the programmer can write simple specifications to direct Kitsune to generate code that traverses and transforms old-version state for use by new code; such state transformation is often necessary and is significantly more difficult in prior DSU systems. We have used Kitsune to update six popular, open-source, single- and multithreaded programs and find that few program changes are required to use Kitsune, that it incurs essentially no performance overhead, and that update times are fast.

Low-disruptive dynamic updating of Java applications

Context In-use software systems are destined to change in order to fix bugs or add new features. Shutting down a running system before updating it is a normal practice, but the service unavailability can be annoying and sometimes unacceptable. Dynamic software updating (DSU) migrates a running software system to a new version without stopping it. State-of-the-art Java DSU systems are unsatisfactory as they may cause a non-negligible system pause during updating. Objective In this paper we present Javelus, a Java HotSpot VM-based Java DSU system with very short pausing time. Method Instead of updating everything at once when the running application is suspended, Javelus only updates the changed code during the suspension, and migrates stale objects on-demand after the application is resumed. With a careful design this lazy approach neither sacrifices the update flexibility nor introduces unnecessary object validity checks or access indirections. Results Evaluation experiments show that Javelus can reduce the updating pausing time by one to two orders of magnitude without introducing observable overheads before and after the dynamic updating. Conclusion Our experience with Javelus indicates that low-disruptive and type-safe dynamic updating of Java applications can be practically achieved with a lazy updating approach.

C 응용 프로그램의 동적 소프트웨어 업데이트 시스템 개발

DSU(Dynamic Software Update)는 실행 중인 프로세스를 종료하지 않고 새 버전으로 업데이트하는 기술이다. 이 기술을 이용하여 C 응용 프로그램을 업데이트 하는 DSU 시스템들이 소개 되었으며, 각 시스템의 업데이트 방식 및 주요 기능에는 큰 차이가 있다. 본 논문에서는 기존 DSU 시스템의 단점을 해결할 수 있는 새로운 DSU 시스템을 제안한다. 이 시스템은 C 응용 프로그램을 코드, 전역 데이터 및 지역 데이터로 나누어 이들 각 부분의 특성을 고려하여 업데이트 한다. 이 논문에서 제안한 방법은 리눅스 운영체제 상에서 구현 및 시험하였으며 기존 DSU 시스템과 비교하여 다음과 같은 장점을 가진다. 첫째, 구 버전의 코드는 메모리에서 해제되므로 코드 메모리의 낭비가 적다. 둘째, 새 버전에서 수정되지 않은 전역 데이터는 메모리에 새로 할당할 필요가 없으므로 전역 데이터 메모리의 낭비가 적다. 셋째, 업데이트 시 구 버전의 지역 데이터는 스택 재구성 방식을 사용하여 새 버전의 지역 데이터로 복구한다. 본 논문은 새로운 DSU 방식을 제안하였다는 점과 이 방식을 활용하여 완전한 DSU 시스템을 구현하였다는 점에서 의의가 있다. Dynamic Software Update(DSU) is a technique, which updates a new version of the software to a running process without stopping. Many DSU systems that update C application programs are introduced. However, these DSU systems differ in implementation method or in main features. In this paper, we propose a new DSU system that can solve some disadvantages of existing DSU systems. DSU system presented in this paper splits existing program to code, global data and local data and then updates each part of the program considering the characteristics of the respective parts. The proposed system in this paper is implemented and tested on Linux. Also, we compared our DSU system with other DSU systems and we could find some strength of our DSU system. First, the code memory usage of our DSU system can be efficient since our system does not need to maintain code of an old version. Second, the global data memory waste is small because our system does not need to allocate the global data again which is not modified in the new version. Finally, we restore local data of old version in stack area of the new version using stack reconstruction technique. This paper is meaningful since we proposed a new DSU method and we implemented a full DSU system using the method.

Formalization and Verification of Behavioral Correctness of Dynamic Software Updates

Dynamic Software Updating (DSU) is a technique of updating running software systems on-the-fly. Whereas there are some studies on the correctness of dynamic updating, they focus on how to deploy updates correctly at the code level, e.g., if procedures refer to the data of correct types. However, little attention has been paid to the correctness of the dynamic updating at the behavior level, e.g., if systems after being updated behave as expected, and if unexpected behaviors can never occur. We present an algebraic methodology of specifying dynamic updates and verifying their behavioral correctness by using off-the-shelf theorem proving and model checking tools. By theorem proving we can show that systems after being updated indeed satisfy their desired properties, and by model checking we can detect potential errors. Our methodology is general in that: (1) it can be applied to three updating models that are mainly used in current DSU systems; and (2) it is not restricted to dynamic updates for certain programming models.