There is a strong synergy between the concepts of evolution and adaptation in software engineering: software adaptation refers to both the current software being adapted and to the evolution process that leads to the new adapted software. Evolution changes for the purpose of adaptation are usually made at development or compile time, and are meant to handle predictable situations in the form of software change requests. On the other hand, software may also change and adapt itself based on the changes in its environment. Such adaptive changes are usually dynamic, and are suitable for dealing with unpredictable or temporary changes in the software's operating environment. A promising solution for software adaptation is to develop self-adaptive software systems that can manage changes dynamically at runtime in a rapid and reliable way. One of the main advantages of self-adaptive software is its ability to manage the complexity that stems from highly dynamic and nondeterministic operating environments. If a self-adaptive software system has been engineered and used properly, it can greatly improve the cost-effectiveness of software change through its lifespan. However, in practice, many of the existing approaches towards self-adaptive software are rather expensive and may increase the overall system complexity, as well as subsequent future maintenance costs. This means that in many cases, self-adaptive software is not a good solution, because its development and maintenance costs are not paid off. The situation is even worse in the case of making current (legacy) systems adaptive. There are several factors that have an impact on the cost-effectiveness and usability of self-adaptive software; however the main objective of this thesis is to make a software system adaptive in a cost-effective way, while keeping the target adaptive software generic, usable, and evolvable, so as to support future changes. In order to effectively engineer and use self-adaptive software systems, in this thesis we propose a new conceptual model for identifying and specifying problem spaces in the context of self-adaptive software systems. Based on the foundations of this conceptual model, we propose a model-centric approach for engineering self-adaptive software by designing a generic adaptation framework and a supporting evolution process. This approach is particularly tailored to facilitate and simplify the process of evolving and adapting current (legacy) software towards runtime adaptivity. The conducted case studies reveal the applicability and effectiveness of this approach in bringing self-adaptive behaviour into non-adaptive applications that essentially demand adaptive behaviour to sustain.

Changing artifacts is intrinsic to the development and maintenance of software projects. The changes made to one artifact, however, do not come about in isolation. Software models are often vastly entangled. As such, a minuscule modification in one ripples in- consistency through several others. The primary goal of the this thesis is to investigate techniques and processes for the synchronization of artifacts in model driven development environments in which projects comprise manifold interdependent models, each being a live document that is continuously altered and evolved. The co-evolution of these artifacts demands an efficient mechanism to keep them consistent in such dynamic environments. To achieve this consistency, we intend to explore methods and algorithms for impact anal- ysis and the propagation of modifications across heterogenous interdependent models. In particular, we consider large scale models that are generated from other models by complex artifact generators. After creation, both the generated artifacts, and also the ones they are generated from, are subject to evolutionary changes throughout which their mutual consistency should be maintained. In such situations, the model transformation is the pri- mary benchmark of consistency rules between source and target models. But the rules are often implanted inside the implementation of artifact generators and hence unavailable. Trivially, the artifacts can be synchronized by regeneration. More often than not however, regeneration of such artifacts from scratch tends to be unwieldy due to their massive size. This thesis is a summary of research on effective change management methodologies in the context of model driven development. In particular, it presents two methods of in- crementally synchronizing software models related by existing model transformations, so that the synchronization time is proportional to the magnitude of change and not to the size of models. The first approach treats model transformations as black-boxes and adds to it incremental synchronization by a technique called conceptualization. The black-box is distinguished from other undertakings in that it does not require the extraction, re- engineering and re-implementation of consistency rules embedded inside transformations. The second approach is a white-box approach that uses static analysis to automatically transform the source code of the transformation into an incremental one. In particular it uses partial evaluation to derive a specialized, incremental transformation from the exist- ing one. These two approaches are complementary and together support a comprehensive range of model transformations.

