Search

The use of ML technology to design safety-critical systems requires a complete understanding of the neural network's properties. Among the relevant properties in an industrial context, the verification of partial monotony may become mandatory. This paper proposes a method to evaluate the monotony property using a Mixed Integer Linear Programming (MILP) solver. Contrary to the existing literature, this monotony analysis provides a lower and upper bound of the space volume where the property does not hold, that we denote ``Non-Monotonic Space Coverage''. This work has several advantages: (i) our formulation of the monotony property works on discrete inputs, (ii) the iterative nature of our algorithm allows for refining the analysis as needed, and (iii) from an industrial point of view, the results of this evaluation are valuable to the aeronautical domain where it can support the certification demonstration. We applied this method to an avionic case study (braking distance estimation using a neural network) where the verification of the monotony property is of paramount interest from a safety perspective.

International audience; The Robot Operating System (ROS) is one of the most used software framework to develop robot applications. Although it is possible to reuse packages and code from other ROS projects, ROS applications remain low level and reasoning at a higher level of abstraction is not possible. Using Model-Driven Engineering (MDE) in the context of ROS applications would allow to increase the accessibility of ROS, leverage the reusability of packages and supply validation of the software earlier in the design, using formal methods. For instance, formal verification methods would improve the overall dependability of robotic systems. Our view is that we should increase the abstraction of the systems through models using MDE methodology in order to enable the use of formal methods on ROS applications. In this paper we do a first step toward this and propose a comparative study of existing modeling alternatives aiming to help roboticists to smoothly adopt MDE. This study compares the use of modeling in ROS systems in three different ways: by means of direct UML modeling, a ROS UML profile and a ROS Domain-Specific Language. That allows us to pick the solution that better fits our needs.

International audience; The paper focuses on the development of cooperation between University Toulouse III-Paul Sabatier (UPS, newly UT3) and Technical University of Liberec (TUL), culminating in the completion of the Double Degree Master's program "Engineering of Interactive Systems" (2009-2015) and "Computer Science for Aerospace" (2017-2021). The development of the International doctoral workshop ECMS(M) uses the patronage of IEEE.

International audience; This paper reports on a four-year project that aims to raise the abstraction level through the use of model-driven engineering (MDE) techniques in the development of scientific applications relying on high-performance computing. The development and maintenance of high-performance scientific computing software is reputedly a complex task. This complexity results from the frequent evolutions of supercomputers and the tight coupling between software and hardware aspects. Moreover, current parallel programming approaches result in a mixing of concerns within the source code. Our approach relies on the use of MDE and consists in defining domain-specific modeling languages targeting various domain experts involved in the development of HPC applications, allowing each of them to handle their dedicated model in a both user-friendly and hardware-independent way. The different concerns are separated thanks to the use of several models as well as several modeling viewpoints on these models. Depending on the targeted execution platforms, these abstract models are translated into executable implementations by means of model transformations. To make all of these effective, we have developed a tool chain that is also presented in this paper. The approach is assessed through a multi-dimensional validation that focuses on its applicability, its expressiveness and its efficiency. To capitalize on the gained experience, we analyze some lessons learned during this project.

International audience; The complex problems that computational science addresses are more and more benefiting from the progress of computing facilities (simulators, librairies, accessible languages,. . .). Nevertheless , the actual solutions call for several improvements. Among those, we address in this paper the needs for leveraging on knowledge and expertise by focusing on Domain-Specific Mod-eling Languages application. In this vision paper we illustrate, through concrete experiments, how the last DSML research help getting closer the problem and implementation spaces.

International audience; Model-Based Systems Engineering plays a key role in managing the complexity in the development of modern cyber-physical systems. Model simulation allows conducting early validation and verification activities. In the context of Extended Enterprises, systems are built out of components developed in different companies as black boxes to protect the company Intellectual Property. Simulation activities thenrely on co-simulation that combines the black box simulation of each component to assess the quality of the whole system. Such activities are difficult to harness as the simulation results depend on black box co-simulation frameworks that coordinate the simulations of each component. Our work targets the modeling of these simulations including the co-simulation framework in order to: a) make explicit all the simulationchoices and have a better understanding of the simulation results and b) benefit from model-driven engineering facilities including automatic code generation. This contribution describes an early experiment based on the classical bouncingball game example.

