L'ingénierie des systèmes embarqués repose sur deux activités complémentaires : la modélisation d'une part permet dereprésenter le système, l'analyse d’autre part permet d'évaluer les diverses propriétés non-fonctionnelles (par exemple despropriétés temporelles via l'analyse d’ordonnancement temps réel). Cette thèse s'intéresse à l'intégration entre ces modèleset analyses: comment appliquer une analyse sur une modèle ? Comment gérer le processus d’analyse ? La première partie de cette thèse présente une approche globale afin de répondre à ces questions. Cette approche s'organise autour de quatre couches applicatives: (1) les modèles qui représentent le système, (2) les accesseurs qui permettent d'extraire des données à partir d'un modèle, (3) l'analyse qui traite des données en entrée pour produire des données ou propriétés en sortie, (4) des contrats qui décrivent les interfaces d'une analyse et permettent d'orchestrer le processus d'analyse. La seconde partie de cette thèse est dédiée à l'expérimentation de cette approche sur des systèmes réels provenant du domaine aérospatial : un drone, un robot explorateur et un système de gestion de vol. Nous montrons que les accesseurs permettent d’appliquer diverses analyses d’ordonnancement temps réel sur des modèles architecturaux hétérogènes, par exemples décrits avec le standard industriel AADL (Architecture Analysis and Design Language) ou le nouveau langage dirigé par le temps CPAL (Cyber-Physical Action Language). En outre, nous montrons que les contrats peuvent être utilisés afin d’automatiser des procédures d'analyse complexes : quelle analyse peut être appliquée sur unmodèle ? Quelles analyses remplissent les objectifs visés ? Peut-on combiner des analyses ? Y-a-t-il des interférences entreles analyses ? Etc. / The engineering of embedded systems relies on two complementary activities: modeling on the one hand enables torepresent the system, analysis on the other hand makes it possible to evaluate the various non-functional properties (forexample, temporal properties with the real-time scheduling analysis). This thesis deals with the integration between thesemodels and analyses: how to apply an analysis on a model? How to manage the analysis process? The first part of this thesis presents a comprehensive approach to answer these questions. This approach is based on four application layers: (1) models to represent the system, (2) accessors to extract data from a model, (3) analyses to computeoutput data and/or properties from input data (4) contracts to represent the analysis interfaces and orchestrate the analysisprocess. The second part of this thesis deals with the experimentation of this approach with concrete systems coming fromthe aerospace: a drone, an exploratory robot and a flight management system. We demonstrate that the accessors enable toapply various real-time scheduling analyses on heterogeneous architectural models, for example written with the industrystandard AADL (Architecture Analysis and Design Language) or the new time-triggered language CPAL (Cyber-PhysicalAction Language). In addition, contracts make it possible to automate complex analysis procedures: which analysis can beapplied on a given model? Which are the analyses that meet a given goal? Are there analyses to be combined? Are thereinterferences between analyses? Etc.

Cette thèse s'intéresse à la sécurité des environnements virtualisés distribués type “Clouds” ou informatique en nuage. Dans ces environnements, le client bénéficie de ressources ou services (de calcul, stockage, etc.) à la demande sans connaissance de l'infrastructure sous-jacente. Ces services sont proposés à bas coût en mutualisant les ressources proposées aux clients. Ainsi, ces derniers se retrouvent à partager une infrastructure commune. Cependant, cette concentration des activités en fait une cible privilégiée pour un attaquant, d'autant plus intéressante que les Clouds présentent de nouveaux vecteurs d'attaque entre les clients du Clouds de part le partage des ressources. Actuellement, les fournisseurs de solutions de Cloud proposent une sécurité par défaut ne correspondant pas nécessairement aux besoins de sécurité des clients. Cet aspect est donc bien souvent négligé et cette situation donne lieu à de nombreux exemples d'attaques (vol de données, usage malicieux, etc.). Dans cette thèse, nous proposons une approche où le client spécifie ses besoins de sécurité ainsi que son application virtualisée au sein d'un modèle. Nous proposons notamment une nouvelle logique dédiée à l'expression de propriétés sur la propagation de l'information dans un système.Puis, nous proposons un déploiement automatique de ce modèle sur une infrastructure de type Cloud basée sur la virtualisation grâce à nos nouveaux algorithmes prenant en compte les propriétés de sécurité. Ces dernières sont assurées via un placement prenant en compte les risques d'attaques entre ressources partagées et/ou via la configuration de mécanismes de sécurité existants au sein du système. / This Thesis deals with security for virtualized distributed environments such as Clouds. In these environments, a client can access resources or services (compute, storage, etc.) on-demand without prior knowledge of the infrastructure underneath. These services are low-cost due to the mutualization of resources. As a result, the clients share a common infrastructure. However, the concentration of businesses and critical data makes Clouds more attractive for malicious users, especially when considering new attack vectors between tenants.Nowadays, Cloud providers offer default security or security by design which does not fit tenants' custom needs. This gap allows for multiple attacks (data thieft, malicious usage, etc.)In this Thesis, we propose a user-centric approach where a tenant models both its security needs as high-level properties and its virtualized application. These security objectives are based on a new logic dedicated to expressing system-based information flow properties. Then, we propose security-aware algorithm to automatically deploy the application and enforce the security properties. The enforcement can be realized by taking into account shared resources during placement decision and/or through the configuration of existing security mechanisms.

Submitted by Haroudo Xavier Filho (haroudo.xavierfo@ufpe.br) on 2016-03-11T14:00:27Z No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) tese bdtd - jhcp.pdf: 10794622 bytes, checksum: dc412b23838ca5016586548c59128658 (MD5) / Made available in DSpace on 2016-03-11T14:00:27Z (GMT). No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) tese bdtd - jhcp.pdf: 10794622 bytes, checksum: dc412b23838ca5016586548c59128658 (MD5) Previous issue date: 2015-02-27 / CAPES / A number of approaches have been proposed for eliciting, modeling and analyzing requirements for adaptive systems. However, there is still a large gap between such requirements specifications and the actual implementation of adaptive systems. In this thesis we investigate the interplay between requirements and architecture for the development of adaptive systems. Furthermore, we propose the Multi-Level Adaptation for Software Systems (MULAS) framework. This framework is centered on the iterative and incremental refinement of a goal model, towards the creation of a Design Goal Model. This model can then be used at runtime to drive adaptation on a system that is properly instrumented. Moreover, the framework includes a toolsupported process for generating statechart behavioral models from a Design Goal Model. The GATO tool (Goal TO Architecture) allows the creation of the different artifacts of the process, including the automatic generation of base statecharts. The suitability of this approach for developing adaptive systems is illustrated by means of case studies. Empirical results show that the techniques developed to translate enriched goal models onto statecharts are scalable, i.e. they present a good performance even with large models. Furthermore, an experiment with software engineering students indicates that the adoption of this framework by non-experts is feasible and beneficial. / Um grande número de abordagens foram propostas para elicitar, modelar e analisar requisitos para sistemas adaptativos. No entanto, ainda existe uma grande distância entre a especificação de requisitos e a implementação de um sistema adaptativo. Nesta tese foi investigada a interrelação entre requisitos e arquitetura para o desenvolvimento de sistemas adaptativos. Mais especificamente, nós propomos o framework Adaptação Multi-Nível para Sistemas de Software (MULAS, do inglês Multi-Level Adaptation for Software Systems). Este framework é focado no refinamento iterativo e incremental de um modelo de objetivos, em direção à criação de um Modelo de Objetivos de Design (DGM, do inglês Design Goal Model). Este modelo pode então ser utilizado em tempo de execução para se gerenciar a adaptação em um sistema devidamente instrumentado. Ademais, o framework inclui um processo para gerar diagramas de estados a partir do Modelo de Objetivos de Design. Uma ferramenta desenvolvida especificamente para apoiar este framework (GATO, do inglês, Goal TO Architecture) permite criar os diferentes artefatos do processo, incluindo a geração automática de diagrama de estados base. A adequação desta abordagem ao desenvolvimento de sistemas adaptativos é ilustrada através de estudos de caso. Resultados empíricos mostram que as técnicas desenvolvidas para criar diagramas de estados a partir do modelo de objetivos com elementos de design apresentam boa escalabilidade, i.e. possui bom desempenho mesmo no caso de modelos extensos. Adicionalmente, um experimento com estudantes de engenharia de software indica que a adoção do framework por não-especialistas não é apenas possível como também é benéfica.

