Дисертації з теми "Mise à jour dynamique des logiciels"

De nombreux systèmes informatiques nécessitent d'être en fonctionnement permanent et sans interruption. Cependant, ces systèmes doivent également être régulièrement adaptés aux changements du domaine dans lequel ils opèrent et aux évolutions des besoins des utilisateurs. La mise à jour logicielle dynamique est l'opération qui consiste à remplacer un programme en exécution par une version suivante sans interrompre le fonctionnement du programme. Cette thèse divise le problème de l'évolution dynamique des programmes en deux sous-problématiques. La difficulté essentielle est d'assurer des exécutions globalement cohérentes au cours du temps, de sorte qu'un processus mis à jour réalise effectivement la tâche qui lui est confiée sans erreur de fonctionnement. La difficulté accidentelle, quant à elle, est causée par l'incapacité de définir et de comprendre la mise à jour dynamique dans les langages de programmation actuels. Pour répondre à ces problématiques, un modèle de langage est présenté. Il permet d'exprimer l'évolution dynamique des programmes et de prévoir le comportement des processus mis à jour. Ce modèle de langage introduit une entité de code - l'étape - associée à un opérateur de contrôle de haut-niveau - reach - pour permettre aux programmeurs de faire émerger la structure temporelle des programmes. La décomposition en étapes offre une vision de haut-niveau des chronologies possibles lors de l'exécution et fournit aux programmeurs des points de contrôle où le futur de l'exécution peut être entièrement redéfini
Numerous software systems must execute constantly without being interrupted. On the other hand, they also have to be regularly adapted to changes in their operational domains and to the evolution of users requirements. Dynamic software update is the process that consists in replacing a running program with a newer version without interrupting the program operation. This thesis divides the dynamic evolution problem in two sub-problems. The essential difficulty is to ensure that the resulting executions will be globally coherent across time, such that updated processes actually perform their task without producing any error. The accidental difficulty is caused by the impossibility to define and understand dynamic software updates in the existing programming languages. To address these problems, a language model is presented. It gives the ability to express the dynamic evolutions of programs and to foresee the behaviors produced by dynamically updated processes. This language model introduce a code entity - the stage - associated with a high level control operator - reach - that allows programmers to express the temporal stucture of programs. The program decomposition in stages offers a high level view of the possible executions chronologies and gives programmers control points from where the entire future of computations can be redefined

Dans la littérature sur les bases de données, il a été proposé d'utiliser des contraintes d'intégrité actives afin de restaurer l'intégrité de la base. Ces contraintes d'intégrité actives consistent en une contrainte classique augmentée d'un ensemble d'actions de mise à jour préférées qui peuvent être déclenchées quand la contrainte est violée. Dans la première partie de cette thèse, nous passons en revue les principales stratégies de réparation qui ont été proposées dans la littérature et proposons une formalisation par des programmes de la Logique Dynamique. L'outil principal que nous employons dans notre recherche est la logique DL-PA, une variante de PDL récemment introduite. Nous explorons ensuite une nouvelle façon dynamique de réparer les bases de données et comparons sa complexité calculatoire et ses propriétés générales aux approches classiques. Dans la seconde partie de la thèse nous abandonnons le cadre propositionnel et adaptons les idées susmentionnées à des langages d'un niveau supérieur. Plus précisément, nous nous intéressons aux Logiques de Description, et étudions des extensions des axiomes d'une TBox par des actions de mise à jour donnant les manières préférées par lesquelles une ABox doit être réparée dans le cas d'une inconsistance avec les axiomes de la TBox. L'extension des axiomes d'une TBox avec de telles actions de mise à jour constitue une nouvelle TBox, qui est active. Nous nous intéressons à la manière de réparer une ABox en rapport avec une telle TBox active, du point de vue syntaxique ainsi que du point de vue sémantique. Étant donnée une ABox initiale, l'approche syntaxique nous permet de construire un nouvel ensemble d'ABox dans lequel nous identifions les réparations les mieux adaptées. D'autre part, pour l'approche sémantique, nous faisons de nouveau appel au cadre de la logique dynamique et considérons les actions de mise à jour, les axiomes d'inclusion actives et les réparations comme des programmes. Étant donné une TBox active aT , ce cadre nous permet de vérifier (1) si un ensemble d'actions de mise à jour est capable de réparer une ABox en accord avec les axiomes actifs d'aT en effectuant une interprétation locale des actions de mise à jour et (2) si une ABox A' est la réparation d'une ABox donnée A sous les axiomes actifs d'aT moyennant un nombre borné de calculs, en utilisant une interprétation globale des actions de mise à jour. Après une discussion des avantages de chaque approche nous concluons en proposant une intégration des approches syntaxiques et sémantiques dans une approche cohésive
In the database literature it has been proposed to resort to active integrity constraints in order to restore database integrity. Such active integrity constraints consist of a classical constraint together with a set of preferred update actions that can be triggered when the constraint is violated. In the first part of this thesis, we review the main repairing routes that have been proposed in the literature and capture them by means of Dynamic Logic programs. The main tool we employ for our investigations is the recently introduced logic DL-PA, which constitutes a variant of PDL. We then go on to explore a new, dynamic kind of database repairing whose computational complexity and general properties are compared to the previous established approaches. In the second part of the thesis we leave the propositional setting and pursue to adapt the aforementioned ideas to higher level languages. More specifically, we venture into Description Logics and investigate extensions of TBox axioms by update actions that denote the preferred ways an ABox should be repaired in case of inconsistency with the axioms of the TBox. The extension of the TBox axioms with these update actions constitute new, active TBoxes. We tackle the problem of repairing an ABox with respect to such an active TBox both from a syntactic as well as a semantic perspective. Given an initial ABox, the syntactic approach allows us to construct a set of new ABoxes out of which we then identify the most suitable repairs. On the other hand, for the semantic approach we once again resort to a dynamic logic framework and view update actions, active inclusion axioms and repairs as programs. Given an active TBox aT , the framework allows to check (1) whether a set of update actions is able to repair an ABox according to the active axioms of aT by interpreting the update actions locally and (2) whether an ABox A' is the repair of a given ABox A under the active axioms of aT using a bounded number of computations by interpreting the update actions globally. After discussing the strong points of each direction, we conclude by combining the syntactic and semantic investigations into a cohesive approach