Almost a decade has passed since the OMG has issued the Model Driven Architecture (MDA) initiative. It soon became obvious that raising the level of abstraction in development and reasoning at the model level would help in asking the right questions at the right time. Based on a concrete problem, we discuss four alternative solutions to a multi-language system design problem. These solutions use a traditional approach, a technique based on modeling, a domain-specific approach, and a mix of modeling and domain-specific techniques, respectively. The solutions depend on the problem, but they are representative for the situations we encounter in practice, therefore giving us a good basis for a larger discussion on the appropriateness of using modeling techniques and on the place of MDA in current software engineering practice and design.

Interconnected smart devices constitute a large and rapidly growing element of the contemporary Internet. A smart thing can be as simple as a web-enabled device that collects and transmits sensor data to a repository for analysis, or as complex as a web-enabled system to monitor and manage a smart home. Smart things present marvellous opportunities, but when they participate in complex systems, they challenge our ability to manage risk and ensure reliability. SDL, the ITU Standard Specification and Description Language, provides many advantages for modelling and simulating communicating agents --- such as smart things --- before they are deployed. The potential for SDL to enhance reliability and safety is explored with respect to existing smart things below. But SDL must advance if it is to become the language of choice for developing the next generation of smart things. In particular, it must target emerging IoT platforms, it must support simulation of interactions between pre-existing smart things and new smart things, and it must facilitate deployment of large numbers of similar things. Moreover, awareness of the potential benefits of SDL must be raised if those benefits are to be realized in the current and future Internet of Things.

The ideas of the papers in this special section have originally been presented at the first edition of the workshop on Specification and Validation of Real Time and Embedded Systems (SVERTS) that was held as a satellite workshop of the UML 2003 Conference in San Francisco. The motivation for initiating this workshop was the fact that UML started to be used more and more also for modelling real-time and embedded software systems, whereas it was lacking features for appropriately modelling this kind of systems. Another motivation was the fact that UML was missing an accepted dynamic semantics, or at least a framework for defining profiles not just in terms of syntax, but also their semantics. The six papers in this section reflect all parts of this problem.

This paper presents a technique and a tool for model-checking operational (design level) UML models based on a mapping to a model of communicating extended timed automata. The target language of the mapping is the IF format, for which existing model-checking and simulation tools can be used. Our approach takes into consideration most of the structural and behavioural features of UML, including object-oriented aspects. It handles the combination of operations, state machines, inheritance and polymorphism, with a particular semantic profile for communication and concurrency. We adopt a UML profile that includes extensions for expressing timing. The breadth of concepts covered by our mapping is an important point, as many previous approaches for applying formal validation to UML put much stronger limitations on the considered models. For expressing properties about models, a formalism called UML observers is defined in this paper. Observers reuse existing concepts like classes and state machines, and they allow expressing a significant class of linear temporal properties. The approach is implemented in a tool that imports UML models from an XMI repository, thus supporting several editors like Rational Rose, Rhapsody or Argo. The generated IF models may be simulated and verified via an interface that presents feedback in the vocabulary of the original UML model.

National audience; A plethora of theoretical results are available which make possible the use of dynamic analysis and model-checking for software and system models expressed in high-level modeling languages like UML, SDL or AADL. Their usage is hindered by the complexity of information processing demanded from the modeler in order to apply them and to effectively exploit their results. Our thesis is that by improving the visual presentation of the analysis results, their exploitation can be highly improved. To support this thesis, we define a trace analysis approach based on the extraction of high-level semantics events from the low-level output of a simulation or model-checking tool. This extraction offers the basis for new types of scenario visualizations, improving scenario understanding and exploration. This approach was implemented in our UML/SysML analyzer and was validated in a controlled experiment that shows a significant increase in the usability of our tool, both in terms of task performance speed and in terms of user satisfaction.