Submitted by Franciele Moreira (francielemoreyra@gmail.com) on 2018-02-01T11:58:08Z No. of bitstreams: 2 Dissertação - Weider Alves Barbosa - 2017.pdf: 3232518 bytes, checksum: 2a1f899f2cf8bf0f76707049183a9888 (MD5) license_rdf: 0 bytes, checksum: d41d8cd98f00b204e9800998ecf8427e (MD5) / Approved for entry into archive by Luciana Ferreira (lucgeral@gmail.com) on 2018-02-02T09:42:07Z (GMT) No. of bitstreams: 2 Dissertação - Weider Alves Barbosa - 2017.pdf: 3232518 bytes, checksum: 2a1f899f2cf8bf0f76707049183a9888 (MD5) license_rdf: 0 bytes, checksum: d41d8cd98f00b204e9800998ecf8427e (MD5) / Made available in DSpace on 2018-02-02T09:42:07Z (GMT). No. of bitstreams: 2 Dissertação - Weider Alves Barbosa - 2017.pdf: 3232518 bytes, checksum: 2a1f899f2cf8bf0f76707049183a9888 (MD5) license_rdf: 0 bytes, checksum: d41d8cd98f00b204e9800998ecf8427e (MD5) Previous issue date: 2017-10-30 / Coordenação de Aperfeiçoamento de Pessoal de Nível Superior - CAPES / This thesis presents an approach to construct model execution machines based on the concept of Domain Specific Virtual Machines (DSVMs), focusing on the control middleware layer that is responsible for the control of model execution. In order to build this layer, we used techniques derived from model-driven engineering (MDE), in order to take advantage of the fact that DSVMs can both interpret models directly and be constructed using models. Another concept used in the proposed approach is the Separation of Concerns, separating the execution model from the knowledge of the application domain. In this sense, the main objective of this work is to propose an approach that unifies the MDE techniques and separation of concerns for the construction of DSVMs, thus allowing to express both the structure and operational semantics of the middleware. As a result, an instance of the control layer of a DSVM for the user-centric communication domain is displayed. We also present the results of a performance evaluation that was carried out to analyze the impact of proposed approach on the execution time. / Esta dissertação apresenta uma abordagem para construção de máquinas de execução de modelos baseadas no conceito de Domain Specific Virtual Machines (DSVMs), com foco na camada de middleware de controle, que é responsável pelo controle de execução de modelos. Para construir essa camada, foram utilizadas técnicas provenientes da engenharia dirigida por modelos (MDE), visando aproveitar o fato de que DSVMs podem tanto interpretar modelos diretamente, quanto ser construída por meio de modelos. Outro conceito utilizado na abordagem proposta é a separação de interesses (Separation of Concerns), separando o modelo de execução do conhecimento de domínio de aplicação. Neste sentido, o objetivo principal deste trabalho é propor uma abordagem que faça a união das técnicas MDE e separação de interesses para construção de DSVMs, permitindo assim expressar tanto a estrutura quanto a semântica operacional do middleware. Como resultado, é apresentada uma instância da camada de controle de uma DSVM para o domínio de comunicação centrada no usuário. Também são apresentados os resultados de uma avaliação de desempenho realizada para analisar a abordagem proposta sobre o tempo de execução.