Les architectures à base de microservices permettent de construire des systèmes répartis complexes composés de microservices indépendants. Le découplage et la modularité des microservices facilitent leur remplacement et leur mise à jour de manière indépendante. Depuis l'émergence du développement agile et de l'intégration continue (DevOps et CI/CD), la tendance est aux changements de version plus fréquents et en cours d'exécution des applications. La réalisation des changements de version est effectuée par un processus d'évolution consistant à passer de la version actuelle de l'application à une nouvelle version. Cependant, les coûts de maintenance et d'évolution de ces systèmes répartis augmentent rapidement avec le nombre de microservices.L'objectif de cette thèse est de répondre aux questions suivantes~:Comment aider les ingénieurs à mettre en place une gestion de version unifiée et efficace pour les microservices et comment tracer les changements de version dans les applications à base de microservices ?Quand les applications à base de microservices, en particulier celles dont les activités sont longues, peuvent-elles être mises à jour dynamiquement sans arrêter l'exécution de l'ensemble du système ? Comment la mise à jour doit-elle être effectuée pour assurer la continuité du service et maintenir la cohérence du système ?En réponse à ces questions, cette thèse propose deux contributions principales. La première contribution est constituée de modèles architecturaux et d'un graphe d'évolution pour modéliser et tracer la gestion des versions des microservices. Ces modèles sont construits lors de la conception et utilisés durant l'exécution. Cette contribution aide les ingénieurs à abstraire l'évolution architecturale afin de gérer les déploiements lors d'une reconfiguration, et fournit la base de connaissances nécessaire à un intergiciel de gestion autonomique des activités d'évolution. La deuxième contribution est une approche basée sur les instantanés pour la mise à jour dynamique (DSU) des applications à base de microservices. Les instantanés répartis cohérents de l'application en cours d'exécution sont construits pour être utilisés dans la spécification de la continuité du service, l'évaluation des conditions de mise à jour sûre et dans la mise en œuvre des stratégies de mise à jour. La complexité en nombre de messages de l'algorithme DSU n'est alors pas égale à la complexité de l'application répartie, mais correspond à la complexité de l'algorithme de construction d'un instantané réparti cohérent
Microservice architectures contribute to building complex distributed systems as sets of independent microservices. The decoupling and modularity of distributed microservices facilitates their independent replacement and upgradeability. Since the emergence of agile DevOps and CI/CD, there is a trend towards more frequent and rapid evolutionary changes of the running microservice-based applications in response to various evolution requirements. Applying changes to microservice architectures is performed by an evolution process of moving from the current application version to a new version. The maintenance and evolution costs of these distributed systems increase rapidly with the number of microservices.The objective of this thesis is to address the following issues: How to help engineers to build a unified and efficient version management for microservices and how to trace changes in microservice-based applications? When can microservice-based applications, especially those with long-running activities, be dynamically updated without stopping the execution of the whole system? How should the safe updating be performed to ensure service continuity and maintain system consistency?In response to these questions, this thesis proposes two main contributions. The first contribution is runtime models and an evolution graph for modelling and tracing version management of microservices. These models are built at design time and used at runtime. It helps engineers abstract architectural evolution in order to manage reconfiguration deployments, and it provides the knowledge base to be manipulated by an autonomic manager middleware in various evolution activities. The second contribution is a snapshot-based approach for dynamic software updating (DSU) of microservices. The consistent distributed snapshots of microservice-based applications are constructed to be used for specifying continuity of service, evaluating the safe update conditions and realising the update strategies. The message complexity of the DSU algorithm is not the message complexity of the distributed application, but the complexity of the consistent distributed snapshot algorithm