The fourth ACES-MB workshop brought together researchers and practitioners interested in model-based software engineering for real-time embedded systems, with a particular focus on the use of models for architecture description and domain-specific design, and for capturing non-functional constraints. Six presenters proposed contributions on a systematic transition from systems modeling using SysML to software modeling using UML, verification of initial architecture models against requirements using consistency checking techniques, techniques to check the validity of refinement relation between abstraction levels, constructing rapid prototypes to assess the behavioral design characteristics, new abstraction layers to describe operating system and mixed-signal issues, and a model-driven approach for parallelizing software programs. In addition, a lively group discussion tackled these issues in further detail. This report presents an overview of the presentations and fruitful discussions that took place during the ACES-MB 2011 workshop. © 2012 Springer-Verlag Berlin Heidelberg. ispartof: pages:257-261 ispartof: Lecture Notes in Computer Science vol:7167 pages:257-261 ispartof: International conference on model driven engineering languages and systems (MoDELS 2011) location:Wellington, New Zealand status: published

International audience; Recent years have seen a manifest increase in the use of modelling by the embedded systems industry. UML and SysML are two examples of languages used in this context. One of the reasons why the use of models is interesting is the possibility to perform early verification, validation and testing. A lot of work was devoted to developing theoretical results in verification and validation, and interesting results are available. Integrating these results in frameworks that take high-level models as an entry remains a challenging task, for several reasons that include the difficult scalability of the theoretical results. In previous work, we presented OMEGA 2, a framework that takes this challenge. Applying our framework on large industrial models revealed the fact that some features of the UML/SysML semantics which lead to bottlenecks in verification are not actually necessary in the models that we considered, thus leaving place for optimisations. This paper discusses the gap existing between the choices made in the general UML/SysML semantic framework and the actual needs of the users. We illustrate it based on the semantics of ports, for which we give a simplified version of the semantics. This semantics was implemented in our tools and we quantify the optimisation obtained when applying it to a set of case studies.

International audience; In recent years, numerical simulation has attracted increasing interest within industry and among academics. Paradoxically, the development and maintenance of high performance scientific computing software has become more complex due to the diversification of hardware architectures and their related programming languages and libraries. In this paper, we share our experience in using model-driven development for numerical simulation software. Our approach called MDE4HPC proposes to tackle development complexity by using a domain specific modeling language to describe abstract views of the software. We present and analyse the results obtained with its implementation when deriving this abstract model to target Arcane, a development framework for 2D and 3D numerical simulation software.

The third ACES-MB workshop brought together researchers and practitioners interested in model-based software engineering for real-time embedded systems, with a particular focus on the use of models for architecture description and domain-specific design, and for capturing non-functional constraints. Twelve presenters proposed contributions on metaheuristic search techniques for UML, modelling languages and mappings, model based verification and validation, software synthesis, and embedded systems product lines. In addition, a lively group discussion tackled these issues in further detail. This report presents an overview of the presentations and fruitful discussions that took place during the ACES-MB 2010 workshop. © 2011 Springer-Verlag Berlin Heidelberg. ispartof: pages:70-74 ispartof: Lecture Notes in Computer Science vol:6627 pages:70-74 ispartof: International conference on model driven engineering languages and systems (MoDELS 2010) location:Oslo, Norway status: published

