A variety of markup languages exist for formatting text and exporting to HTML. These languages are tailored to the needs in a specific context by specialising tags, selecting tags and limiting the number of possible distinctions to a subset of what is available in HTML. However, limiting the number of possible distinctions creates problems when changes occur in the context. The real world is ever-changing, thus that which models it must be able to reflect the changes in the operational environment to remain relevant and satisfactory. Incorporating new requirements and adjusting to the changes in requirements means adapting and evolving. This thesis explores giving document authors the possibility to extend and modify the repertoire of available markup tags when new user requirements demand it. What is presented is a prototype which allows the user to tailor the markup and also adapt it to changes in the environment. The system allows users to create their own set of markup tags, annotate their documents with them, and export a generated XML document. Users create the tag and assign a meaning to it, when changes occur in the requirements they can be implemented by modifying the tags, extending the repertoire by adding tags, or changing the meaning of a defined tag.

Les approches basées sur les composants permettent de développer des logiciels en réutilisant des composants existant dans des bibliothèques. La structure d'un tel logiciel produit par assemblage de composants est définie à l'aide d'un langage de description d'architectures (ADL). Les processus de développement sont encore peu adaptés à ce paradigme. Ainsi, les ADL existants ne fournissent pas de véritable support au développement et à l'évolution des architectures logicielles à composants. Cette thèse propose Dedal, un ADL permettant de définir une architecture logicielle à différents niveaux d'abstraction qui correspondent aux étapes du cycle de vie du logiciel : sa spécification, son implémentation et son déploiement. La définition de l'architecture est complétée par un modèle du logiciel à l'exécution. La cohérence entre les différentes définitions d'une architecture doit être assurée : sa définition à un niveau d'abstraction doit être conforme à sa définition à un niveau supérieur. Ce principe permet de contrôler l'évolution d'une architecture, en validant les modifications réalisées à un certain niveau d'abstraction ou en motivant la création d'une nouvelle version pour propager les modifications entre niveaux d'abstraction et rétablir la cohérence. Ces mécanismes préviennent les problèmes d'érosion ou de dérive qui surviennent lors des évolutions entre les différents niveaux de définition des architectures. Un environnement couvrant le cycle de vie complet d'un logiciel à base de composants a été prototypé. Il comporte un atelier, permettant de décrire des architectures avec Dedal, puis un environnement d'exécution, extension des outils Fractal, capable de contrôler l'évolution des architectures déployées. L'évolution à l'exécution est réalisée de façon graduelle, de manière à faire fonctionner et à instrumenter les nouvelles versions pendant une phase de transition, avant de valider définitivement une modification. / Component-based approaches promote software development by reuse of existing components from a repository. The structure of such software is described as an assembly of software components using an architecture description language (ADL). Software development processes often do not comply with this paradigm yet. Consequently, existing ADLs do not fully support component-based software architecture development and evolution. This thesis proposes Dedal, an ADL to describe software architectures at several abstraction levels that correspond to the steps of software lifecycle: its specification, its implementation and its deployment. The architecture definition is completed with a runtime model of the software. Consistency between the various definitions of a given architecture must be maintained: its definition at some abstraction level must conform to its definition at a higher abstraction level. This consistency principle enables to control the evolution of architectures either validating changes performed at an abstraction level or motivating the creation of a new version, to propagate changes from an abstraction level to the other and restore their consistency. These mechanisms prevent from architecture erosion or drift which might occur between two different description levels after evolution. An environment that covers the whole lifecycle of component-based software has been prototyped. It includes a CASE tool that supports the Dedal-based description of architectures and a runtime environment that extends Fractal tools to control the evolution of the deployed software. Runtime evolution is performed gradually in order to have new versions run and instrumented during a transition phase before committing changes.