Contrairement à la mise à jour traditionnelle, la mise à jour dynamique est la capacité de pouvoir modifier un système logiciel ou une application durant son exécution sans interruption de ce dernier et sans perte de l’état d’exécution du système. L’objectif est de permettre aux développeurs de pouvoir corriger les défauts (mettre à jour une partie fautive du système) ou de faire évoluer leurs applications (ajout, suppression de nouvelles fonctionnalités). Les cartes à puce sont de petits ordinateurs dotées d’au moins un circuit intégré ou puce capable de contenir de l’information. Ce circuit intégré peut contenir un microprocesseur capable de traiter l’information. Parmi les types de cartes, on distingue la Java Card, basée sur la technologie Java. C’est une carte multi-applicative avec les applications qui s’exécutent au dessus de la machine virtuelle Java embarquée dans la carte. Ces cartes ont des durées de vie de plus en plus élevée. Il est difficile d’imaginer que les applications embarquées n’aient pas un besoin de mise à jour pour solutionner un bogue, mettre à jour une faille de sécurité, améliorer des fonctionnalités ou en supprimer, ceci de façon transparente à l’utilisateur. De nombreux systèmes existants offrent des mécanismes de mise à jour dynamique. Cependant, ces systèmes sont généralement destinés à des environnements n’ayant pas de fortes contraintes de ressources (environnement de type poste de travail). De plus, les approches de solutions proposées ne sont pas toujours applicables au domaine des objets à faibles ressources tels que les cartes à puce. Dans cette thèse, nous présentons EmbedDSU, un système de mise à jour dynamique pour les cartes à puce basées sur Java. Ce système est basé sur un ensemble de mécanismes à l’extérieur de la carte et à l’intérieur de la carte. Pour évaluer notre système, nous avons réalisé un prototype basé sur simpleRTJ1, une machine virtuelle Java pour l’embarqué
Unlike the traditional update, the dynamic update is the ability to modify a software system or an application during its execution without stopping it and without loosing its execution state. The aim is to enable developers to be able to correct bugs, improve and delete some functionnalities. Smart cards are small computers equipped with at least one integrated circuit or chip that contain information. This integrated circuit can contain a microprocessor capable of processing information. Java Card is a type of smart card based on Java technology. This is a multi-application card which allows application to run on the top of the embedded virtual machine. These cards may have a long lifetime. It is hard to imagine that embedded application do not need an update to solve a bug, update security holes, improve or remove features, in transparent manner to the user. Many existing systems provide mechanisms for dynamic update. However these systems are generally intended for environments that do not have strong resource constraints (like workstation environment). In addition, the existing approaches of solutions are not always applicable to the field of smart cards. In this thesis, we present EmbedDSU, a dynamic update system for smart cards based on Java. This system consists of a set of mechanisms off-card and on-card. To evaluate our system, we have implemented a prototype based on simpleRTJ2, a Java virtual machine for embedded systems

Le travail présenté dans cette thèse concerne la problématique de l'évolution des bases de données géographiques (BDG). Nous donnons une solution pour le problème de maintien de la cohérence d'une BDG lors de sa mise à jour (m. à. J. ). Cette solution repose sur l'approche préventive à base de contraintes d'intégrités et l'approche de m. à. J incrémentale avec contrôle continu de la cohérence. Notre approche est composée de deux phases. La première a consisté à modéliser la BDG construite ou complétée, dans une optique de m. à. J. La seconde phase a consisté à s'appuyer sur cette modélisation pour mettre en place le mécanisme d'évolution composé d'algorithmes déterminant le déroulement du processus de m. à. J et aussi celui du maintien de la cohérence. Nous avons construit nos méthodes de propagation en travaillant sur des zones locales autour de l'objet ciblé par l'opération de m. à. J, puis nous avons établi une propriété qui prouve la cohérence globale d'une BDG à partir d'un traitement local de sa cohérence.