The main specific features of high performance scientific simulation consist of obtaining optimal performance levels, sustainability of the codes and models and the use of dedicated architectures. The construction of codes and of the physical phenomena to be simulated requires substantial investments both in terms of human resources and of the experiments required to validate the models. The need for increasingly refined modeling leads to optimization of the performance levels of the codes to obtain simulation results within acceptable calculation times. Finally, the necessary recourse to highly specialized hardware resources adds further constraints to the programming of such software, especially when the lifetime of the codes, often close to 20 years, is compared to that of super computers, in the order of just 4 years. The MDA approach (Model Driven Architecture), standardized by the OMG and based on UML 2.0, provides among things a generic method for obtaining a runnable code from a UML model describing a system on several levels of modeling. Its various abstraction mechanisms should make it possible to increase the lifetime of our codes by facilitating the porting operations while at the same time improving performance thanks to the capitalization of good programming practices. MDA technologies have already proved their value in other fields of the computer industry. The sector of real time systems, for example, is based on UML to define a profile specific to their programming constraints (size on the onboard code, limited resources, rapidity of upgrades, etc.). By analogy to these other sectors of the computer industry, we have therefore chosen to adopt the definition of a UML profile specific to the constraints for the development of high performance scientific simulation. This approach is explained in the article which addresses in turn the following points: definition of a meta-model for high performance simulation, the use of proven technologies (Topcased, Acceleo) for the automatic transformation of models with in particular the automatic generation of a Fortran code, and finally an overall illustration of an implementation of this profile.

The second ACES-MB workshop brought together researchers and practitioners interested in model-based software engineering for real-time embedded systems, with a particular focus on the use of models for architecture description and domain-specific design, and for capturing non-functional constraints. Eleven presenters proposed contributions on domain-specific languages for embedded systems, the Architecture Analysis and Design Language (AADL), analysis and formalization, semantics preservation issues, and variability and reconfiguration. In addition, a lively group discussion tackled the issue of combining models from different Domain Specific Modeling Languages (DSMLs). This report presents an overview of the presentations and fruitful discussions that took place during the ACES-MB 2009 workshop. © Springer-Verlag Berlin Heidelberg 2010. ispartof: pages:63-67 ispartof: Lecture Notes in Computer Science vol:6002 pages:63-67 ispartof: International conference on model driven engineering languages and systems (MoDELS 2009) location:Denver, CO, USA date:4 Oct - 9 Oct 2009 status: published

This paper describes an approach for real-time modelling in UML, focusing on analysis and verification of time and scheduling-related properties. To this aim, a concrete UML profile, called the ωprofile, is defined, dedicated to real-time modelling by identifying a set of relevant concepts for real-time modelling which can be considered as a refinement of the standard SPT profile. The profile is based on a rich concept of event representing an instant of state change, and allows the expression of duration constraints between occurrences of events. These constraints can be provided in the form of OCL-like expressions annotating the specification or by means of state machines, stereotyped as ‘observers’. A framework for modelling scheduling issues is obtained by adding a notion of resource and a notion of execution time. For proving the relevance of these choices, the profile has been implemented in a validation tool and applied to case studies. It has a formal semantics and is sufficiently general and expressive to define a semantic underpinning for other real-time profiles of UML which in general define more restricted frameworks. In particular, most existing profiles handling real-time issues define a number of predefined attributes representing particular durations or constraints on them and their semantic interpretation can be expressed in the OMEGA-RT profile.

This paper presents an overview on the IF toolset which is an environment for modelling and validation of heterogeneous real-time systems. The toolset is built upon a rich formalism, the IF notation, allowing structured automata-based system representations. Moreover, the IF notation is expressive enough to support real-time primitives and extensions of high-level modelling languages such as SDL and UML by means of structure preserving mappings.

We present a technique and a tool for model-checking operational UML models based on a mapping of object oriented UML models into a framework of communicating extended timed automata – in the IF format – and the use of the existing model-checking and simulation tools for this format.

This paper presents an overview on the IF toolset which is an environment for modelling and validation of heterogeneous real-time systems. The toolset is built upon a rich formalism, the IF notation, allowing structured automata-based system representations. Moreover, the IF notation is expressive enough to support real-time primitives and extensions of high-level modelling languages such as SDL and UML by means of structure preserving mappings. The core part of the IF toolset consists of a syntactic transformation component and an open exploration platform. The syntactic transformation component provides language level access to IF descriptions and has been used to implement static analysis and optimisation techniques. The exploration platform gives access to the graph of possible executions. It has been connected to different state-of-the-art model-checking and test-case generation tools. A methodology for the use of the toolset is presented at hand of a case study concerning the Ariane-5 Flight Program for which both an SDL and a UML model have been validated.

