Fabien Dagnat

Using free modeling as an agile method for developing domain specific modeling languages

Mostly the development of domain specific modeling languages (DSML) follows the traditional model driven engineering practices. First the syntax and semantics of the language are defined (at meta-level) and then it is used for the development of user models. In certain situations, it is hard even to conceptualize the demands of the user, let alone the definition of the language. Agile methods for software development suggest that the development activities should be performed alongside a client stakeholder for incremental development of the system. This approach helps in the elicitation of requirements in parallel to the actual development of the system. We followed this approach for developing a domain specific modeling language and its tooling for a local government project, Brest Métropole. The project aimed at filling the communication gap between the elected representatives (politicians) and the bureaucracy (government officers). We used a modeling methodology that does not restrict a modelers interaction to a single abstraction level. Thus a modeler can develop both models and metamodels at the same time, where the definition of one helps in defining the other. In this article, we explain our experiences from this project and share the lessons learnt.

Addressing modularity for heterogeneous multi-model systems using model federation

Model-Driven Engineering (MDE) proposes to modularize complex software-intensive systems using multiple models where each module serves a specific concern. These concerns of a system might be diverse and the use of multiple heterogeneous models often becomes inevitable. These models adhere to different paradigms and use distinct formalisms, which makes it hard to ensure consistency among them. Moreover, these models might contain certain concepts (at times overlapping) that are reused for building cross-concern views/models. Maintaining models using separation of concerns in a heterogeneous modeling space becomes difficult. Traditional MDE suggests the use of model transformations to maintain the mappings between heterogeneous models. In this paper, we introduce a different approach based on model federation to map heterogeneous models. In contrast to traditional approaches where heterogeneous models are gathered in a single technological space, model federation keeps them in their own technological spaces. We provide a mechanism so that elements of these models are accessible for the development of cross-concern views/models from their respective technological spaces.

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.

Towards a categorical framework to ensure correct software evolutions

Distributed software, such as satellite software are now developed and managed by several actors. In this context supporting the maintenance and therefore the evolution of such applications is complex and need a formal framework. In this article, we propose a first step towards such a formal framework to ensure the correctness of software evolutions. Using category theory, we can model software and represent patches. This modeling allows to identify the proof obligations that the provider of a patch has to discharge in order to ensure that its patch preserves the correctness of the software.

Towards context-aware components

Making component self-adaptable requires observation abilities. Observation features are usually intricated within the functional code. We propose to consider observation as an aspect. The solution we present in this paper allows an explicit specification of which observation data are required by a business component and which observation data this component offers to the other entities of the system. We illustrate the advantages of this separation of concerns for a self-adaptable web server.

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.