Process-based arguments aim at demonstrating that a process, compliant with a standard, has been followed during the development of a safety-critical system. Compliance with these processes is mandatory for certification purposes, so the generation of process-based arguments is essential, but also a very costly and time-consuming task. In addition, inappropriate reasoning in the argumentation such as insufficient evidence (i.e. a fallacious argumentation), may result in a loss of quality of the system, leading to safety-related failures. Therefore, avoiding or detecting fallacies in process-based arguments is crucial. However, the process of reviewing such arguments is currently done manually and is based on the expert’s knowledge, so it is a very laborious and error-prone task.In this thesis, an approach to automatically generate fallacy-free process-based arguments is proposed and implemented. This solution is composed of two parts; (i) detecting omission of key evidence fallacies on the modelled processes, and (ii) transforming them into process-based safety arguments. The former checks automatically if the process model, compliant with the Software & Systems Process Engineering Metamodel (SPEM) 2.0, contains the sufficient information for not committing an omission of key evidence fallacy. If fallacies are detected, the functionality provides the proper recommendation to resolve them. Once the safety engineers/process engineers modify the process model following the provided recommendations, the second part of the solution can be applied. This one generates automatically the process-based argument, compliant with the Structured Assurance Case Metamodel (SACM), and displays it –rendered via Goal Structuring Notation (GSN)– into the OpenCert assurance case editor within the AMASS platform. The applicability of the solution is validated in the context of the ECSS-E-ST-40C standard.

Dans cette thèse, nous décrivons comment on peut utiliser un diagramme de séquence UML avec des contraintes de temps MARTE pour spécifier complètement le comportement des systèmes à base de composants tout en faisant abstraction des rôles fonctionnels des composants. Nous avons proposé une approche qui permet d'analyser ces spécifications d'une manière modulaire. Pour cela, nous avons attribué une sémantique opérationnelle aux diagrammes de séquence en les traduisant vers les TIOSTS qui sont des automates symbolique et temporisé. Nous avons utilisé des techniques d'exécution symbolique pour calculer les exécutions du système sous la forme d'un arbre symbolique. Nous avons défini des mécanismes de projection pour extraire l'arbre d'exécution associé à un composant sous-jacent. L'arbre résultant de la projection caractérise les comportements attendus du composant et peut être utilisé comme une référence pour valider le système bout par bout. Pour ce faire, nous nous sommes intéressés à des techniques de test. Nous avons présenté un résultat qui ramène la conformité du système à la conformité des composants qui le composent. Sur la base de ces résultats, nous avons proposé une méthodologie incrémentale de test basé sur des spécifications décrites sous la forme de diagrammes de séquence. / In this thesis, we describe how to use UML sequence diagrams with MARTE timing constraints to specify entirely the behavior of component-based systems while abstracting as much as possible the functional roles of components composing it. We have shown how to conduct compositional analysis of such specifications. For this, we have defined operational semantics to sequence diagrams by translating them into TIOSTS which are symbolic automata with timing constraints. We have used symbolic execution techniques to compute possible executions of the system in the form of a symbolic tree. We have defined projection mechanisms to extract the execution tree associated with any distinguished component. The resulting projected tree characterizes the possible behaviors of the component with respect to the context of the whole system specification. As such, it represents a constraint to be satisfied by the component and it can be used as a correctness reference to validate the system in a compositional manner. For that purpose, we have grounded our validation framework on testing techniques. We have presented compositional results relating the correctness of a system to the correctness of components. Based on these results, we have defined an incremental approach for testing from sequence diagrams.