La mise à jour dynamique des programmes consiste en la modification de ceux-ci sans en arrêter l'exécution. Cette caractéristique est primordiale pour les applications critiques en continuelles évolutions et nécessitant une haute disponibilité. Le but de notre travail est d'effectuer la vérification formelle de la correction de la mise à jour dynamique d'applications Java Card à travers l'étude du système EmbedDSU. Pour ce faire, nous avons premièrement établi la correction de la mise à jour du code en définissant une sémantique formelle des opérations de mise à jour sur le code intermédiaire Java Card en vue d'établir la sûreté de typage des mises à jour. Nous avons ensuite proposé une approche pour vérifier la sémantique du code mis à jour à travers la définition d'une transformation de prédicats. Nous nous sommes ensuite intéressés à la vérification de la correction concernant la détection de points sûrs de la mise à jour. Nous avons utilisé la vérification de modèles. Cette vérification nous a permis de corriger d'abord un problème d'inter blocage dans le système avant d'établir d'autres propriétés de correction : la sûreté d'activation et la garantie de mise à jour. La mise à jour des données est effectuée à travers les fonctions de transfert d'état. Pour cet aspect, nous avons proposé une solution permettant d'appliquer les fonctions de transfert d’état tout en préservant la consistance du tas de la machine virtuelle Java Card et en permettant une forte expressivité dans leurs écritures
Dynamic Software Updating (DSU) consists in updating running programs on the fly without any downtime. This feature is interesting in critical applications that are in continual evolution and that require high availability. The aim of our work is to perform formal verification the correctness of dynamic software updating in Java Card applications by studying the system EmbedDSU. To do so, we first established the correctness of code update. We achieved this by defining formal semantics for update operations on java Card bytecode in order to ensure type safety. Then, we proposed an approach to verify the semantics of updated programs by defining a predicate transformation. Afterward, we were interested in the verification of correction concerning the safe update point detection. We used model checking. This verification allowed us first to fix a deadlock situation in the system and then to establish other correctness properties: activeness safety and updatability. Data update is performed through the application of state transfer functions. For this aspect, we proposed a solution to apply state transfer functions with the preservation of the Java Card virtual machine heap consistency and by allowing a high expressiveness when writing state transfer functions

Dans le contexte automobile actuel, le standard pour les calculateurs enfouis est AUTOSAR. L'un des inconvénients majeurs de cette architecture est son manque de flexibilité. Cependant, les mises à jour et la personnalisation des systèmes embarqués sont de plus en plus, non seulement plébiscités, mais également nécessaires. En effet, la complexité grandissante des systèmes exige à présent de déployer des moyens supplémentaires pour permettre leur maintenance et leur évolution de manière plus aisée. Ainsi, partant de ces constats, ce travail étudie les possibilités de faire des mises à jour dans le contexte d'AUTOSAR. Les modifications nécessaires se retrouvent non seulement dans l'architecture, mais également au sein du processus de développement et des considérations temps-réel. Tous ces aspects sont donc regardés en détails pour permettre les mises à jour partielles dans le cadre du standard AUTOSAR. Cette thèse décrit donc le processus de développement logiciel AUTOSAR et propose certaines améliorations mises en place au cours de ce travail. Un certain nombre de concepts sont également définis, afin d'aménager des espaces d'adaptation logiciels. Ces espaces sont ensuite utilisés pour intégrer des mises à jour partielles dans le calculateur embarqué. Le processus de développement est également modifié pour intégrer ces concepts ainsi que les mécanismes nécessaires à la mise à jour. Les aspects temps-réel concernant la mise à jour partielle dans les systèmes embarqués automobiles sont également traités ici. Un modèle de tâches approprié est mis en place dans le cadre d'AUTOSAR. De plus l'analyse de sensibilité est utilisée spécifiquement pour déterminer la flexibilité disponible dans un système donné. Les aspects d'implémentation sont également détaillés. En particulier, la création de mises à jour dans un contexte donné, la gestion des différentes versions possibles pour une application, l'utilisation et l'écriture dans la mémoire embarquée et enfin, les moyens nécessaires à la prise en compte des aspects de sûreté de fonctionnement. Pour terminer, tous les concepts développés dans ce travail sont appliqués à une preuve de concept reposant sur une application embarquée fournie par Renault. L'approche proposée est donc appliquée de manière pratique.

Une question essentielle pour un agent intelligent devant faire évoluer un système est : « Quelles actions effectuer pour mener à bien ma tâche ? ». Pour y répondre, l’agent doit prévoir l’effet de ses plans d’action sur le système. Les modèles utilisés en planification classique ne suffisent plus dès lors que l’agent n’a pas une connaissance parfaite du système ou lorsque les actions ne sont pas déterministes. Nous développons une logique modale doxastique permettant de raisonner sur les croyances graduelles de l’agent. Nous offrons un cadre formel (syntaxique et sémantique) pour la progression (« on-line » et « off-line ») d’états de croyances graduels par des programmes incluant des actions épistémiques non fiables et actions ontiques pouvant échouer. Tandis que la progression « on-line » permet l’exécution des programmes, la progression « off-line » permet l’évaluation de ceux-ci par rapport à un but précis et donc l’établissement d’un plan d’action adapté à la tâche de l’agent
An essential question for an intelligent agent aiming at controlling a system is: “Which actions should I perform to fulfil my goals?”. To answer it, the agent must predict the effect of its actions (its plan) on the system. The models used in the classical planning literature are not expressive enough for when the agent does not have a perfect knowledge of the system or when the actions are not deterministic. For this reason, we develop a doxastic modal logic allowing to reason on the graded beliefs of the agent. We give a formal framework (syntactical and semantical) for progression (both on-line and off-line) of graded states of beliefs by programs involving unreliable epistemic actions and ontic actions that may fail. While on-line progression allows for program execution, off-line progression allows for evaluating programs with respect to a given goal and thus to finding an action plan for fulfilling the goal