Development and evolution of Domain-Specific Languages (DSLs) is becoming recurrent in the development of complex software-intensive systems. However, despite many advances in Software Language Engineering (SLE), DSLs and their tooling still suffer from substantial development costs which hamper their successful adoption in the industry. We identify two main challenges to be addressed. First, the proliferation of independently developed and constantly evolving DSLs raises the problem of interoperability between similar languages and environments. Second, since DSLs and their environments suffer from high development costs, tools and methods must be provided to assist language designers and mitigate development costs. To address these challenges, we first propose the notion of language interface. Using language interfaces, one can vary or evolve the implementation of a DSL while retaining the compatibility with the services and environments defined on its interface. Then, we present a mechanism, named model polymorphism, for manipulating models through different language interfaces. Finally, we propose a meta-language that enables language designers to reuse legacy DSLs, compose them, extend them, and customize them to meet new requirements. We implement all our contributions in a new language workbench named Melange that supports the modular definition of DSLs and the interoperability of their tooling. We evaluate the ability of Melange to solve challenging SLE scenarios. / Development and evolution of Domain-Specific Languages (DSLs) is becoming recurrent in the development of complex software-intensive systems. However, despite many advances in Software Language Engineering (SLE), DSLs and their tooling still suffer from substantial development costs which hamper their successful adoption in the industry. We identify two main challenges to be addressed. First, the proliferation of independently developed and constantly evolving DSLs raises the problem of interoperability between similar languages and environments. Second, since DSLs and their environments suffer from high development costs, tools and methods must be provided to assist language designers and mitigate development costs. To address these challenges, we first propose the notion of language interface. Using language interfaces, one can vary or evolve the implementation of a DSL while retaining the compatibility with the services and environments defined on its interface. Then, we present a mechanism, named model polymorphism, for manipulating models through different language interfaces. Finally, we propose a meta-language that enables language designers to reuse legacy DSLs, compose them, extend them, and customize them to meet new requirements. We implement all our contributions in a new language workbench named Melange that supports the modular definition of DSLs and the interoperability of their tooling. We evaluate the ability of Melange to solve challenging SLE scenarios.