We present an approach towards a formal dynamic semantics for UML using ASM. We aim to remain as close as possible to the standard definition of UML and to cover the operational part of the language with particular attention to the behavior description based on actions. To remain close to the standard UML, we automatically translate the UML metamodel in ASM. This allows to take into account all the concepts and relationships contained in the standard, and to minimize the changes subsequent to the frequent updates of the standard. For the dynamic part, the particularity of our approach is that we focus on actions, as defined in our proposal to the OMG action semantics working group. We deal with concurrency, signal exchange, operation calls, general communication primitives, etc. We do not define the semantics of state machines, but we clearly define their place within the framework of our semantics. We also describe how the ASM domains and functions used in the semantics are built initially from a particular UML model.

International audience; In model-based engineering (MBE), the abstraction power of models is used to deal with the ever increasing complexity of modern software systems. As models play a central role in MBE-based development processes, for the adoption of MBE in practical projects it becomes indispensable to introduce rigorous methods for ensuring the correctness of the models. Consequently, much effort has been spent on developing and applying validation and verification (V&V) techniques for models. However, there are still many open challenges. In this paper, we shortly review the status quo of V&V techniques in MBE and derive a catalogue of open questions whose answers would contribute to successfully putting MBE into practice.

International audience; Model-Based Systems Engineering and early simulation based Validation & Verification are now key enablers for managing the complexity in the development of modern complex systems like Cyber- Physical Systems. Models provide a formal account of system require- ments and design decisions. Model simulation enables both design ex- ploration and design versus requirements correctness assessment. Model simulation activities rely on Simulation Systems (i.e. systems that exe- cute the model simulation). System execution environment models play a key role during these activities. Appropriate models must be devel- oped for each kind of analysis conducted during Validation & Verifica- tion. More and more often, complex Systems Engineering is conducted in Extended Enterprises and the simulation activities are performed us- ing partial models that must be completed with mock-up models for missing parts of the system. The development of Simulation Systems is thus costly and error prone and would benefit from the same Systems Engineering principles that are applied to the product. We propose a methodology for a seamless integration of the Simulation Systems devel- opment in the Products Systems Engineering. This method imports the available elements from the models of the system and its environment, from the Systems Engineering for Product space to a dedicated Systems Engineering for Simulation space. The required mock-up models are then defined in the Systems Engineering for Simulation space. As a result, we target a better management and reuse of the various environment and mock-up models in the various simulation activities during the devel- opment of the same product. This proposal is independent both of the actual methods and tools used to model the system and of the simulation environment.

International audience; This year’s ICCS conference theme promotes the use of computational science as a means to foster multidisciplinarity and synergies with other fields. Our thesis is that this trend towards multidisciplinarity should be accompanied by the use of best practices issued from the software engineering community in order to avoid obtaining overly complex and tangled code, difficult to validate, to maintain and to port. In this paper we argue for the need of applying separation of concerns principles when the development involves scientists from various application fields. We overview several strategies that may be used to achieve this separation, focusing mainly on two approaches drawn from our previous experiences with multidisciplinary projects, addressing two distinct patterns of multi-domain interaction that may occur in scientific software development.