Increasingly complex dynamics in the software operations pose formidable software evolution challenges to the software industry. Examples of these dynamics include the globalization of software markets, the massive increase of interconnected devices worldwide with the internet of things, and the digital transformation to large-scale cyber-physical systems. To tackle these challenges, researchers and practitioners have developed impressive bodies of knowledge, including adaptive and autonomic systems, run-time models, continuous software engineering, and the practice of combining software development and operations (i.e., DevOps). Despite the tremendous strides the software engineering community has made toward managing highly dynamic systems, software-intensive industries face major challenges to match the ever-increasing pace. To cope with this rapid rate at which operational contexts for software systems change, organizations are required to automate and expedite software evolution on both the development and operations sides. The aim of our research is to develop continuous and autonomic methods, infrastructures, and tools to realize software evolution holistically. In this dissertation, we shift the prevalent autonomic computing paradigm and provide new perspectives and foci on integrating autonomic computing techniques into continuous software engineering practices, such as DevOps. Our methods and approaches are based on online experimentation and evolutionary optimization. Experimentation allows autonomic managers to make in- formed data-driven and explainable decisions and present evidence to stakeholders. As a result, autonomic managers contribute to the continuous and holistic evolution of design, configuration and deployment artifacts, providing guarantees on the validity, quality and effectiveness of enacted changes. Ultimately, our approach turns autonomic managers into online stakeholders whose contributions are subject to quality control. Our contributions are threefold. We focus on effecting long-lasting software changes through self-management, self-improvement, and self-regulation. First, we propose a framework for continuous software evolution pipelines for bridging offline and online evolution processes. Our framework’s infrastructure captures run-time changes and turns them into configuration and deployment code updates. Our functional validation on cloud infrastructure management demonstrates its feasibility and soundness. It effectively contributes to eliminate technical debt from the Infrastructure-as-Code (IAC) life cycle, allowing development teams to embrace the benefits of IAC without sacrificing existing automation. Second, we provide a comprehensive implementation for the continuous IAC evolution pipeline. Third, we design a feedback loop to conduct experimentation-driven continuous exploration of design, configuration and deployment alternatives. Our experimental validation demonstrates its capacity to enrich the software architecture with additional components, and to optimize the computing cluster’s configuration, both aiming to reduce service latency. Our feedback loop frees DevOps engineers from incremental improvements, and allows them to focus on long-term mission-critical software evolution changes. Fourth, we define a reference architecture to support short-lived and long-lasting evolution actions at run-time. Our architecture incorporates short-term and long-term evolution as alternating autonomic operational modes. This approach keeps internal models relevant over prolonged system operation, thus reducing the need for additional maintenance. We demonstrate the usefulness of our research in case studies that guide the designs of cloud management systems and a Colombian city transportation system with historical data. In summary, this dissertation presents a new approach on how to manage software continuity and continuous software improvement effectively. Our methods, infrastructures, and tools constitute a new platform for short-term and long-term continuous integration and software evolution strategies and processes for large-scale intelligent cyber-physical systems. This research is a significant contribution to the long-standing challenges of easing continuous integration and evolution tasks across the development-time and run-time boundary. Thus, we expand the vision of autonomic computing to support software engineering processes from development to production and back. This dissertation constitutes a new holistic approach to the challenges of continuous integration and evolution that strengthens the causalities in current processes and practices, especially from execution back to planning, design, and development. / Graduate

No description available.

No description available.

No description available.