La dynamique de frappe au clavier est une modalité biométrique comportementale qui permet d'authentifier des individus selon leur façon de taper au clavier. Un tel système est peu coûteux, car il ne nécessite pas de matériel d'acquisition autre que le clavier de l'ordinateur, et est facilement accepté par l'utilisateur. Nous nous sommes principalement intéressé aux systèmes statiques où le texte saisit par l'utilisateur est connu à l'avance par la machine. Malheureusement, les performances de cette modalité sont plutôt médiocres en raison de la forte variabilité de la donnée biométrique. Cette variabilité est due à l'état émotionnel de la personne, l'apprentissage de la façon de taper, \ldots Nous proposons dans cette thèse différentes contributions permettant d'améliorer les performances de reconnaissance de systèmes de dynamique de frappe au clavier (DDF). Nous effectuons également une analyse des bases publiques permettant d'évaluer la performance de nouveaux systèmes de reconnaissance. Une contribution est la mise au point d'un système de DDF par mot de passe partagé. Nous étudions ensuite la fusion multibiométrique avec la dynamique de frappe au clavier et la reconnaissance faciale afin d'augmenter les performances des deux systèmes. Nous montrons, sur deux jeux de données différents, qu'il est possible de reconnaitre le genre d'un individu suivant sa façon de taper au clavier. Enfin, nous présentons une nouvelle méthode de mise à jour de la référence biométrique qui permet de prendre en compte le vieillissement de la donnée biométrique, afin de ne pas avoir une diminution des performances de reconnaissance au cours du temps.

De nombreuses études montrent que la plus grande partie du coût de production d'un logiciel est générée lors de la phase de maintenance. Lors de cette phase, pour corriger des erreurs, pour optimiser des programmes, ou pour ajouter des fonctionnalités, il est essentiel de comprendre les programmes, et en particulier de comprendre leur comportement. Les analyseurs dynamiques d'exécutions tels que les profileurs, les moniteurs, ou les débogueurs, sont alors des outils indispensables. Cependant, ces outils d'analyse dynamique sont extrêmement coûteux à mettre en oeuvre : (1) d'abord, parce qu'il est généralement nécessaire de modifier le système de compilation utilisé, ce qui est fastidieux et pas toujours envisageable ; (2) en outre, les besoins en outils d'analyse de programmes varient d'un utilisateur à l'autre, en fonction de sa compétence, de son expérience du système de programmation utilisé, ainsi que de sa connaissance du code à maintenir ; (3) et enfin, parce que ces outils sont difficilement réutilisables. Il est donc souhaitable que chaque utilisateur puisse spécifier facilement les analyses dynamiques dont il a besoin. C'est pourquoi nous proposons dans cette thèse une architecture qui permet de faciliter leur mise en oeuvre. Cette architecture est basée : (1) sur une instrumentation systématique du programme qui produit une image très détaillée de l'exécution, la trace ; (2) sur un ensemble de primitives qui permettent d'analyser cette trace efficacement. Les analyseurs résultants ont des performances du même ordre de grandeur que leurs équivalents implémentés <<à la main>> par modification du système de compilation. Ils peuvent être mis en oeuvre par des utilisateurs sans connaissance particulière du système de compilation, qu'ils n'ont pas à modifier. Cette architecture leur permet d'implémenter les outils qui leur conviennent, adaptés à leur niveau de compréhension du code qu'ils sont chargés de maintenir. De plus, la structure modulaire de l'architecture proposée devrait permettre de faciliter la réutilisation de ces analyseurs pour d'autres systèmes. Notre propos est illustré dans le cadre du langage de programmation logique et fonctionnelle Mercury. Cependant, les concepts utilisés sont indépendants du paradigme de programmation. La trace sur laquelle nous basons la mise en oeuvre de nos analyseurs se doit de refléter le plus fidèlement possible la sémantique opérationnelle du langage. C'est pourquoi nous proposons également dans cette thèse un cadre de modélisation des traces d'exécutions basé sur une sémantique opérationnelle du langage à analyser. Cette spécification formelle de la trace nous permet de valider expérimentalement les traceurs et de prouver leur correction. Cette étude a été menée dans le cadre du langage de programmation logique Prolog
Several studies show that most of the software production cost is spent during the maintenance phase. During that phase, to locate bugs, to optimize programs, or to add new functionalities, it is essential to understand programs, and in particular to understand their runtime behavior. Dynamic analysis tools such as debuggers, profilers, or monitors, are very useful in that respect. However, such tools are expensive to implement because: (1) it generally requires to modify the compiling system, which is tedious and not always possible; (2) the needs in dynamic analysis tools vary from one user to another, depending on its competence, on its experience of the programming system, and on its knowledge of the code to maintain; (3) such tools are generally difficult to reuse. It is therefore desirable that each user is able to specify easily the dynamic analyses he needs. Hence, we propose an architecture that eases dynamic analysis tools implementation. This architecture is based on: (1) a systematic instrumentation of the program which gives a detailed image of the execution, the trace; (2) a set of trace processing primitives that lets one analyse the trace efficiently. The resulting analysers have performance of the same order of magnitude that their equivalent implemented ``by hand'' by modifying the compiling system. They can be implemented by programmers without any knowledge of the compiling system. This architecture let them implement the tools they need, adapted to their level of comprehension of the code they are in charge to maintain. Furthermore, the modular structure of the proposed architecture should ease the analysers reuse. This work has been held within the context of the logical and functional programming language Mercury. However, the concepts we used do not depend on the programming paradigm. The trace on which we base the implementation of our dynamic analysis tools should reflect as much as possible the runtime behavior of programs. Therefore, we also propose a framework to specify execution traces. This framework is based on an operational semantics of the language to analyse. Such formal specifications of the trace let us experimentally validate tracers, and prove their correctness. This work have been held within the context of the logical programming language Prolog