Submitted by Fabio Sobreira Campos da Costa (fabio.sobreira@ufpe.br) on 2017-02-13T15:18:50Z No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) [dsc] Edson Alves v.1.5.6.pdf: 4201919 bytes, checksum: c682b493376c27a9896e5215c62283a1 (MD5) / Made available in DSpace on 2017-02-13T15:18:50Z (GMT). No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) [dsc] Edson Alves v.1.5.6.pdf: 4201919 bytes, checksum: c682b493376c27a9896e5215c62283a1 (MD5) Previous issue date: 2015-03-02 / CNPq / Model Driven Development (MDD) é um paradigma para geração automática de código executável que utiliza modelos como o seu artefato primário. No escopo de Banco de Dados, apesar das regras para transformação de esquemas Enhanced Entity Relationship (EER) em código da Structured Query Language (SQL)-Relacional já terem sido amplamente exploradas na literatura, não se encontrou um trabalho que ao mesmo tempo especifique tradutores MDD capazes de transformar, automaticamente, esquemas EER em códigos SQL-Relacional e aborde restrições como: Participação em Relacionamento, Disjunção e Completude em Herança ou Categoria são transformadas em estruturas SQL-Relacional. Neste contexto, visando dar uma contribuição às limitações mencionadas, esta dissertação apresenta duas macros contribuições: 1) um Catálogo de regras para transformar um esquema EER em um esquema Relacional e este em código SQL; e 2) um algoritmo que especifica uma ordem correta para a execução automática destas regras. De modo a mostrar a viabilidade e aplicação prática deste trabalho, o Catálogo de regras de transformação e o algoritmo para automatização do Catálogo são codificados na linguagem Query/View/Transformation-Relations (QVT-R) e implementados na ferramenta EERCASE. A avaliação do trabalho foi feita a partir da transformação de esquemas EER (não triviais) em códigos SQLRelacional, os quais são conferidos por especialistas de Banco de Dados. Por fim, comparando o trabalho proposto com os trabalhos relacionados investigados, constatou-se que o trabalho desta dissertação avança o estado da arte, pois é o único que é baseado em MDD e garante que as restrições de Participação em Relacionamento, Disjunção e Completude em Herança ou Categoria sejam automaticamente geradas para serem garantidas diretamente pelo Sistema de Gerenciamento de Banco de Dados. / Model Driven Development (MDD) is a paradigm for automatic generation of executable code that uses models as its primary artifact. In the database scope, despite the rules for transformation of Enhanced Entity Relationship (EER) schemas in code of Structured Query Language (SQL)-Relational have already been widely explored in the literature, we did not find a work that, at the same time, specifies MDD translators capable of transforming, automatically, EER schemas in SQL-Relational codes and addresses restrictions such as: Participation in Relationship, Disjunction and Completeness in Inheritance or Category are transformed into SQL-relational structures. In this context, in order to contribute for the mentioned limitations, this dissertation presents two macro contributions: 1) a rule Catalog to transform an EER schema into a Relational schema and this SQL code; and 2) an algorithm that specifies a correct order for the automatic enforcement of these rules. In order to show the feasibility and practical application of this work, the Catalog of transformation rules and the algorithm for Catalog automation are encoded in Query/View/TransformationRelations (QVT-R) language and implemented in EERCASE tool. The evaluation of the work was made from the processing of EER schemas (nontrivial) in SQL-Relational codes, which are conferred by database experts. Finally, comparing the proposed work with the related work investigated, it was found that the proposed work advances the state of the art, as it is the only one that is based on MDD and ensures that the restrictions on Participation in Relationship, Disjunction in Inheritance and Completeness in Inheritance or Category are guaranteed by the Database Management System.

One of the inevitable negative effects of software evolution is design erosion. Refactoring is a technique that aims at counteracting this phenomenon by successively improving the design of software without changing its observable behaviour. Design erosion occurs also in the context of executable UML models, i.e. models that are detailed enough to be automatically compiled to executable applications. This thesis presents results of a study on applying refactoring to the area of maintenance of executable UML models. It contains an overview of recent approaches to UML model refactoring and to executable modelling, followed by identification of refactoring areas in models built in Telelogic TAU, a state-of-the art UML CASE tool. It proposes a systematic approach to specification of both executable UML model refactorings as well as associated bad smells in models. Additionally, it shows how refactorings can be implemented in Telelogic TAU.

Enterprise models are usually developed with ambition to capture the current or desired situation in enterprises with respect to performed or planned processes, organizational structure (including organization units, roles and competences), products or services produced and IT systems available in the enterprise.The above aspects are mutually reflective. Such enterprise models are often represented in formal modeling languages, like UEML (Unified Enterprise Modeling Language) or GEM (General Entity Manipulator) language allowing for the development of applications, which interprets or compute them. Enterprise ontologies basically allow the representation of the same aspects of an enterprise (processes, organizational structure, products and systems). However, enterprise ontologies use another representation (like OWL- Web Ontology Language) and often are developed for other application purposes than enterprise model. The objective of this thesis is to develop strategies for transforming enterprise models into enterprise ontologies.  There should be maximum preservation of semantics and minimum loss of information during the process of transformation. On the basis of meta-model (model to model) transformation, we propose three elements mapping approaches. Each approach has a number of elements mapping rules. After comparative study the best suitable approach according to objective of this thesis is selected for implementation purpose. From a technical perspective, a tool named “EM2EO” is developed, which accepts an enterprise model as input and produces ontology as output.