Les cadriciels et les bibliothèques sont indispensables aux systèmes logiciels d'aujourd'hui. Quand ils évoluent, il est souvent fastidieux et coûteux pour les développeurs de faire la mise à jour de leur code. Par conséquent, des approches ont été proposées pour aider les développeurs à migrer leur code. Généralement, ces approches ne peuvent identifier automatiquement les règles de modification une-remplacée-par-plusieurs méthodes et plusieurs-remplacées-par-une méthode. De plus, elles font souvent un compromis entre rappel et précision dans leur résultats en utilisant un ou plusieurs seuils expérimentaux. Nous présentons AURA (AUtomatic change Rule Assistant), une nouvelle approche hybride qui combine call dependency analysis et text similarity analysis pour surmonter ces limitations. Nous avons implanté AURA en Java et comparé ses résultats sur cinq cadriciels avec trois approches précédentes par Dagenais et Robillard, M. Kim et al., et Schäfer et al. Les résultats de cette comparaison montrent que, en moyenne, le rappel de AURA est 53,07% plus que celui des autre approches avec une précision similaire (0,10% en moins). / Software frameworks and libraries are indispensable to today's software systems. As they evolve, it is often time-consuming for developers to keep their code up-to-date. Approaches have been proposed to facilitate this. Usually, these approaches cannot automatically identify change rules for one-replaced-by-many and many-replaced-by-one methods, and they trade off recall for higher precision using one or more experimentally-evaluated thresholds. We introduce AURA (AUtomatic change Rule Assistant), a novel hybrid approach that combines call dependency and text similarity analyses to overcome these limitations. We implement it in a Java system and compare it on five frameworks with three previous approaches by Dagenais and Robillard, M. Kim et al., and Schäfer et al. The comparison shows that, on average, the recall of AURA is 53.07% higher while its precision is similar (0.10% lower).

Le développement du logiciel actuel doit faire face de plus en plus à la complexité de programmes gigantesques, élaborés et maintenus par de grandes équipes réparties dans divers lieux. Dans ses tâches régulières, chaque intervenant peut avoir à répondre à des questions variées en tirant des informations de sources diverses. Pour améliorer le rendement global du développement, nous proposons d'intégrer dans un IDE populaire (Eclipse) notre nouvel outil de visualisation (VERSO) qui calcule, organise, affiche et permet de naviguer dans les informations de façon cohérente, efficace et intuitive, afin de bénéficier du système visuel humain dans l'exploration de données variées. Nous proposons une structuration des informations selon trois axes : (1) le contexte (qualité, contrôle de version, bogues, etc.) détermine le type des informations ; (2) le niveau de granularité (ligne de code, méthode, classe, paquetage) dérive les informations au niveau de détails adéquat ; et (3) l'évolution extrait les informations de la version du logiciel désirée. Chaque vue du logiciel correspond à une coordonnée discrète selon ces trois axes, et nous portons une attention toute particulière à la cohérence en naviguant entre des vues adjacentes seulement, et ce, afin de diminuer la charge cognitive de recherches pour répondre aux questions des utilisateurs. Deux expériences valident l'intérêt de notre approche intégrée dans des tâches représentatives. Elles permettent de croire qu'un accès à diverses informations présentées de façon graphique et cohérente devrait grandement aider le développement du logiciel contemporain. / Nowadays, software development has to deal more and more with huge complex programs, constructed and maintained by large teams working in different locations. During their daily tasks, each developer may have to answer varied questions using information coming from different sources. In order to improve global performance during software development, we propose to integrate into a popular integrated development environment (Eclipse) our new visualization tool (VERSO), which computes, organizes, displays and allows navigation through information in a coherent, effective, and intuitive way in order to benefit from the human visual system when exploring complex data. We propose to structure information along three axes: (1) context (quality, version control, etc.) determines the type of information; (2) granularity level (code line, method, class, and package) determines the appropriate level of detail; and (3) evolution extracts information from the desired software version. Each software view corresponds to a discrete coordinate according to these three axes. Coherence is maintained by navigating only between adjacent views, which reduces cognitive effort as users search information to answer their questions. Two experiments involving representative tasks have validated the utility of our integrated approach. The results lead us to believe that an access to varied information represented graphically and coherently should be highly beneficial to the development of modern software.

