La programmation orientée langage (Language-Oriented Programming – LOP) préconise l’utilisation de langages de modélisation dédiés exécutables (eXecutable Domain-Specific Modeling Languages – xDSMLs) pour la conception, le développement, la vérification et la validation de systèmes hautement concurrents. De tels systèmes placent l’expression de la concurrence dans les langages informatiques au coeur du processus d’ingénierie logicielle, par exemple à l’aide de formalismes dédiés appelés modèles de concurrence (Models of Concurrency – MoCs). Ceux-ci permettent une analyse poussée du comportement des systèmes durant les phases de vérification et de validation, mais demeurent complexes à comprendre, utiliser, et maîtriser. Dans cette thèse, nous développons et étendons une approche qui vise à faire collaborer l’approche LOP et les MoCs à travers le développement de xDSMLs dans lesquels la concurrence est spécifiée de façon explicite (Concurrency-aware xDSMLs). Dans de tels langages, on spécifie l’utilisation systématique d’un MoC au niveau de la sémantique d’exécution du langage, facilitant l’expérience pour l’utilisateur final qui n’a alors pas besoin d’appréhender et de maîtriser l’utilisation du MoC choisi.Un tel langage peut être raffiné lors de la phase de déploiement, pour s’adapter à la plateforme utilisée, et les systèmes décrits peuvent être analysés sur la base du MoC utilisé. / Language-Oriented Programming (LOP) advocates designing eXecutable Domain-Specific Modeling Languages (xDSMLs) to facilitate the design, development, verification and validation of modern softwareintensive and highly-concurrent systems. These systems place their needs of rich concurrency constructs at the heart of modern software engineering processes. To ease theirdevelopment, theoretical computer science has studied the use of dedicated paradigms for the specification of concurrent systems, called Models of Concurrency (MoCs). They enable the use of concurrencyaware analyses such as detecting deadlocks or starvation situations, but are complex to understand and master. In this thesis, we develop and extend an approach that aims at reconciling LOP and MoCs by designing so-called Concurrencyaware xDSMLs. In these languages, the systematic use of a MoC is specified at the language level, removing from the end-user the burden of understanding or using MoCs. It also allows the refinement of the language for specific execution platforms, and enables the use of concurrency-aware analyses on the systems.

This paper introduces a graphical modeling notation based on coloured petri nets for the performance and cost evaluation of mobile applications. When developing such an application some restrictions due to the low bandwith of mobile networks need to be considered. The notation can be used to model the workflow of an mobile application with just a small effort. The resulting model can be (automatically) transformed into a coloured petri net for simulating the communication behaviour depending on typical user interactions. The simulation results are an important basis for improving the applications performance and the occuring costs for using mobile networks.