Avec la livraison rapide de nouvelles fonctionnalités, de nombreux projets logiciels ont modifié leurs processus de développement pour aller vers des modèles où les versions sont publiées selon des cycles courts de quelques semaines ou quelques jours. L’adoption de politiques de publication rapide des logiciels a considérablement réduit le temps de stabilisation, c’est-à-dire le temps nécessaire pour que le taux d’échec d’un produit logiciel atteigne un état stable pour l’ensemble des nouvelles fonctionnalités. Cette mise en place de livraisons rapides a obligé les organisations et les entreprises à modifier leur processus de développement et leurs outils pour publier les nouvelles versions, ceci en un temps réduit tout en garantissant la qualité. Ces nouveaux processus de développement sont censés offrir un délai réduit de mise sur le marché, un retour d'information rapide de la part des utilisateurs. Ils doivent également améliorer le temps de traitement de correction des bugs. Les utilisateurs finaux bénéficient alors d’un accès rapide aux améliorations des fonctionnalités avec des mises à jour fiables. Malgré ces avantages, des recherches antérieures ont montré que les versions rapides se font souvent au détriment de la fiabilité logicielle. Cependant, avec l'adoption croissante des versions rapides des logiciels open source et commerciaux, les effets de cette pratique sur le processus de développement logiciel ne sont pas bien compris.L'objectif de cette thèse est de fournir une compréhension approfondie de l'impact de la livraison rapide de versions dans les différentes phases du processus de développement de logiciels open source. Cette thèse présente une étude de cas empirique de la livraison rapide de versions dans les projets Eclipse et Mozilla Firefox. Nous présentons les résultats d’expériences sur l'impact à court et à long terme de la livraison rapide de versions sur le processus de gestion et de test des bugs dans les organisations open source, ainsi que le plan et les outils nécessaires pour une adoption réussie des livraisons rapides de versions. Nous suivons une approche avec des méthodes mixtes où nous analysons les référentiels de logiciels, contenant différents types de données tels que le code source, les données de test et les rapports de bugs. Nous avons également mené une enquête auprès des développeurs Eclipse. Nos travaux aident à comprendre l'évolution et les changements du processus de développement logiciel ainsi que les plans et les pratiques nécessaires pour une adoption réussie de la livraison rapide de versions et identifient plusieurs perspectives de recherche
The advent of delivering new features faster has led many software projects to change their development processes towards more rapid release models where releases are shipped using release cycles of weeks or days. The adoption of rapid release practices has significantly reduced the amount of stabilization time, the time it takes for a software product’s failure rate to reach close to the steady-state, available for new features. This forces organizations to change their development process and tools to release to the public, in a timely manner and with good quality. Rapid releases are claimed to offer a reduced time-to-market and faster user feedback; end-users bene- fit of faster access to functionality improvements and security updates and improve turnaround time for fixing bad bugs. Despite these benefits, previous research has shown that rapid releases often come at the expense of reduced software reliability. Despite the increasing adoption of rapid releases in open-source and commercial soft- ware, the effects of this practice on the software development process are not well understood.The goal of this thesis is to provide a deeper understanding of how rapid releases impact different parts of the open-source software development process. We present empirical evidence about the short and long-term impact of rapid releases on the bug handling and testing process in open source organizations; and the plan and tools that are needed for successful adoption of rapid releases. This thesis presents an empirical case study of rapid releases in Eclipse and Mozilla Firefox projects. We follow a mixed-methods approach where we analyze software repositories, containing different types of data such as source code, testing data and software issues; and we conduct a survey with Eclipse developers. This help in understanding the evolution and changes of the software development process, the plans and practices that are needed for successful adoption of rapid releases and we identify several future research directions calling for further investigation