This manuscript presents a methodology for the design of "early" simulations in extended enterprise, based on model-driven system engineering. The goal is to allow the system architect to explore alternative solutions, and to verify and/or validate the system architecture being designed, in relation to the user requirements. This methodology is divided into two complementary axes : the method part (new) and the means of execution, without which there can be no simulation. This new method is based on the following principle : starting from the user requirements to create the system architecture model, then derive the simulation architecture, develop the executable models and run the simulation in relation to objectives of verification and/or validation. By doing this, potential differences in interpretations between the system architecture model and simulation models are removed or at least reduced compared to a traditional approach. This method is of matrix type. The columns represent the actors, while the lines correspond to the different steps of the MBSE method used by the system architect for the product, including the refinement steps. The actors are the system architect for the product (SyA), a first new actor introduced by this method : the system architect for the simulation (SiA), the developers of the simulation executable models (SMD), and the second new actor in charge of the execution of the simulation (SEM). The analysis of its qualities and the production of results exploitable by the system architect for the product. As the method relies on a matrix structure, the SyA can request simulations, either in depth to specify a particular point of its model, or more in extension to check the good agreement of the functions between them. With this new matrix approach, the system architect for the product can reuse functions already defined during the upstream or downstream stages of its previous decompositions. Overall, saving time, costs, and confidence. The second axis of this methodology is the realization of an extended enterprise cosimulation (EE) platform, which is a project in itself. Based on a proposal of requirements specifications, the MBSE has defined a functional and physical architecture. The architecture of this platform can be modified according to the simulation needs expressed by the architect of the simulation. This is one of his prerogatives. The proposal introduces a third new player : the Infrastructure Project Manager (IPM) which is in charge of coordinating for the realization of the cosimulation platform, within his company. For an EE of federated type, that is to say from contractor to subcontractor, introduction of two new actors : - the supervisor of IPM, whose rôle is to link IPMs to solve the administrative and interconnection problems, - the person responsible in charge of the execution simulations. He coordinates, with the SEM of each partner, the implementation of simulations, ensures launches, and returns the results to all partners., Ce manuscrit présente une méthodologie pour la conception de systèmes de simulation de modèles en entreprise étendue, basée sur l'ingénierie système dirigée par les modèles. Le but est de permettre à l'architecte système d'explorer des solutions alternatives et de vérifier et/ou valider l'architecture du système en cours de conception, en regard des exigences et besoins des parties prenantes. Cette méthodologie se décline suivant deux axes complémentaires : la partie méthode et les moyens d'exécution, sans lesquels il ne peut y avoir de simulation. Cette nouvelle méthode se fonde sur le principe suivant : partir des exigences utilisateur pour créer les modèles d'architecture système, puis en dériver l'architecture de simulation, développer les modèles exécutables et exécuter la simulation en relation avec les objectifs de vérification et/ou validation. En agissant ainsi, les écarts d'interprétations potentiels entre le modèle d'architecture système et les modèles de simulation sont supprimés ou à tout le moins réduits, par rapport à une approche traditionnelle. Cette nouvelle méthode est de type matriciel. Les colonnes représentent les acteurs, tandis que les lignes correspondent aux différentes étapes de la méthode MBSE employée par l'architecte système pour le produit, y compris les étapes de raffinements. Les acteurs sont l'architecte système pour le produit (SyA), un premier nouvel acteur introduit par cette méthode : l'architecte système pour la simulation (SiA), les développeurs des modèles exécutables de simulation (SMD). Un second nouvel acteur est en charge de l'exécution de la simulation (SEM) au sein de chacune des entreprises, en charge de l'analyse et de la production des résultats exploitables par l'architecte système pour le produit. Avec cette méthode matricielle, le SyA peut demander des simulations, soit en profondeur pour préciser un point particulier de son modèle, soit en extension pour vérifier la bonne concordance des fonctions entre elles, tout en réutilisant des fonctions déjà définies durant les étapes amont ou aval de ses décompositions précédentes. Au global, gains de temps, de coûts, et de confiance. Le deuxième axe de cette méthodologie concerne la réalisation d'une plateforme de cosimulation en entreprise étendue (EE), qui est un projet en soi. Le MBSE a permis de définir une architecture fonctionnelle et physique de cette plateforme de cosimulation qui peut être amendée en fonction des besoins exprimés par l'architecte de la simulation. La proposition introduit un troisième nouvel acteur : le Infrastructure Project Manager (IPM) qui est en charge de la coordination pour la réalisation de la plateforme de cosimulation, au sein de son entreprise. Pour une EE de type donneur d'ordres à soustraitants, introduction de deux nouveaux acteurs : le superviseur d'IPM et le responsable de l'exécution des simulations (SEM), dont leurs rôles respectifs sont de faire le lien avec leurs pendants chez les partenaires.