Cette thèse se situe à l'intersection de deux domaines-clés : l'ingénierie dirigée par les modèles (IDM) et les méthodes formelles, avec différents champs d'application. Elle porte sur la vérification formelle d'applications parallèles modélisées selon l'approche IDM. Dans cette approche, les modèles tiennent un rôle central et permettent de développer une application par transformations successives (automatisées ou non) entre modèles intermédiaires à différents niveaux d'abstraction, jusqu'à la production de code exécutable. Lorsque les modèles ont une sémantique formelle, il est possible d'effectuer une vérification automatisée ou semi-automatisée de l'application. Ces principes sont mis en oeuvre dans TOPCASED, un environnement de développement d'applications critiques embarquées basé sur ECLIPSE, qui permet la vérification formelle par connexion à des boîtes à outils existantes. Cette thèse met en oeuvre l'approche TOPCASED en s'appuyant sur la boîte à outils CADP pour la vérification et sur son plus récent formalisme d'entrée : LOTOS NT. Elle aborde la vérification formelle d'applications IDM à travers deux problèmes concrets : 1) Pour les systèmes GALS (Globalement Asynchrone Localement Synchrone), une méthode de vérification générique par transformation en LOTOS NT est proposée, puis illustrée sur une étude de cas industrielle fournie par AIRBUS : un protocole pour les communications entre un avion et le sol décrit dans le langage synchrone SAM conçu par AIRBUS. 2) Pour les services Web décrits à l'aide de la norme BPEL (Business Process Execution Language), une méthode de vérification est proposée, qui est basée sur une transformation en LOTOS NT des modèles BPEL, en prenant en compte les sous-langages XML Schema, XPath et WSDL sur lesquels repose la norme BPEL. / The work in this thesis is at the intersection of two major research domains~: Model-Driven Engineering (MDE) and formal methods, and has various fields of application. This thesis deals with the formal verification of parallel applications modelled by the MDE approach. In this approach, models play a central role and enable to develop an application through successive transformations (automated or not) between intermediate models of differing levels of abstraction, until executable code is produced. When models have a formal semantics, the application can be verified, either automatically or semi-automatically. These principles are used in TOPCASED, an ECLIPSE-based development environment for critical embedded applications, which enables formal verification by interconnecting existing tools. This thesis implements the TOPCASED approach by relying on the CADP toolbox for verifying systems, and on its most recent input formalism : LOTOS NT. This thesis tackles the formal verification of MDE applications through two real problems : 1) For GALS (Globally Asynchronous, Locally Synchronous), a generic verification method, based on a transformation to LOTOS NT, is proposed and illustrated by an industrial case-study provided by AIRBUS : a communication protocol between the airplane and the ground described in the synchronous langage SAM designed at AIRBUS. 2) For Web services specified with the BPEL (Business Process Execution Language) norm, a verification method is proposed. It is based on a BPEL to LOTOS NT transformation which takes into account XML Schema, Xpath, and WSDL, the languages on which the BPEL norm is built.

The development of self-adaptive software requires the engineering of an adaptation engine that controls and adapts the underlying adaptable software by means of feedback loops. The adaptation engine often describes the adaptation by using runtime models representing relevant aspects of the adaptable software and particular activities such as analysis and planning that operate on these runtime models. To systematically address the interplay between runtime models and adaptation activities in adaptation engines, runtime megamodels have been proposed for self-adaptive software. A runtime megamodel is a specific runtime model whose elements are runtime models and adaptation activities. Thus, a megamodel captures the interplay between multiple models and between models and activities as well as the activation of the activities. In this article, we go one step further and present a modeling language for ExecUtable RuntimE MegAmodels (EUREMA) that considerably eases the development of adaptation engines by following a model-driven engineering approach. We provide a domain-specific modeling language and a runtime interpreter for adaptation engines, in particular for feedback loops. Megamodels are kept explicit and alive at runtime and by interpreting them, they are directly executed to run feedback loops. Additionally, they can be dynamically adjusted to adapt feedback loops. Thus, EUREMA supports development by making feedback loops, their runtime models, and adaptation activities explicit at a higher level of abstraction. Moreover, it enables complex solutions where multiple feedback loops interact or even operate on top of each other. Finally, it leverages the co-existence of self-adaptation and off-line adaptation for evolution. / Die Entwicklung selbst-adaptiver Software erfordert die Konstruktion einer sogenannten "Adaptation Engine", die mittels Feedbackschleifen die unterliegende Software steuert und anpasst. Die Anpassung selbst wird häufig mittels Laufzeitmodellen, die die laufende Software repräsentieren, und Aktivitäten wie beispielsweise Analyse und Planung, die diese Laufzeitmodelle nutzen, beschrieben. Um das Zusammenspiel zwischen Laufzeitmodellen und Aktivitäten systematisch zu erfassen, wurden Megamodelle zur Laufzeit für selbst-adaptive Software vorgeschlagen. Ein Megamodell zur Laufzeit ist ein spezielles Laufzeitmodell, dessen Elemente Aktivitäten und andere Laufzeitmodelle sind. Folglich erfasst ein Megamodell das Zusammenspiel zwischen verschiedenen Laufzeitmodellen und zwischen Aktivitäten und Laufzeitmodellen als auch die Aktivierung und Ausführung der Aktivitäten. Darauf aufbauend präsentieren wir in diesem Artikel eine Modellierungssprache für ausführbare Megamodelle zur Laufzeit, EUREMA genannt, die aufgrund eines modellgetriebenen Ansatzes die Entwicklung selbst-adaptiver Software erleichtert. Der Ansatz umfasst eine domänen-spezifische Modellierungssprache und einen Laufzeit-Interpreter für Adaptation Engines, insbesondere für Feedbackschleifen. EUREMA Megamodelle werden über die Spezifikationsphase hinaus explizit zur Laufzeit genutzt, um mittels Interpreter Feedbackschleifen direkt auszuführen. Zusätzlich können Megamodelle zur Laufzeit dynamisch geändert werden, um Feedbackschleifen anzupassen. Daher unterstützt EUREMA die Entwicklung selbst-adaptiver Software durch die explizite Spezifikation von Feedbackschleifen, der verwendeten Laufzeitmodelle, und Adaptionsaktivitäten auf einer höheren Abstraktionsebene. Darüber hinaus ermöglicht EUREMA komplexe Lösungskonzepte, die mehrere Feedbackschleifen und deren Interaktion wie auch die hierarchische Komposition von Feedbackschleifen umfassen. Dies unterstützt schließlich das integrierte Zusammenspiel von Selbst-Adaption und Wartung für die Evolution der Software.