Les bases de données lexicales jouent un grand rôle dans le TAL, mais, elles nécessitent un développement et un enrichissement permanents via l’exploitation des ressources libres du web sémantique, entre autres, l’encyclopédie Wikipédia, DBpedia, Geonames et Yago2. Prolexbase, comporte à ce jour dix langues, trois parmi elles sont bien couvertes : le francais, l’anglais et le polonais. Il a été conçu manuellement et une première tentative semi-automatique a été réalisée par le projet ProlexFeeder (Savary et al. 2013). L’objectif de notre travail était d’élaborer un outil de mise à jour et d’extension automatiques de ce lexique, et l'ajout de la langue arabe. Un système automatique a également été mis en place pour calculer via la Wikipédia l’indice de notoriété des entrées de Prolexbase ; cet indice dépend de la langue et participe, d'une part, à la construction d'un module de Prolexbase pour la langue arabe et, d'autre part, à la révision de la notoriété présente pour les autres langues de la base
Lexical databases play a significant role in natural language processing (NLP), however, they require permanent development and enrichment through the exploitation of free resources from the semantic web, among others, Wikipedia, DBpedia, Geonames and Yago2. Prolexbase, which issued of numerous studies on NLP, has ten languages, three of which are well covered: French, English and Polish. It was manually designed; the first semiautomatic attempt was made by the ProlexFeeder project (Savary et al., 2013). The objective of our work was to create an automatic updating and extension tool for Prolexbase, and to introduce the Arabic language. In addition, a fully automatic system has been implemented to calculate, via Wikipedia, the notoriety of the entries of Prolexbase. This notoriety is language dependent, is the first step in the construction of an Arabic module of Prolexbase, and it takes a part in the notoriety revision currently present for the other languages in the database

Mettre à jour des applications durant leur exécution est utilisé aussi bien en production pour réduire les temps d’arrêt des applications que dans des environnements de développement interactifs (IDE pour live programming). Toutefois, ces deux scénarios présentent des défis différents qui font que les solutions de mise à jour dynamique (DSU pour Dynamic Software Updating) existantes sont souvent spécifiques à l’un des deux. Par exemple, les DSUs pour la programmation interactives ne supportent généralement pas la détection automatique de points sûrs de mise à jour ni la migration d’instances, alors que les DSUs pour la production nécessitent une génération manuelle de l’ensemble des modifications et manquent d’intégration avec l’IDE. Les solutions existantes ont également une capacité limitées à se mettre à jour elles-mêmes ou à mettre à jour les bibliothèques de base du langage ; et certaines d’entre elles introduisent mêmle une dégradation des performances d’exécution en dehors du processus de mise à jour.Dans cette thèse, nous proposons un DSU (nommé gDSU) unifié qui fonctionne à la fois pour la programmation interactive et les environnements de production. gDSU permet la détection automatique des points sûrs de mise à jour en analysant et manipulant la pile d’exécution, et offre un mécanisme réutilisable de migration d’instances afin de minimiser les interventions manuelles lors de l’application d’une migration. gDSU supporte également la mise à jour des bibliothèques du noyau du langage et du mécanisme de mise à jour lui-même. Ceci est réalisé par une copie incrémentale des objets à modifier et une application atomique de ces modifications.gDSU n’affecte pas les performances globales de l’application et ne présente qu’une pénalité d’exécution lors processus de mise à jour. Par exemple, gDSU est capable d’appliquer une mise à jour sur 100 000 instances en 1 seconde. Durant cette seconde, l’application ne répond pas pendant 250 milli-secondes seulement. Le reste du temps, l’application s’exécute normalement pendant que gDSU recherche un point sûr de mise à jour qui consiste alors uniquement à copier les éléments modifiés.Nous présentons également deux extensions de gDSU permettant un meilleur support du développement interactif dans les IDEs : la programmation interactive transactionnelle et l’application atomique de reusinages (refactorings)
Updating applications during their execution is used both in production to minimize application downtine and in integrated development environments to provide live programming support. Nevertheless, these two scenarios present different challenges making Dynamic Software Update (DSU) solutions to be specifically designed for only one of these use cases. For example, DSUs for live programming typically do not implement safe point detection or insistance migration, while production DSUs require manual generation of patches and lack IDE integration. These sollutions also have a limited ability to update themselves or the language core libraries and some of them present execution penalties outside the update window.In this PhD, we propose a unified DSU named gDSU for both live programming and production environments. gDSU provides safe update point detection using call stack manipulation and a reusable instance migration mechanism to minimize manual intervention in patch generation. It also supports updating the core language libraries as well as the update mechanism itself thanks to its incremental copy of the modified objects and its atomic commit operation.gDSU does not affect the global performance of the application and it presents only a run-time penalty during the window. For example, gDSU is able to apply an update impacting 100,000 instances in 1 second making the application not responsive for only 250 milliseconds. The rest of the time the applications runs normally while gDSU is looking for a safe update point during which modified elements will be copied.We also present extensions of gDSU to support transactional live programming and atomic automactic refactorings which increase the usability of live programming environments