In many domains such as aerospace and automotive industries, engineers rely on Domain Specific Modeling Languages (DSML) to solve the complex issues of engineering safety critical software. The difficulty to embrace the whole complexity of the concerns and the difficulty to manage their inter-relations has raised the interest of the engineering community for "concerns driven" engineering. This is addressed today in the model driven engineering research community through the exploration of "viewpoint modeling" technologies. The goal of this tutorial is to practice existing tools to create viewpoint and their associated DSMLs environment. We illustrate the conceptual simplicity and elegance of this multi-viewpoint approach using the running example of a small component based language in which component implementation are defined using Finite State Machine developed with a set of tools that has been integrated in the context of the French ANR project MOVIDA (MOdeling VIews and Decision support for Architects), Dans de nombreux domaines tels que les industries automobiles ou aérospaciales, les ingénieurs se basent sur des langages de modélisation spécifiques à un domaine pour maîtriser la complexité de la conception des systèmes critiques. Cette complexité globale liée aux nombreuses préoccupations de tels systèmes a augmenté l'intérèt de la communauté pour l'ingénierie dirigée par les points de vues ("concern driven engineering"). Ce problème est étudié par la communauté scientifique au travers de l'exploration des technologies de la modélisation des points de vues (viewpoint modeling). Le but de ce tutoriel est d'utiliser des outils existants pour créer des points de vues (viewpoints) et leur environnement DSML associé.Nous illustrons la simplicité conceptuelle de cette approche multi-vue en utilisant l'exemple d'un petit langage de composants dans lequel l'implémentation est définie en utilisant des automates d'états finis (Finite State Machine) avec différents outils intégrés dans le contexte du projet ANR MOVIDA (MOdeling VIews and Decision support for Architects).

International audience; Autonomic computing is recognized as one of the most promizing solutions to address the increasingly complex task of distributed environments' administration. In this context, many projects relied on software components and architectures to provide autonomic management frameworks. We designed such a component-based autonomic management framework, but observed that the interfaces of a component model are too low-level and difficult to use. Therefore, we introduced UML diagrams for the modeling of deployment and management policies. However, we had to adapt/twist the UML semantics in order to meet our requirements, which led us to define DSMLs. In this paper, we present our experience in designing the Tune system and its support for management policy specification, relying on UML diagrams and on DSMLs. We analyse these two approaches, pinpointing the benefits of DSMLs over UML.