Safety-critical software intensive systems are used in a lot of industries nowadays. Examples ofthese are in automotive and aircraft industry, medicine, and autonomous systems. Fault in suchsystems can lead to severe damage and/or loss of human lives. Therefore fault-tolerance should beconsidered at all stages of the system development, starting from the analysis and design.Different languages and tools have been developed for that purpose across the years. One of these isthe Architecture Analysis and Design Language (AADL) – a modeling language used to describethe architecture of a software system. It consists of textual and graphical descriptions of three typesof components – software, execution platform and composite.In this work we implement a prototype of an AADL simulator in Java that enables us to examine thepossible dynamic executions of an AADL specification. This allows us to verify the correctness ofan AADL specification based on the behavior it shows. The simulator would expect an AADLspecification of a software system as an input and simulate the dynamic execution of that system.Before implementing the simulator, we introduce the problem area - safety-critical systems andAADL. Since AADL is used primarily in the automotive and aircraft industries, we have chosen todescribe a simplified flight control system for a plane. It should give the reader an initialunderstanding of the language without going into unnecessary detail about rarely used features.Part of the simulator is a compiler that reads the AADL specification, validates it and transforms itto a Java model. We take a look at the individual steps needed for that, with focus on parsing theinput. Therefore we review the different kinds of algorithms used for parsing and explore how theywork.We also make a detailed literature review of previous works in the area of AADL modeltransformations. Finally, we describe the analysis, design and implementation of the simulator andexamine a case study to test the prototype.

Traits are primitive units of code reuse that serve as building blocks of classes. In this research, we enhance reuse by extending the capabilities of traits; in particular, we add modeling abstractions to them. Traits have a variety of benefits, including facilitating reuse and separation of concerns. They have appeared in several programming languages, particularly derivatives of Smalltalk. However, there is still no support for traits that contain modeling abstractions, and no straightforward support for them in general-purpose programming languages. The latter is due to structural concerns that exist for them at runtime, especially traits that contain modeling abstractions. Model-driven technologies are making inroads into the development community, albeit slowly. Modeling abstractions such as state machines and associations provide new opportunities for reuse, and can be combined with inheritance for even greater reusability. However, issues with inheritance apply also when these new abstractions are inheritable units. This suggests that traits and models ought to be able to be synergistically combined. We perform a comprehensive analysis of using modeling elements in traits. We implement such traits in Umple, which is a model-oriented programming language that permits embedding of programming concepts into models. The contributions of the thesis are: a) Adding new elements including state machines and associations into traits, hence bringing more reusability, modularity, and applications to traits; b) Developing an algorithm that allows reusing, extending, and composing state machines through traits; c) Extending traits with required interfaces so dependencies at the semantic level become part of their usage, rather than simple syntactic capture; d) Adding template parameters with associations in traits, offering new applications for traits in which it is possible to define design patterns and to have a library of most-used functionality; e) The implementation of all the above concepts, including generating code in multiple general-purpose programming languages through automatic model transformation.

Reuse has often been claimed in the software engineering literature to improve thequality and reduce the cost of software. Motivated by the idea that these gains canbe multiplied if reuse can be achieved earlier in the software life-cycle, a subset ofthe requirements engineering literature has focused, since the inception of the field,on investigating approaches to reuse at the requirements level. A wide array of differentapproaches now exist within this space. However, these approaches offer varyingdegrees of generality and utility. Generality is important because it enables a requirementsengineer to utilise the same reuse library across multiple projects. Utility isimportant because it is a measure of the extent to which effort is reduced by utilising areuse approach. This thesis presents Reuse-Oriented Requirements Engineering (RORE): a systematicframework to support the production of requirements models by reuse. RORE aimsto improve on existing requirements-reuse approaches in respect of the generalityutilitytrade-off. RORE seeks to do this by bringing together the strengths of two existingrequirements-level reuse approaches: The Domain Theory and Problem-OrientedSoftware Engineering (POSE - a refinement of Jackson’s Problem Frames Approach).This thesis evaluates RORE with respect to both generality and utility, and comparesRORE against both frameworks. The major conclusion of the thesis is that while ROREimproves on each framework in respect of some, but not all, evaluation metrics, ROREdoes succeed in offering a level of generality which compares favourably to existinghighly general approaches, and without significantly reducing the utility of the approach.