For repeated transient solutions of geometrically nonlinear structures the numerical effort often poses a major obstacle. Thus, the introduction of a reduced order model, which takes the nonlinear effects into account and accelerates the calculations considerably, is often necessary.This work yields a method that allows for rapid, accurate and parameterisable solutions by means of a reduced model of the original structure. The structure is discretised and its dynamic equilibrium described by a matrix equation. The projection on a reduced basis is introduced to obtain the reduced model. A comprehensive numerical study on several common reduced bases shows that the simple introduction of a constant basis is not sufficient to account for the nonlinear behaviour. Three requirements for an rapid, accurate and parameterisable solution are derived. The solution algorithm has to take into account the nonlinear evolution of the solution, the solution has to be independent of the nonlinear finite element terms and the basis has to be adapted to external parameters.Three approaches are provided, each responding to one requirement. These approaches are assembled to the integrated method. The approaches are the update and augmentation of the basis, the polynomial formulation of the nonlinear terms and the interpolation of the basis. A Newmark-type time-marching algorithm provides the frame of the integrated method. The application of the integrated method on test-cases with geometrically nonlinear finite elements confirms that this method leads to the initial aim of a rapid, accurate and parameterisable transient solution.

The present Ph.D. thesis addresses the problem of knowledge-based engineering template update in product design. The reuse of design knowledge has become a key asset for the company's competitiveness. Knowledge-based engineering templates allow to store best practices and knowhow via formulas, rules, scripts, etc. This design knowledge can then be reused by instantiating the template. The instantiation results in the creation of an instance of the template in the specified context. In the scope of complex and large products, such as cars or aircrafts, the maintenance of knowledge-based engineering templates is a challenging task. Several engineers from various disciplines work together and make evolve the templates in order to extend their capabilities or to fix bugs. Furthermore, in some cases, the modifications applied to templates should be forwarded to their instances in order that they benefit from the changes. These issues slow down the adoption of template technologies at a large scale within companies. The objective of this work is to propose an approach in order to support engineers in the template update related tasks. In order to address these issues, a process supporting the template update related tasks is defined. Then a framework is proposed that helps design engineers during the template update process by providing a decision support system and a strategy for the update of template instances. The former is a system designed to ease the collaboration between various experts in order to solve template related problems. The latter aims at providing a sequence of updates to follow, in order to forward the templates' modifications to their instances. This sequence is computed with data extracted from models and templates, which are stored in an ontology designed for this purpose. The ontology is used to represent and to infer knowledge about templates, products and their relations. This facilitates the construction of update sequences as it provides an efficient overview of relationships, even implicit ones.

In this thesis we have tackled a few scheduling problems under energy constraint, since the energy issue is becoming crucial, for both economical and environmental reasons. In the first chapter, we exhibit tight bounds on the energy metric of a classical algorithm that minimizes the makespan of independent tasks. In the second chapter, we schedule several independent but concurrent pipelined applications and address problems combining multiple criteria, which are period, latency and energy. We perform an exhaustive complexity study and describe the performance of new heuristics. In the third chapter, we study the replica placement problem in a tree network. We try to minimize the energy consumption in a dynamic frame. After a complexity study, we confirm the quality of our heuristics through a complete set of simulations. In the fourth chapter, we come back to streaming applications, but in the form of series-parallel graphs, and try to map them onto a chip multiprocessor. The design of a polynomial algorithm on a simple problem allows us to derive heuristics on the most general problem, whose NP-completeness has been proven. In the fifth chapter, we study energy bounds of different routing policies in chip multiprocessors, compared to the classical XY routing, and develop new routing heuristics. In the last chapter, we compare the performance of different algorithms of the literature that tackle the problem of mapping DAG applications to minimize the energy consumption.