This research is focused on helping engineers design better systems by supporting their decision making. When engineers design a system, they have an almost unlimited number of possible system alternatives to consider. Modern systems are difficult to design because of a need to satisfy many different stakeholder concerns from a number of domains which requires a large amount of expert knowledge. Current systems engineering practices try to simplify the design process by providing practical approaches to managing the large amount of knowledge and information needed during the process. Although these methods make designing a system more practical, they do not support a structured decision making process, especially at early stages when designers are selecting the appropriate system architecture, and instead rely on designers using ad hoc frameworks that are often self-contradictory. In this dissertation, a framework for performing architecture exploration at early stages of the design process is presented. The goal is to support more rational and self-consistent decision making by allowing designers to explicitly represent their architecture exploration problem and then use computational tools to perform this exploration. To represent the architecture exploration problem, a modeling language is presented which explicitly models the problem as an architecture selection decision. This language is based on the principles of decision-based design and decision theory, where decisions are made by picking the alternative that results in the most preferred expected outcome. The language is designed to capture potential alternatives in a compact form, analysis knowledge used to predict the quality of a particular alternative, and evaluation criteria to differentiate and rank outcomes. This language is based on the Object Management Group's System Modeling Language (SysML). Where possible, existing SysML constructs are used; when additional constructs are needed, SysML's profile mechanism is used to extend the language. Simply modeling the selection decision explicitly is not sufficient, computational tools are also needed to explore the space of possible solutions and inform designers about the selection of the appropriate alternative. In this investigation, computational tools from the mathematical programming domain are considered for this purpose. A framework for modeling an architecture selection decision in mixed-integer linear programming (MIP) is presented. MIP solvers can then solve the MIP problem to identify promising candidate architectures at early stages of the design process. Mathematical programming is a common optimization domain, but it is rarely used in this context because of the difficulty of manually formulating an architecture selection or exploration problem as a mathematical programming optimization problem. The formulation is presented in a modular fashion; this enables the definition of a model transformation that can be applied to transform the more compact SysML representation into the mathematical programming problem, which is also presented. A modular superstructure representation is used to model the design space; in a superstructure a union of all potential architectures is represented as a set of discrete and continuous variables. Algebraic constraints are added to describe both acceptable variable combinations and system behavior to allow the solver to eliminate clearly poor alternatives and identify promising alternatives. The overall framework is demonstrated on the selection of an actuation subsystem for a hydraulic excavator. This example is chosen because of the variety of potential architecture embodiments and also a plethora of well-known configurations which can be used to verify the results.