[EN] Software development projects are diverse in nature. For this reason, software companies are often forced to define their methods in-house. In order to define methods efficiently and effectively, software companies require systematic solutions that are built upon sound methodical foundations. Providing these solutions is the main goal of the Method Engineering discipline. Method Engineering is the discipline to design, construct, and adapt methods, techniques, and tools for the development of information systems. Over the last two decades, a lot of research work has been performed in this area. However, despite its potential benefits, Method Engineering is not widely used in industrial settings. Some of the causes of this reality are the high theoretical complexity of Method Engineering and the lack of adequate software support. In this thesis, we aim to mitigate some of the problems that affect Method Engineering by providing a novel methodological approach that is built upon Model-Driven Engineering (MDE) foundations. The use of MDE enables a rise in abstraction, automation, and reuse that allows us to alleviate the complexity of our Method Engineering approach. Furthermore, by leveraging MDE techniques (such as metamodeling, model transformations, and models at runtime), our approach supports three phases of the Method Engineering lifecycle: design, implementation, and execution. This is unlike traditional Method Engineering approaches, which, in general, only support one of these phases. In order to provide software support for our proposal, we developed a Computer-Aided Method Engineering (CAME) environment that is called MOSKitt4ME. To ensure that MOSKitt4ME offered the necessary functionality, we identified a set of functional requirements prior to developing the tool. Then, after these requirements were identified, we defined the architecture of our CAME environment, and, finally, we implemented the architecture in the context of Eclipse. The thesis work was evaluated by means of a study that involved the participation of end users. In this study, MOSKitt4ME was assessed by means of the Technology Acceptance Model (TAM) and the Think Aloud method. While the TAM allowed us to measure usefulness and ease of use in a subjective manner, the Think Aloud method allowed us to analyze these measures objectively. Overall, the results were favorable. MOSKitt4ME was highly rated in perceived usefulness and ease of use; we also obtained positive results with respect to the users' actual performance and the difficulty experienced. / [ES] Los proyectos de desarrollo de software son diversos por naturaleza. Por este motivo, las compañías de software se ven forzadas frecuentemente a definir sus métodos de manera interna. Para poder definir métodos de forma efectiva y eficiente, las compañías necesitan soluciones sistemáticas que estén definidas sobre unos fundamentos metodológicos sólidos. Proporcionar estas soluciones es el principal objetivo de la Ingeniería de Métodos. La Ingeniería de Métodos es la disciplina que aborda el diseño, la construcción y la adaptación de métodos, técnicas y herramientas para el desarrollo de sistemas de información. Durante las dos últimas décadas, se ha llevado a cabo mucho trabajo de investigación en esta área. Sin embargo, pese a sus potenciales beneficios, la Ingeniería de Métodos no se aplica ampliamente en contextos industriales. Algunas de las principales causas de esta situación son la alta complejidad teórica de la Ingeniería de Métodos y la falta de un apropiado soporte software. En esta tesis, pretendemos mitigar algunos de los problemas que afectan a la Ingeniería de Métodos proporcionando una propuesta metodológica innovadora que está basada en la Ingeniería Dirigida por Modelos (MDE). El uso de MDE permite elevar el nivel de abstracción, automatización y reuso, lo que posibilita una reducción de la complejidad de nuestra propuesta. Además, aprovechando técnicas de MDE (como por ejemplo el metamodelado, las transformaciones de modelos y los modelos en tiempo de ejecución), nuestra aproximación da soporte a tres fases del ciclo de vida de la Ingeniería de Métodos: diseño, implementación y ejecución. Esto es a diferencia de las propuestas existentes, las cuales, por lo general, sólo dan soporte a una de estas fases. Con el objetivo de proporcionar soporte software para nuestra propuesta, implementamos una herramienta CAME (Computer-Aided Method Engineering) llamada MOSKitt4ME. Para garantizar que MOSKitt4ME proporcionaba la funcionalidad necesaria, definimos un conjunto de requisitos funcionales como paso previo al desarrollo de la herramienta. Tras la definción de estos requisitos, definimos la arquitectura de la herramienta CAME y, finalmente, implementamos la arquitectura en el contexto de Eclipse. El trabajo desarrollado en esta tesis se evaluó por medio de un estudio donde participaron usuarios finales. En este estudio, MOSKitt4ME se evaluó por medio del Technology Acceptance Model (TAM) y del método Think Aloud. Mientras que el TAM permitió medir utilidad y facilidad de uso de forma subjetiva, el método Think Aloud permitió analizar estas medidas objetivamente. En general, los resultados obtenidos fueron favorables. MOSKitt4ME fue valorado de forma positiva en cuanto a utilidad y facilidad de uso percibida; además, obtuvimos resultados positivos en cuanto al rendimiento objetivo de los usuarios y la dificultad experimentada. / [CAT] Els projectes de desenvolupament de programari són diversos per naturalesa. Per aquest motiu, les companyies es veuen forçades freqüenment a definir els seus mètodes de manera interna. Per poder definir mètodes de forma efectiva i eficient, les companyies necessiten solucions sistemàtiques que estiguin definides sobre uns fundaments metodològics sòlids. Proporcionar aquestes solucions és el principal objectiu de l'Enginyeria de Mètodes. L'Enginyeria de Mètodes és la disciplina que aborda el diseny, la construcció i l'adaptació de mètodes, tècniques i eines per al desenvolupament de sistemes d'informació. Durant les dues últimes dècades, s'ha dut a terme molt de treball de recerca en aquesta àrea. No obstant, malgrat els seus potencials beneficis, l'Enginyeria de Mètodes no s'aplica àmpliament en contextes industrials. Algunes de les principals causes d'aquesta situació són l'alta complexitat teòrica de l'Enginyeria de Mètodes i la falta d'un apropiat suport de programari. En aquesta tesi, pretenem mitigar alguns dels problemes que afecten a l'Enginyeria de Mètodes proporcionant una proposta metodològica innovadora que està basada en l'Enginyeria Dirigida per Models (MDE). L'ús de MDE ens permet elevar el nivell d'abstracció, automatització i reutilització, possibilitant una reducció de la complexitat de la nostra proposta. A més a més, aprofitant tècniques de MDE (com per exemple el metamodelat, les transformacions de models i els models en temps d'execució), la nostra aproximació suporta tres fases del cicle de vida de l'Enginyeria de Mètodes: diseny, implementació i execució. Açò és a diferència de les propostes existents, les quals, en general, només suporten una d'aquestes fases. Amb l'objectiu de proporcionar suport de programari per a la nostra proposta, implementàrem una eina CAME (Computer-Aided Method Engineering) anomenada MOSKitt4ME. Per garantir que MOSKitt4ME oferia la funcionalitat necessària, definírem un conjunt de requisits funcionals com a pas previ al desenvolupament de l'eina. Després de la definició d'aquests requisits, definírem la arquitectura de l'eina CAME i, finalment, implementàrem l'arquitectura en el contexte d'Eclipse. El treball desenvolupat en aquesta tesi es va avaluar per mitjà d'un estudi on van participar usuaris finals. En aquest estudi, MOSKitt4ME es va avaluar per mitjà del Technology Acceptance Model (TAM) i el mètode Think Aloud. Mentre que el TAM va permetre mesurar utilitat i facilitat d'ús de manera subjectiva, el mètode Think Aloud va permetre analitzar aquestes mesures objectivament. En general, els resultats obtinguts van ser favorables. MOSKitt4ME va ser valorat de forma positiva pel que fa a utilitat i facilitat d'ús percebuda; a més a més, vam obtenir resultats positius pel que fa al rendiment objectiu dels usuaris i a la dificultat experimentada. / Cervera Úbeda, M. (2015). A Model-Driven Approach for the Design, Implementation, and Execution of Software Development Methods [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/53931 / TESIS

No description available.

L'automatisation de la génération des artefacts textuels à partir des modèles est une étape critique dans l'Ingénierie Dirigée par les Modèles (IDM). C'est une transformation de modèles utile pour générer le code source, sérialiser les modèles dans de stockages persistents, générer les rapports ou encore la documentation. Parmi les différents paradigmes de transformation de modèle-au-texte, la génération de code basée sur les templates (TBCG) est la plus utilisée en IDM. La TBCG est une technique de génération qui produit du code à partir des spécifications de haut niveau appelées templates. Compte tenu de la diversité des outils et des approches, il est nécessaire de classifier et de comparer les techniques de TBCG existantes afin d'apporter un soutien approprié aux développeurs. L'objectif de ce mémoire est de mieux comprendre les caractéristiques des techniques de TBCG, identifier les tendances dans la recherche, et éxaminer l'importance du rôle de l'IDM par rapport à cette approche. J'évalue également l'expressivité, la performance et la mise à l'échelle des outils associés selon une série de modèles. Je propose une étude systématique de cartographie de la littérature qui décrit une intéressante vue d'ensemble de la TBCG et une étude comparitive des outils de la TBCG pour mieux guider les dévloppeurs dans leur choix. Cette étude montre que les outils basés sur les modèles offrent plus d'expressivité tandis que les outils basés sur le code sont les plus performants. Enfin, Xtend2 offre le meilleur compromis entre l'expressivité et la performance. / A critical step in model-driven engineering (MDE) is the automatic synthesis of a textual artifact from models. This is a very useful model transformation to generate application code, to serialize the model in persistent storage, generate documentation or reports. Among the various model-to-text transformation paradigms, Template-Based Code Generation (TBCG) is the most popular in MDE. TBCG is a synthesis technique that produces code from high-level specifications, called templates. It is a popular technique in MDE given that they both emphasize abstraction and automation. Given the diversity of tools and approaches, it is necessary to classify and compare existing TBCG techniques to provide appropriate support to developers. The goal of this thesis is to better understand the characteristics of TBCG techniques, identify research trends, and assess the importance of the role of MDE in this code synthesis approach. We also evaluate the expressiveness, performance and scalability of the associated tools based on a range of models that implement critical patterns. To this end, we conduct a systematic mapping study of the literature that paints an interesting overview of TBCG and a comparative study on TBCG tools to better guide developers in their choices. This study shows that model-based tools offer more expressiveness whereas code-based tools performed much faster. Xtend2 offers the best compromise between the expressiveness and the performance.

L'ingénierie dirigée par les modèles est une approche qui s'appuie sur l'abstraction pour exprimer davantage les concepts du domaine. Ainsi, les ingénieurs logiciels développent des langages dédiés (LD) qui encapsulent la structure, les contraintes et le comportement du domaine. Comme tout logiciel, les LDs évoluent régulièrement. Cette évolution peut se produire lorsque l'un de ses composants ou le domaine évolue. L'évolution du domaine ainsi que l'évolution des composants du LD et l'impact de cette évolution sur ceux-ci ont été largement étudiés. Cependant, un LD peut également dépendre sur d'éléments externes qui ne sont pas modélisées. Par conséquent, l'évolution de ces dépendances externes affecte le LD et ses composants. Actuellement, les ingénieurs logiciels doivent évoluer le LD manuellement lorsque les dépendances externes évoluent. Dans ce mémoire, nous nous concentrons sur l'évolution des librairies externes. Plus spécifiquement, le but de cette thèse est d'aider les ingénieurs logiciels dans la tâche d'évolution. À cette fin, nous proposons une approche qui intègre automatiquement les changements des librairies externes dans le LD. De plus, nous offrons un LD qui supporte l'évolution des librairies Arduino. Nous évaluons également notre approche en faisant évoluer un éditeur de modélisation interactif qui dépend d'un LD. Cette étude nous permet de montrer la faisabilité et l'utilité de notre approche. / Model-driven engineering (MDE) is an approach that relies on abstraction to further express domain concepts. Hence, language engineers develop domain-specific languages (DSLs) that encapsulates the domain structure, constraints, and behavior. Like any software, DSLs evolve regularly. This evolution can occur when one of its components or the domain evolves. The domain evolution as well as the evolution of DSL components and the impact of such evolution on them has been widely investigated. However, a DSL may also rely on external dependencies that are not modeled. As a result, the evolution of these external dependencies affects the DSL and its components. This evolution problem has yet to be addressed. Currently, language engineers must manually evolve the DSL when the external dependencies evolve. In this thesis, we focus on the evolution of external libraries. More specifically, our goal is to assist language engineers in the task of evolution. To this end, we propose an approach that automatically integrates the changes of the external libraries into the DSL. In addition, we offer a DSL that supports the evolution of the Arduino libraries. We also evaluate our approach by evolving an interactive modeling editor that depends on a DSL. This study allows us to demonstrate the feasibility and usefulness of our approach.

L'ingénierie dirigée par les modèles (MDE) est une méthodologie d'ingénierie logiciel qui permet aux ingénieurs de définir des modèles conceptuels pour un domaine spécifique. La MDE est supportée par des outils de modélisation, qui sont des éditeurs pour créer et manipuler des modèles spécifiques au domaine. Cependant, l'état actuel de la pratique de ces éditeurs de modélisation offre des interactions utilisateur très limitées, souvent restreintes à glisser-déposer en utilisant les mouvements de souris et les touches du clavier. Récemment, un nouveau cadre propose de spécifier explicitement les interactions utilisateur des éditeurs de modélisation. Dans cette thèse, nous étendons ce cadre pour supporter les interactions multitouches lors de la modélisation. Nous proposons un catalogue initial de gestes multitouches pour offrir une variété de gestes tactiles utiles. Nous démontrons comment notre approche est applicable pour générer des éditeurs de modélisation. Notre approche permet des interactions plus naturelles pour l'utilisateur quand il effectue des tâches de modélisation types. / Model-driven engineering (MDE) is a software engineering methodology that enables engineers to define conceptual models for a specific domain. Modeling is supported by modeling language workbenches, acting as editor to create and manipulate domain-specific models. However, the current state of practice of these modeling editors offers very limited user interactions, often restricted to drag-and-drop with mouse movement and keystrokes. Recently, a novel framework proposes to explicitly specify the user interactions of modeling editors. In this thesis, we extend this framework to support multi-touch interactions when modeling. We propose an initial set of multi-touch gesture catalog to offer a variety of useful touch gestures. We demonstrate how our approach is applicable for generating modeling editors. Our approach yields more natural user interactions to perform typical modeling tasks.