Formalization and Verification of Behavioral Correctness of Dynamic Software Updates

AbstractDynamic 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

Dependencies Management in Dynamically Updateable Component-Based System.

Component-based software systems achieve their functionalities through interaction between their components. Analyzing the dependencies between systems components is an essential task in system reconfiguration. This paper discusses dependencies analysis significance when updating component-based system dynamically. It presents a service-based matrix model and nested graph as approaches to capture components' dependencies; it discusses using dependencies analysis for safe dynamic updating in component-based software systems

E&F Chaos: a user friendly software package for nonlinear economic dynamics

The use of nonlinear dynamic models in economics and finance has expanded rapidly in the last two decades. Numerical simulation is crucial in the investigation of nonlinear systems. E&F Chaos is an easy-to-use and freely available software package for simulation of nonlinear dynamic models to investigate stability of steady states and the presence of periodic orbits and chaos by standard numerical simulation techniques such as time series, phase plots, bifurcation diagrams, Lyapunov exponent plots, basin boundary plots and graphical analysis. The package contains many well-known nonlinear models, including applications in economics and finance, and is easy to use for non-specialists. New models and extensions or variations are easy to implement within the software package without the use of a compiler or other software. The software is demonstrated by investigating the dynamical behavior of some simple examples of the familiar cobweb model, including an extension with heterogeneous agents and asynchronous updating of strategies. Simulations with the E&F chaos software quickly provide information about local and global dynamics and easily lead to challenging questions for further mathematical analysis.

A simplified software architecture for self-updating Building Information Models (BIM)

Thesis (S.M.)--Massachusetts Institute of Technology, Dept. of Civil and Environmental Engineering, 2009.Cataloged from PDF version of thesis.Includes bibliographical references (p. 61-63).Building Information Modeling (BIM) is an emerging software technology that is revolutionizing the architecture, engineering, and construction (A/E/C) industry. BIM technology employs "object-based 3D models-containing the physical and functional characteristics of a facility-that serve as a repository for lifecycle information in an open, interoperable format" [1]. The major difference between BIM and Computer-Aided Design/Drafting (CADD) is that the former includes geometry and a plethora of building information while the latter includes only geometry. BIM utilization in the AEC industry has increased due to 1) BIM tools increasing productivity in design tasks; 2) the increasing number of private and government agencies that have instituted BIM requirements; 3) the pervasive use of computer analysis and simulations models; 4) the benefits of BIM as lifecycle management tool. Current literature shows trends of a transition from a "passive"-static model-based-approach to an "active"-dynamic model-based-approach. The active approach requires the integration of BIM with sensors to create "self-updating" building models. Previous research introduces the concept of a self-updating building model ([2], [31, [41). These systems involve complex software architecture and may perpetuate the problem of software interoperability. This thesis explores the following question: May a similar system be created to synthesize dynamic sensor data while improving upon previous research and simplifying the software architecture? The author describes a prototype system, called LiveBuild, which integrates commercial BIM software with other off-the-shelf software components to create a self-updating building model. LiveBuild is the first self-updating building model that operates as an extension to existing commercial BIM software. Therefore, the transition from static to active building models is as simple as installing a plug-in. LiveBuild may serve as the basis for future research in self-updating building by providing simplified system that is well integrated with state-of-the art commercial design software. Likewise, the prototype is applicable for professional practice by allowing firms to use their existing BIM software to perform "pilot projects" with self-updating technology. The current prototype supports an interface with single commercial BIM software (Autodesk Revit 2009) product however future prototypes may extend both the functions and interfaces for other BIM software.by Pierre Fuller.S.M

A Framework For Dynamic Updating In Component-based Software Systems

Setiap sistem perisian (software) perlu dikemas kini setiap masa bagi pelbagai alasan seperti penetapan pepijat (fixing bugs) Every software system needs to be updated over time for different reasons such as fixing bugs, upgrading its components, or adapting the system in response to its environment's changes

A Framework For Dynamic Updating In Component-Based Software Systems.

This paper presents DPICS framework for composing component-based software system that can be modified at runtime. It is based on message pattern interaction between system’s components, which facilitates adding, removing, or replacing a component while the whole system is running

Shortening Time-to-Discovery with Dynamic Software Updates for Parallel High Performance Applications

Despite using multiple concurrent processors, a typical high performance parallel application is long-running, taking hours, even days to arrive at a solution. To modify a running high performance parallel application, the programmer has to stop the computation, change the code, redeploy, and enqueue the updated version to be scheduled to run, thus wasting not only the programmer’s time, but also expensive computing resources. To address these inefficiencies, this article describes how dynamic software updates can be used to modify a parallel application on the fly, thus saving the programmer’s time and using expensive computing resources more productively. The net effect of updating parallel applications dynamically reduces their time-to-discovery metrics, the total time it takes from posing a problem to arriving at a solution. To explore the benefits of dynamic updates for high performance applications, this article takes a two-pronged approach. First, we describe our experience in building and evaluating a system for dynamically updating applications running on a parallel cluster. We then review a large body of literature describing the existing state of the art in dynamic software updates and point out how this research can be applied to high performance applications. Our experimental results indicate that dynamic software updates have the potential to become a powerful tool in reducing the time-to-discovery metrics for high performance parallel applications

Automating Object Transformations for Dynamic Software Updating via Online Execution Synthesis

Dynamic software updating (DSU) is a technique to upgrade a running software system on the fly without stopping the system. During updating, the runtime state of the modified components of the system needs to be properly transformed into a new state, so that the modified components can still correctly interact with the rest of the system. However, the transformation is non-trivial to realize due to the gap between the low-level implementations of two versions of a program. This paper presents AOTES, a novel approach to automating object transformations for dynamic updating of Java programs. AOTES bridges the gap by abstracting the old state of an object to a history of method invocations, and re-invoking the new version of all methods in the history to get the desired new state. AOTES requires no instrumentation to record any data and thus has no overhead during normal execution. We propose and implement a novel technique that can synthesize an equivalent history of method invocations based on the current object state only. We evaluated AOTES on software updates taken from Apache Commons Collections, Tomcat, FTP Server and SSHD Server. Experimental results show that AOTES successfully handled 51 of 61 object transformations of 21 updated classes, while two state-of-the-art approaches only handled 11 and 6 of 61, respectively