<p>Object-oriented frameworks are currently widely used in software application development. Unfortunately, they are known to be generally difficult to use because of the difficulty in understanding the concepts and constraints in different frameworks. With the formalization of framework concepts and constraints in domain-specific modeling languages called framework-specific modeling languages (FSMLs), previous works have shown that round-trip engineering between models of applications using frameworks and the application code is possible to aid framework application development.</p> <p>Framework-specific modeling languages only capture, however, framework concepts and constraints and hence, lack the expressiveness of general-purpose modeling languages. For this reason, the complete code for an entire framework application cannot be generated from the model in the model editor using round-trip engineering, and the user would need to switch to the code editor to program the application logic code. Also, since models are only abstractions of code, implementation details in code may be missing in models. Although default implementation details can be used when generating code from a model, the generated code might require further customization by the user, which would also require switching to the code editor.</p> <p>To reduce the need for the user to switch between the model editor and the code editor and to reduce the need to customize the generated code, this thesis presents a model-guided approach to providing code assistance for framework application development directly in the code editor, where additional implementation details can also be obtained. An approach to building a context-sensitive code assistant that aids the user in the implementation of framework concepts with the consideration of framework constraints is described. A prototype has further been implemented and applied on two widely popular frameworks. The evaluation in this thesis analyzes and characterizes framework concepts and shows that the framework-based code assistant can reduce the need to customize the generated code in the code editor when compared to code generation from the model editor.</p>

<p>Object-oriented frameworks are currently widely used in software application development. Unfortunately, they are known to be generally difficult to use because of the difficulty in understanding the concepts and constraints in different frameworks. With the formalization of framework concepts and constraints in domain-specific modeling languages called framework-specific modeling languages (FSMLs), previous works have shown that round-trip engineering between models of applications using frameworks and the application code is possible to aid framework application development.</p> <p>Framework-specific modeling languages only capture, however, framework concepts and constraints and hence, lack the expressiveness of general-purpose modeling languages. For this reason, the complete code for an entire framework application cannot be generated from the model in the model editor using round-trip engineering, and the user would need to switch to the code editor to program the application logic code. Also, since models are only abstractions of code, implementation details in code may be missing in models. Although default implementation details can be used when generating code from a model, the generated code might require further customization by the user, which would also require switching to the code editor.</p> <p>To reduce the need for the user to switch between the model editor and the code editor and to reduce the need to customize the generated code, this thesis presents a model-guided approach to providing code assistance for framework application development directly in the code editor, where additional implementation details can also be obtained. An approach to building a context-sensitive code assistant that aids the user in the implementation of framework concepts with the consideration of framework constraints is described. A prototype has further been implemented and applied on two widely popular frameworks. The evaluation in this thesis analyzes and characterizes framework concepts and shows that the framework-based code assistant can reduce the need to customize the generated code in the code editor when compared to code generation from the model editor.</p>

This dissertation develops a new model transformation approach that supports engineering model integration, which is essential to support contemporary interdisciplinary system design processes. We extend traditional model transformation, which has been primarily used for software engineering, to enable model-based systems engineering (MBSE) so that the model transformation can handle more general engineering models. We identify two issues that arise when applying the traditional model transformation to general engineering modeling domains. The first is instance data integration: the traditional model transformation theory does not deal with instance data, which is essential for executing engineering models in engineering tools. The second is syntactical inconsistency: various engineering tools represent engineering models in a proprietary syntax. However, the traditional model transformation cannot handle this syntactic diversity. In order to address these two issues, we propose a new multi-layer syntactical model transformation approach. For the instance integration issue, this approach generates model transformation rules for instance data from the result of a model transformation that is developed for user model integration, which is the normal purpose of traditional model transformation. For the syntactical inconsistency issue, we introduce the concept of the complete meta-model for defining how to represent a model syntactically as well as semantically. Our approach addresses the syntactical inconsistency issue by generating necessary complete meta-models using a special type of model transformation.