Les applications orientées objet de tailles significatives ont des dépendances complexes et nombreuses, et généralement ne disposent pas d'architectures logicielles explicites. Par conséquent, elles sont difficiles à maintenir, et certaines parties de ces applications sont difficiles à réutiliser. Le paradigme de développement à base de composants est né pour améliorer ces aspects et pour soutenir la maintenabilité et la réutilisation efficaces. Il offre une meilleure compréhensibilité à travers une vue d'architecture de haut niveau. Ainsi, la migration des applications orientées objet à celles à base de composants contribuera à améliorer ces caractéristiques, et de soutenir l'évolution des logiciels et la future maintenance.Dans cette thèse, nous proposons une approche pour transformer automatiquement les applications orientées objet à celles à base de composants. Plus particulièrement, l'entrée de l'approche est le résultat fourni par la récupération de l'architecture logicielle: une description de l'architecture à base de composants. Ainsi, notre approche transforme le code source orienté objet afin de produire des composants déployables. Nous nous concentrons sur la transformation des dépendances orientées objet en celles basées sur les interfaces. De plus, nous passons du concept d'objet au concept d'instance d'un composant. En outre, nous fournissons une approche de transformation déclarative en utilisant des langages dédiés. Nous démontrons notre approche sur de nombreux modèles de composants bien connus. / Large object-oriented applications have complex and numerousdependencies, and usually do not have explicitsoftware architectures. Therefore they are hard to maintain, and parts of themare difficult to reuse. Component-based development paradigm emergedfor improving these aspects and for supporting effectivemaintainability and reuse. It provides better understandabilitythrough a high-level architecture view of the application. Thus, migrating object-oriented applications to component-based ones will contribute to improve these characteristics, and support software evolution and future maintenance.In this dissertation, we propose an approach to automatically transform object-oriented applications tocomponent-based ones. More particularly, the input of the approach isthe result provided by software architecture recovery: acomponent-based architecture description. Then, our approachtransforms the object-oriented source code in order to producedeployable components. We focus on transforming object-oriented dependencies into interface-based ones. Moreover, we move from the concept of object to the concept of component instance. Furthermore, we provide a declarative transformation approach using domain-specific languages. We demonstrate our approach on many well-known component models.

Le contrôle de l'évolution des logiciels exige une compréhension profonde des changements et leur impact sur les différents artefacts du système. Nous proposons une approche de multi-modélisation pour l'analyse d'impact du changement pour une compréhension des effets des modifications prévus ou réels dans les systèmes distribués. Ce travail consiste à élaborer une modélisation des artefacts logiciels et de leur différents liens d'interdépendance pour construire un système à base de connaissance permettant, entre autres, d'assister les développeurs et les chargés de l'évolution des logiciels pour étblir une évaluation a priori de l'impact des modifications.La modélisation que nous élaborons intègre deux descriptions majeures des logiciels, dans un premier temps, la description structurelle sous-jacente qui englobe l'ensemble des niveaux granulaires et l'abstraction des constituants logiciels, et ensuite la description qualitative conçue pour s'intégrer à la description précédente. Deux modèles, d'abord élaborés individuellement pour les deux descriptions respectives, ont été intégrés ou mis en correspondance dans l'objectif d'étudier l'impact de toute modification et sa potentielle propagation à travers les constituants logiciels concernés. Lors de chaque modification, il devient alors possible d'établir un bilan qualitatif de son impact. La modélisation intégrée est élaborée pour se prêter à un raisonnement à base de règles expertes. La modélisation proposée est en cours d'expérimentation et validation à travers le développement d'une plate-forme d'implémentation basée sur l'environnement Eclipse. / The software evolution control requires a complete understanding of the changes and their impact on the various systems artifacts. We propose a multi-modeling approach for the change impact analysis to provide assistance in understanding the effects of projected or actual changes in distributed software systems. This work elaborate the modeling of software artifacts along with their various interdependencies to build a knowledge-based system, which allows, among others, an assistance for the software developers or maintenance engineers to establish an a priori evaluation of impact of changes. The model we develop integrates two major descriptions of software, at first, the underlying structural description that encompasses the levels of granularity and abstraction of software artifacts, and then the qualitative description designed to integrate the structural description. Initially, the formal models are designed separately for the respective descriptions, and then these are integrated for the objective to study the change impact and its potential propagation through the affected software artifacts. For a change, it is important to establish a qualitative assessment of its impact. The integrated modeling leads to a reasoning based on expert rules. The proposed model is being tested and validated through the development of a platform, implemented in the Eclipse environment.