Jérémy Buisson

ReCaml: execution state as the cornerstone of reconfigurations

To fix bugs or to enhance a software system without service disruption, one has to update it dynamically during execution. Most prior dynamic software updating techniques require that the code to be changed is not running at the time of the update. However, this restriction precludes any change to the outermost loops of servers, OS scheduling loops and recursive functions. Permitting a dynamic update to more generally manipulate the programs execution state, including the runtime stack, alleviates this restriction but increases the likelihood of type errors. In this paper we present ReCaml, a language for writing dynamic updates to running programs that views execution state as a delimited continuation. ReCaml includes a novel feature for introspecting continuations called match_cont which is sufficiently powerful to implement a variety of updating policies. We have formalized the core of ReCaml and proved it sound (using the Coq proof assistant), thus ensuring that state-manipulating updates preserve type-safe execution of the updated program. We have implemented ReCaml as an extension to the Caml bytecode interpreter and used it for several examples.

Issues in applying a model driven approach to reconfigurations of satellite software

Satellite software has to deal with specific needs including high integrity and dynamic updates. In order to deal with these requirements, we propose working at a higher level of abstraction thanks to model-driven engineering. Doing so involves many technologies including model manipulation, code generation and verification. Before we can implement the approach, there is a need for further research in these areas, e.g., about meta-transformations in order to maintain several consistent related code generators. We highlight such issues in regard to the current state of the art.

Introspecting continuations in order to update active code

In the case of critical systems and dynamic environments, it is necessary to apply bug fixes and functional enhancements at runtime. Mainly due to technical difficulties, updating active code is usually considered impractical. Most of researches on dynamic software update therefore prevent changing active code. In this paper, we study how to express manipulations of the execution state in terms of operations on continuations, thus enabling update of active code. We explore how language support can help doing so in a type-safe manner thanks to specific operators.

Coqcots & pycots: non-stopping components for safe dynamic reconfiguration

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, and; (ii) a reconfiguration development process including specification, proof of correctness using Coq, and 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 and the formalization allows ensuring the safety and consistency of the reconfiguration process.

Experiments with Fractal on Modular Reflection

In most reflective systems, the model of reflection objects often mirrors (a part of) the metamodel of the system. As a result, reflection is commonly tightly bound to the rest of the system. In this paper, we investigate the loosening of that coupling. With the rise of domain-specific modeling the need for separation of concerns and reuse when designing metamodels become critical. Therefore, we advocate the use of general design patterns abstracting the details of modeling languages when working on cross-cutting concerns (such as reflection) of a metamodel. Once the abstract patterns for reflection are built, they are mapped onto concrete modeling languages thanks to model engineering tools. In this paper, we apply this approach to the fractal component model. Following this process, reflection mechanisms built at the abstract level are straightforwardly reused and the resulting reflection system gains modularity.

Safe reconfiguration of Coqcots and Pycots components

Dynamic reconfiguration without suspending components.Integration of dynamic software updating and dynamic architecture reconfiguration.Coq proof mode as an interactive development environment for reconfigurations.Bidirectional translation between middleware and Coq-based abstract component model. Display Omitted 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.

The sosADL studio: an architecture development environment for software-intensive systems-of-systems

Conceiving Architecture Description Languages (ADLs) and accompanying Architecture Development Environments (ADEs) has been the subject of intensive research in the last two decades. This paper presents the SosADL Studio, an SoS ADE for accompanying SosADL in the formal development of evolutionary architectures of Systems-of-Systems (SoSs). SosADL Studio provides a model-driven ADE where SoS architecture descriptions in SosADL are edited, parsed, type checked, and transformed to different analysis languages for concurrent constraint solving, model checking, simulation, as well as statistical model checking.

Polychronous interpretation of synoptic, a domain specific modeling language for embedded flight-software

The SPaCIFY project, which aims at bringing advances in MDE to the satellite flight software indus- try, advocates a top-down approach built on a domain-specific modeling language named Synoptic. In line with previous approaches to real-time modeling such as Statecharts and Simulink, Synoptic features hierarchical decomposition of application and control modules in synchronous block dia- grams and state machines. Its semantics is described in the polychronous model of computation, which is that of the synchronous language SIGNAL.