Ambient intelligence aims to provide to human users applications and services that are personalized and adapted to the current situation. The ambient environment which surrounds the human consists of a set of connected objects and software components that are bricks used for the construction of applications by composition. The availability of these components can vary dynamically, in case of mobility for example. In addition, their appearance or disappearance is usually unanticipated. Moreover, in these dynamic and open environments, the user needs are not stable nor always well defined.To build these applications, and provide the user with “the right applications at the right time”, our team explores an original approach called "opportunistic software composition" : the idea is to build applications on the fly by assembling software components present in the environment at the time, without relying on explicit user needs or predefined applications models. Here, it is the availability of the components that triggers opportunistically the on the-fly building of applications. It is controlled by an intelligent system, called opportunistic composition engine, which decides on the “right” compositions to be made without user input. In such a way, the applications “emerge” dynamically from the ambient environment.Thus, emerging applications can be unexpected or unknown to the user. At the center of the system, the latter must be informed of these applications. On the first hand, she/he must be able to control them, i.e. accept or reject them, and if she/he has the required skills, modify them or eventually build applications herself/himself by assembling software components present in the ambient environment. However, in the control tasks, the user must be assisted as well as possible. On the other hand, in order for the opportunistic composition engine to build relevant assemblies in the absence of explicit needs, it must receive information from the user.In this thesis, we propose an approach based on Model Driven Engineering (MDE) in order to put the user "at the center of the loop". The objective is to present the emerging applications to the user, to assist him in his interventions and to extract useful feedback data to provide to the "intelligent" composition engine.Our solution is based on a metamodel for assembling software components, on different domain-specific languages (DSL) that support application descriptions, and on a graphical editor for editing applications and capturing user feedback. Different methods for model transformations are used to generate structural and semantic application descriptions for different users, from the applications models build by the intelligent engine. In addition, the descriptions can be easily adjusted to a particular human, by changing or adapting the DSL and the model transformations to the user’s profile. Unlike the traditional use of MDE where tools and techniques are used by engineers to develop software and generate code, the focus in our approach is on the end users.The entire solution has been implemented and works coupled with the engine. That is to say, our solution is able to intercept the applications models built by the engine, to transform them into presentable models that can be understood and modified by the user, and finally to capture the user feedback and give it back to the engine to update its knowledge.; L’intelligence ambiante vise à offrir à un utilisateur humain des applications et des services personnalisés et adaptés à la situation courante. L’environnement ambiant dans lequel cet humain est plongé est composé d’un ensemble d’objets connectés et de composants logicielsqui sont des briques de base pour la construction d’applications par composition. La disponibilité de ces composants peut varier dynamiquement, en cas de mobilité par exemple. Ceux-ci peuvent apparaître ou disparaître de manière non anticipée. De plus, dans ces environnements dynamiques et ouverts, le besoin de l’utilisateur humain n’est pas stable ni toujours bien défini.Pour construire des applications dans un tel contexte, et fournir à l’utilisateur “les bonnes applications au bon moment”, notre équipe explore une approche originale appelée “composition logicielle opportuniste” : l’idée est de construire des applications à la volée par assemblage de composants logiciels présents dans l’environnement sur le moment, sans se baser sur des besoins explicites ni sur des schémas de construction prédéfinis. C’est l’opportunité qui déclenche la construction des applications à la volée. Elle est contrôlée par un système intelligent, appelé moteur de composition opportuniste, qui doit décider des “bonnes” compositions à effectuer sans contribution explicite de l’utilisateur. Ainsi, les applications “émergent” dynamiquement.Les applications émergentes peuvent être imprévues ou inconnues de l’utilisateur. Au centre du système, ce dernier doit être en informé. Il doit pouvoir les contrôler, c’est-à-dire les accepter ou les rejeter, et s’il a les compétences requises, les modifier ou même construire lui-même des applications en assemblant des composants logiciels présents dans l’environnement ambiant. Dans les tâches de contrôle, l’utilisateur doit être assisté au mieux. D’autre part, pour que le moteur de composition opportuniste construise des assemblages pertinents en l’absence de besoins explicites, il doit recevoir des informations de l’utilisateur. Ceci ne doit cependant pas entraîner, pour l’utilisateur, une surcharge d’information ou d’opérations à effectuer.Dans cette thèse, nous proposons une approche basée sur l’ingénierie dirigée par les modèles (IDM) afin de mettre l’utilisateur “au centre de la boucle”. Il s’agit de lui présenter les applications émergentes, de l’assister dans son contrôle et d’extraire des données de feedback utiles à fournir au moteur de composition “intelligent”.Notre solution repose sur un métamodèle d’assemblage de composants logiciels, des langages spécifiques à un domaine (DSL) qui supportent la description des applications, un éditeur graphique qui permet d’éditer les applications et de capturer le feedback de l’utilisateur.Différentes transformations de modèle permettent l’interfaçage avec le moteur de composition et la génération de différentes formes de descriptions structurelles et sémantiques des applications pour des utilisateurs différents. En outre, les descriptions peuvent être facilement ajustées à un humain particulier, en changeant ou en adaptant les DSL et les transformations de modèle au profil de l’utilisateur.Dans notre approche, contrairement à l’utilisation classique de l’IDM où les outils et les techniques sont utilisés par les ingénieurs pour développer des logiciels et générer du code, le focus est sur les utilisateurs finaux qui prennent la place des ingénieurs.L’ensemble de la solution a été implémentée et fonctionne de manière couplée avec le moteur de composition opportuniste : notre solution prend en entrée les applications proposées par le moteur, les transforme en des modèles présentables, compréhensibles et modifiables par l’utilisateur, et enfin capture le feedback