Submitted by Marlene Santos (marlene.bc.ufg@gmail.com) on 2016-03-22T17:53:33Z No. of bitstreams: 2 Dissertação - Gustavo Cipriano Mota Sousa - 2012.pdf: 2362932 bytes, checksum: 554bee516fc979b416ec8ff1b253e521 (MD5) license_rdf: 19874 bytes, checksum: 38cb62ef53e6f513db2fb7e337df6485 (MD5) / Approved for entry into archive by Luciana Ferreira (lucgeral@gmail.com) on 2016-03-23T14:15:40Z (GMT) No. of bitstreams: 2 Dissertação - Gustavo Cipriano Mota Sousa - 2012.pdf: 2362932 bytes, checksum: 554bee516fc979b416ec8ff1b253e521 (MD5) license_rdf: 19874 bytes, checksum: 38cb62ef53e6f513db2fb7e337df6485 (MD5) / Made available in DSpace on 2016-03-23T14:15:40Z (GMT). No. of bitstreams: 2 Dissertação - Gustavo Cipriano Mota Sousa - 2012.pdf: 2362932 bytes, checksum: 554bee516fc979b416ec8ff1b253e521 (MD5) license_rdf: 19874 bytes, checksum: 38cb62ef53e6f513db2fb7e337df6485 (MD5) Previous issue date: 2012-10-09 / Coordenação de Aperfeiçoamento de Pessoal de Nível Superior - CAPES / Fundação de Amparo à Pesquisa do Estado de Goiás - FAPEG / The combination of domain-specific modeling languages and model-driven engineering techniques hold the promise of a breakthrough in the way applications are developed. By raising the level of abstraction and specializing in building blocks that are familiar in a particular domain, it has the potential to turn domain experts into application developers. Applications are developed as models, which in turn are interpreted at runtime by a specialized execution engine in order to produce the intended behavior. In this approach models are processed by domain-specific execution engines that embed knowledge about how to execute the models. This approach has been successfully applied in different domains, such as communication and smart grid management to execute applications described by models that can be created and changed at runtime. However, each time the approach has to be realized in a different domain, substantial re-implementation has to take place in order to put together an execution engine for the respective DSML. In this work, we present a generalization of the approach in the form of a metamodel that captures the domain-independent aspects of runtime model interpretation and allow the definition of a particular class of domain-specific execution engines which provide a highlevel service upon an underlying set of heterogenous set of resources. / Abordagens de engenharia de software dirigida por modelos propõem o uso de modelos como uma forma de lidar com a crescente complexidade das aplicações atuais. Por meio de linguagens de modelagem específicas de domínio, essas abordagens visam elevar o nível de abstração utilizado na engenharia de software, possibilitando que usuários que conheçam o domínio de negócio sejam capazes de construir aplicações. As aplicações são definidas como modelos que são então processados de forma automatizada por mecanismos capazes de executá-los. Essa abordagem tem sido aplicada em domínios como comunicação e redes elétricas inteligentes para possibilitar a construção de aplicações por meio de modelos que podem ser criados e modificados em tempo de execução. Nessa abordagem, modelos são processados por máquinas de execução específicas de domínio, que encapsulam o conhecimento necessário para executá-los. No entanto, a aplicação dessa mesma abordagem em outros domínios exige que novas máquinas de execução sejam implementadas por completo, o que exige um grande esforço de implementação. Neste trabalho, apresentamos uma abordagem dirigida por modelos para a construção dessas máquinas de execução de modelos. Essa abordagem propõe um metamodelo que captura os aspectos independentes de domínio de uma classe particular de máquinas de execução de modelos, os quais descrevem aplicações baseadas no provimento de serviços a partir de um conjunto heterogêneo de recursos. A partir do metamodelo proposto, podem ser construídos modelos que definem máquinas de execução para domínios específicos, as quais são capazes de executar modelos descritos na linguagem de modelagem específica do domínio em questão.

No description available.