Search

Against the growing complexity of systems, model reuse is often used in the analysis and design steps of software development. In this thesis, we explore this kind of reuse by focusing on templates which are parameterized models. Templates capture general knowledge that can be adapted to various application contexts. On the basis of aspectual templates which have a model as parameter, we propose a dedicated engineering. This engineering is structured around a model repository and two design spaces : one for templates and one for application models, each space supporting its specific modeling activities. We contribute to this engineering by studying three topics. First, through the analysis of the UML “bind” relationship, we isolate instantiation as a first-class operation to build a model based on the template structure. Questions about partial instantiation and instantiation sequences are further examined. Then, in order to ease model comprehension and evolution, we provide operators for detecting and deleting templates inside models. Finally, we study the application of templates on model hierarchies which occurs in model versioning and team modeling. To facilitate these uses, rules defining the validity of such applications and their effects on the relations between resulting models are given. We apply this engineering by presenting corresponding operators, their implementa- tion in a reusable technology and their experimentation to model a REST server of data curation.; Pour répondre à la complexité grandissante des systèmes, la réutilisation de modèles est employée dans les phases amont d’analyse et de conception. Dans cette thèse, nous nous intéressons à cette réutilisation en privilégiant les modèles paramétrés que sont les templates. Ceux-ci expriment des connaissances générales applicables à différents contextes. Sur la base des aspectual templates possédant un modèle en paramètre, nous proposons une ingénierie dédiée. Celle-ci est structurée autour d’un dépôt de modèles et de deux espaces de conception : celui des templates et celui des modèles applicatifs, chaque espace supportant des activités de modélisation spécifiques. Nous contribuons à cette ingénierie en approfondissant trois axes. Tout d’abord, en examinant la relation “bind" des templates UML, nous isolons l’instanciation comme opération de plein droit pour construire un modèle basé sur la structure du template. Les questions d’instanciation partielle et de séquences d’instanciation sont aussi examinées. Ensuite, pour répondre à des besoins d’évolution de modèles, nous proposons des opérateurs pour détecter et supprimer des templates dans un modèle. Enfin, nous étudions l’application de templates sur une hiérarchie de modèles dont les usages se rencontrent dans le versionnement et la modélisation en équipe. Pour faciliter ces usages, des règles définissant la validité de telles applications et leurs effets sur les relations entre leurs modèles résultats sont données. Nous appliquons cette ingénierie en proposant des opérateurs, leur mise en œuvre dans une technologie réutilisable et leur expérimentation en modélisant un serveur REST d’agrégation d’informations.

For securing web applications, we were interested in applying dynamic security analyses to JavaScript programs. In this context, the ability to quickly modify the interpreter and to compose analyses at runtime is paramount. One way to effect these changes would have been through refactoring. But refactoring can be tricky and time-consuming, as it entails to rewrite parts of the source code, and even to reorganize the program’s whole architecture. Refactoring is too costly when rapid iteration is preferred.We explore a lightweight alternative to refactoring: diverting. To divert a program is to change its results without directly modifying its source code. To divert a program, we leverage indirection techniques such as dynamic scoping and metaprogramming.We first review the techniques used in related extensibility problems, like the Expression Problem, and apply these techniques to divert simple interpreters. We then show how diverting can help build interpreters incrementally in layers, allowing dynamic activation of alternative behavior. Finally, we apply those techniques to divert a full-blown JavaScript interpreter with multiple dynamic security analyses. We find that, with potential costs in efficiency and program safety, diverting is both faster and more flexible than rewriting the interpreter,thus making diverting a legitimate alternative to refactoring.; Afin de sécuriser les applications web, nous nous sommes intéressés à appliquer des analyses dynamiques de sécurité à des programmes JavaScript. Dansce contexte, pouvoir rapidement modifier l’interpréteur et composer des analyses à l’exécution est primordial. Une façon d’effectuer ces changements aurait été parrefactorisation. Mais la refactorisation peut être délicate et chronophage, car elle implique de réécrire des parties du code source, voire de réorganiser toute l’architecture du programme. La refactorisation est trop coûteuse lorsque prime la vitesse d’itération.Nous explorons une alternative économe à la refactorisation : le détournement. Détourner un programme c’est changer ses résultats sans directement modifierson code source. Pour détourner un programme, on exploite des techniques d’indirection, tels que la portée dynamique et la métaprogrammation.On commence par passer en revue les techniques utilisées pour des problèmes connexes d’extensibilité, et on applique ces techniques pour détourner des interpréteurs simples. Puis, on montre comment le détournement peut aider à construire un interpréteur par incréments, pour permettre d’activer dynamiquement des comportements alternatifs. Enfin, on applique ces techniques pour détourner un véritable interpréteur JavaScript par de multiples analyses dynamiques de sécurité.Au prix d’un potentiel impact en efficacité et en sûreté, détourner l’interpréteur est à la fois plus rapide et plus flexible que de le réécrire, ce qui fait du détournement une alternative légitime à la refactorisation.

For securing web applications, we were interested in applying dynamic security analyses to JavaScript programs. In this context, the ability to quickly modify the interpreter and to compose analyses at runtime is paramount. One way to effect these changes would have been through refactoring. But refactoring can be tricky and time-consuming, as it entails to rewrite parts of the source code, and even to reorganize the program’s whole architecture. Refactoring is too costly when rapid iteration is preferred.We explore a lightweight alternative to refactoring: diverting. To divert a program is to change its results without directly modifying its source code. To divert a program, we leverage indirection techniques such as dynamic scoping and metaprogramming.We first review the techniques used in related extensibility problems, like the Expression Problem, and apply these techniques to divert simple interpreters. We then show how diverting can help build interpreters incrementally in layers, allowing dynamic activation of alternative behavior. Finally, we apply those techniques to divert a full-blown JavaScript interpreter with multiple dynamic security analyses. We find that, with potential costs in efficiency and program safety, diverting is both faster and more flexible than rewriting the interpreter,thus making diverting a legitimate alternative to refactoring.; Afin de sécuriser les applications web, nous nous sommes intéressés à appliquer des analyses dynamiques de sécurité à des programmes JavaScript. Dansce contexte, pouvoir rapidement modifier l’interpréteur et composer des analyses à l’exécution est primordial. Une façon d’effectuer ces changements aurait été parrefactorisation. Mais la refactorisation peut être délicate et chronophage, car elle implique de réécrire des parties du code source, voire de réorganiser toute l’architecture du programme. La refactorisation est trop coûteuse lorsque prime la vitesse d’itération.Nous explorons une alternative économe à la refactorisation : le détournement. Détourner un programme c’est changer ses résultats sans directement modifierson code source. Pour détourner un programme, on exploite des techniques d’indirection, tels que la portée dynamique et la métaprogrammation.On commence par passer en revue les techniques utilisées pour des problèmes connexes d’extensibilité, et on applique ces techniques pour détourner des interpréteurs simples. Puis, on montre comment le détournement peut aider à construire un interpréteur par incréments, pour permettre d’activer dynamiquement des comportements alternatifs. Enfin, on applique ces techniques pour détourner un véritable interpréteur JavaScript par de multiples analyses dynamiques de sécurité.Au prix d’un potentiel impact en efficacité et en sûreté, détourner l’interpréteur est à la fois plus rapide et plus flexible que de le réécrire, ce qui fait du détournement une alternative légitime à la refactorisation.

Les logiciels sont en constante évolution, nécessitant une maintenance et un développement continus. Ils subissent des changements tout au long de leur vie, que ce soit pendant l'ajout de nouvelles fonctionnalités ou la correction de bogues. Lorsque les logiciels évoluent, leurs architectures ont tendance à se dégrader et deviennent moins adaptables aux nouvelles spécifications des utilisateurs. En effet, les architectures de ces logiciels deviennent plus complexes et plus difficiles à maintenir à cause des nombreuses dépendances entre les artefacts. Par conséquent, les développeurs doivent comprendre les dépendances entre les artefacts des logiciels pour prendre des mesures proactives qui facilitent les futurs changements et ralentissent la dégradation des architectures des logiciels. D'une part, le maintien d'un logiciel sans la compréhension des les dépendances entre ses artefacts peut conduire à l'introduction de défauts. D'autre part, lorsque les développeurs manquent de connaissances sur l'impact de leurs activités de maintenance, ils peuvent introduire des défauts de conception, qui ont un impact négatif sur l'évolution du logiciel. Ainsi, les développeurs ont besoin de mécanismes pour comprendre comment le changement d'un artefact impacte le reste du logiciel. Dans cette thèse, nous proposons trois contributions principales : La spécification de deux nouveaux patrons de changement et leurs utilisations pour fournir aux développeurs des informations utiles concernant les dépendances de co-changement. La spécification de la relation entre les patrons d'évolutions des artefacts et les fautes. La découverte de la relation entre les dépendances des anti-patrons et la prédisposition des différentes composantes d'un logiciel aux fautes., Program maintenance accounts for the largest part of the costs of any program. During maintenance activities, developers implement changes (sometimes simultaneously) on artefacts to fix bugs and to implement new requirements. Thus, developers need knowledge to identify hidden dependencies among programs artefacts and detect correlated artefacts. As programs evolved, their designs become more complex over time and harder to change. In the absence of the necessary knowledge on artefacts dependencies, developers could introduce design defects and faults that causes development and maintenance costs to rise. Therefore, developers must understand the dependencies among program artefacts and take proactive steps to facilitate future changes and minimize fault proneness. On the one hand, maintaining a program without understanding the different dependencies between their artefacts may lead to the introduction of faults. On the other hand, when developers lack knowledge about the impact of their maintenance activities, they may introduce design defects, which have a negative impact on program evolution. Thus, developers need mechanisms to understand how a change to an artefact will impact the rest of the programs artefacts and tools to detect design defects impact. In this thesis, we propose three principal contributions. The first contribution is two novel change patterns to model new co-change and change propagation scenarios. We introduce the Asynchrony change pattern, corresponding to macro co-changes, i.e., of files that co-change within a large time interval (change periods), and the Dephase change pattern, corresponding to dephase macro co-changes, i.e., macro co-changes that always happen with the same shifts in time. We present our approach, named Macocha, and we show that such new change patterns provide interesting information to developers. The second contribution is proposing a novel approach to analyse the evolution of different classes in object-oriented programs and to link different evolution behaviour to faults. In particular, we define an evolution model for each class to study the evolution and the co-evolution dependencies among classes and to relate such dependencies with fault-proneness. The third contribution concerns design defect dependencies impact. We propose a study to mine the link between design defect dependencies, such as co-change dependencies and static relationships, and fault proneness. We found that the negative impact of design defects propagate through their dependencies. The three contributions are evaluated on open-source programs.

Maintenance consumes a large part of the cost of software development which makes the optimization of that cost among the important issues in the world of software engineering. In this thesis we aim to optimize this cost by making these maintenances modular. To achieve this goal, we define transformations of program architectures that allow to transform a program to maintain into an architecture that facilitates the maintenance tasks required. We focus on transformation between architectures having dual modularity properties such as Composite and Visitor designpatterns. In this context, we define an automatic and reversible transformation based on refactoring between a program structured according to the Composite structure and its corresponding Visitor structure. This transformation is validated by generating a precondition which guarantees statically its success. It is also adapted to take into account the transformation of four variations of Composite pattern and it is then applied to JHotDraw program in which these four variations occur. We define also a reversible transformation in the Singleton pattern to benefit from optimization by introducing this pattern and flexibility by its suppression according to the requirements of the software user.; La maintenance consomme une grande partie du coût de développement des logiciels ce qui rend l’optimisation de ce coût parmi les enjeux importants dans le monde du génie logiciel. Dans cette thèse nous visons à optimiser ce coût par rendre ces maintenances modulaires. Pour atteindre cet objectif, nous définissons des transformations des architectures des programmes qui permettent de transformer le programme à maintenir vers une architecture qui facilite la tâche de maintenance voulue. Nous nous concentrons plus sur la transformation entre les architectures à propriétés de modularité duales tels que les patrons de conception Composite et Visiteur. Dans ce contexte, nous définissons une transformation automatique et réversible basée sur le refactoring entre un programme structuré selon le Composite et sa structureVisiteur correspondante. Cette transformation est validée par la génération d’une précondition qui garantit statiquement sa réussite. Elle est aussi adaptée afin qu’elle prenne en compte la transformation de quatre variations du patron Composite et est validée sur le programme JHotDraw qui comporte ces quatre variations. Nous définissons aussi une transformation réversible au sein du patron Singleton afin de pouvoir bénéficier de l’optimisation par l’introduction de ce patron et la souplesse par sa suppression selon les exigences de l’utilisateur du logiciel.

The research context of this thesis is the inter-cultural development of computer tools. The thesis considers as case study the Nasa people, a Colombian native society, which preserves different traditions and cultural particularities. The research questioning emerges from the sociocultural differences between a rural society, such as the Nasa, and the computer-producing societies. In general, cultural adaptation processes focus on the linguistic translation and factors easy to study. However, the developer¿s culture is implicit in a wide range of aspects of the production of interactive systems. For example, the office metaphor, commonly used in personal computers, is based on everyday objects found in a urban work context. Nevertheless, desktops, files, folders are less familiar in the Nasa environment, resulting in a misunderstood analogy. This thesis accomplish two main contributions. First, a cultural model for the study of important sociocultural characteristics in the development of computer tools (language, environment and technology, social organization, spatial structures and non-verbal signs.) Second, a design description method that integrates the cultural characteristics identified by the model into design patterns. These contributions have been applied in the Nasa context, where two different tools have been developed following a participative method. These tools were designed and evaluated with students and teachers of two schools. An initial catalog of patterns describes how the design issues found have been resolved; Le contexte de recherche de cette thèse est le développement d'outils informatiques dans un cadre interculturel. La thèse prend comme cas d'étude le peuple nasa, aborigène de Colombie conservant d'importantes caractéristiques culturelles. La problématique de recherche est née à partir des différences culturelles entre ce peuple rural et la société productrice des dispositifs informatiques. Les processus d'adaptation culturelle se concentrent en général sur la traduction textuelle et sur des éléments faciles à étudier. Cependant, la culture est implicite dans une large gamme d'aspects de la conception et utilisation d'un système informatique. Par exemple, la métaphore du bureau est basée sur des éléments typiques d'un environnement de travail urbain. Toutefois, les dossiers, fichiers et autres composants de l'interface sont moins courants dans le contexte nasa. Cette thèse réalise deux contributions majeures. Premièrement, un modèle culturel qui aide à l'étude de caractéristiques socioculturelles importantes dans le développement d'outils informatiques (la langue, l'environnement et la technologie, l'organisation sociale, la structuration de l'espace, et les signes non-linguistiques). Deuxièmement, une méthode de description de conception intégrant les caractéristiques culturelles à des patrons de conception. Ceux-ci rendent possible la représentation de l'influence de la culture sur la production d'un outil. Ces contributions ont été appliquées dans le contexte nasa et deux outils ont été mis en oeuvre dans deux écoles en suivant une méthode de conception participative. Un catalogue initial de patrons décrit la résolution de différents problèmes de conception.

20 pages; International audience; Pour répondre au besoin d'adaptation de la scénarisation pédagogique des jeux sérieux exprimé par des enseignants, nous avons développé un modèle pour représenter la scénarisation pédago­ludique des jeux sérieux fondé sur des patrons de conception. Puis, nous avons implémenté ce modèle dans un outil auteur permettant aux enseignants de manipuler les parcours pédago­ludiques.

We first expose in this memoir efficient matrix multiplication techniques. We set up new schedules that allow us to minimize the extra memory requirements during a Winograd-style matrix multiplication, while keeping the complexity competitive. In order to get them, we develop external tools (pebble game), tight complexity computations and new hybrid algorithms. Then we use parallel technologies (multicore CPU and GPU) in order to accelerate efficiently the sparse matrix--dense vector multiplication (SpMV), crucial to /blackbox/ algorithms and we set up new hybrid formats to store them. Finally, we establish generic design methods focusing on efficiency, especially via building block conceptions or self-optimization. We also propose tools for improving and standardizing code quality in order to make it more sustainable and more robust. This is in particular applied to the LinBox computer algebra library., Dans ce mémoire de thèse, nous développons d'abord des multiplications matricielles efficaces. Nous créons de nouveaux ordonnancements qui permettent de réduire la taille de la mémoire supplémentaire nécessaire lors d'une multiplication du type Winograd tout en gardant une bonne complexité, grâce au développement d'outils externes ad hoc (jeu de galets), à des calculs fins de complexité et à de nouveaux algorithmes hybrides. Nous utilisons ensuite des technologies parallèles (multicœurs et GPU) pour accélérer efficacement la multiplication entre matrice creuse et vecteur dense (SpMV), essentielles aux algorithmes dits /boîte noire/, et créons de nouveaux formats hybrides adéquats. Enfin, nous établissons des méthodes de /design/ générique orientées vers l'efficacité, notamment par conception par briques de base, et via des auto-optimisations. Nous proposons aussi des méthodes pour améliorer et standardiser la qualité du code de manière à pérenniser et rendre plus robuste le code produit. Cela permet de pérenniser de rendre plus robuste le code produit. Ces méthodes sont appliquées en particulier à la bibliothèque de calcul exact LinBox.

National audience; De nombreux jeux sérieux reposent sur une simulation du domaine à enseigner avec laquelle l'apprenant joueur peut interagir ludiquement au moyen d'une métaphore. Dans la conception de ces jeux sérieux, l'équilibre entre motivation et apprentissage est un critère de réussite. Cette articulation repose sur la synergie des expertises pédagogiques et ludiques. Afin de susciter cette synergie et de faciliter cette articulation, nous avons mis au point un outil d'analyse de la conception : les 6 facettes du jeu sérieux. Cet outil est un cadre conceptuel permettant de questionner la conception afin de comprendre la structure d'un jeu sérieux, soit en cours de conception pour identifier les problèmes et rationaliser le travail, soit après la conception pour identifier et extraire les bonnes pratiques.

La recherche en génie logiciel a depuis longtemps tenté de mieux comprendre le processus de développement logiciel, minimalement, pour en reproduire les bonnes pratiques, et idéalement, pour pouvoir le mécaniser. On peut identifier deux approches majeures pour caractériser le processus. La première approche, dite transformationnelle, perçoit le processus comme une séquence de transformations préservant certaines propriétés des données à l’entrée. Cette idée a été récemment reprise par l’architecture dirigée par les modèles de l’OMG. La deuxième approche consiste à répertorier et à codifier des solutions éprouvées à des problèmes récurrents. Les recherches sur les styles architecturaux, les patrons de conception, ou les cadres d’applications s’inscrivent dans cette approche. Notre travail de recherche reconnaît la complémentarité des deux approches, notamment pour l’étape de conception: dans le cadre du développement dirigé par les modèles, nous percevons l’étape de conception comme l’application de patrons de solutions aux modèles reçus en entrée. Il est coutume de définir l’étape de conception en termes de conception architecturale, et conception détaillée. La conception architecturale se préoccupe d’organiser un logiciel en composants répondant à un ensemble d’exigences non-fonctionnelles, alors que la conception détaillée se préoccupe, en quelque sorte, du contenu de ces composants. La conception architecturale s’appuie sur des styles architecturaux qui sont des principes d’organisation permettant d’optimiser certaines qualités, alors que la conception détaillée s’appuie sur des patrons de conception pour attribuer les responsabilités aux classes. Les styles architecturaux et les patrons de conception sont des artefacts qui codifient des solutions éprouvées à des problèmes récurrents de conception. Alors que ces artefacts sont bien documentés, la décision de les appliquer reste essentiellement manuelle. De plus, les outils proposés n’offrent pas un support adéquat pour les appliquer à des modèles existants. Dans cette thèse, nous nous attaquons à la conception détaillée, et plus particulièrement, à la transformation de modèles par application de patrons de conception, en partie parce que les patrons de conception sont moins complexes, et en partie parce que l’implémentation des styles architecturaux passe souvent par les patrons de conception. Ainsi, nous proposons une approche pour représenter et appliquer les patrons de conception. Notre approche se base sur la représentation explicite des problèmes résolus par ces patrons. En effet, la représentation explicite du problème résolu par un patron permet : (1) de mieux comprendre le patron, (2) de reconnaître l’opportunité d’appliquer le patron en détectant une instance de la représentation du problème dans les modèles du système considéré, et (3) d’automatiser l’application du patron en la représentant, de façon déclarative, par une transformation d’une instance du problème en une instance de la solution. Pour vérifier et valider notre approche, nous l’avons utilisée pour représenter et appliquer différents patrons de conception et nous avons effectué des tests pratiques sur des modèles générés à partir de logiciels libres., Software engineering researchers have long tried to understand the software process development to mechanize it or at least to codify its good practices. We identify two major approaches to characterize the process. The first approach—known as transformational—sees the process as a sequence of property-preserving transformations. This idea was recently adopted by the OMG’s model-driven architecture (MDA). The second approach consists in identifying and codifying proven solutions to recurring problems. Research on architectural styles, frameworks and design patterns are part of this approach. Our research recognizes the complementarity of these two approaches, in particular in the design step. Indeed within the model-driven development context, we view software design as the process of applying codified solution patterns to input models. Software design is typically defined in terms of architectural design and detailed design. Architectural design aims at organizing the software in modules or components that meet a set of non-functional requirements while detailed design is—in some way—concerned by the contents of the identified components. Architectural design relies on architectural styles which are principles of organization to optimize certain quality requirements, whereas detailed design relies on design patterns to assign responsibilities to classes. Both architectural styles and design patterns are design artifacts that encode proven solutions to recurring design problems. While these design artifacts are documented, the decision to apply them remains essentially manual. Besides, once a decision has been made to use a design artifact, there is no adequate support to apply it to existing models. As design patterns present an ‘‘easier’’ problem to solve, and because architectural styles implementation relies on design patterns, our strategy for addressing these issues was to try to solve the problem for design patterns first, and then tackle architectural styles. Hence, in this thesis, we propose an approach for representing and applying design patterns. Our approach is based on an explicit representation of the problems solved by design patterns. Indeed, and explicit representation of the problem solved by a pattern enables to: 1) better understand the pattern, 2) recognize the opportunity of applying the pattern by matching the representation of the problem against the models of the considered system, and 3) specify declaratively the application of the pattern as a transformation of an instance of the problem into an instance of the solution. To verify and validate the proposed approach, we used it to represent and apply several design patterns. We also conducted practical tests on models generated from open source systems.

Models driven engineering considers models first class entities for the software development. The models driven processes must be able to take into account the know-how of experts, generally expressed in terms of analysis, architectural of design patterns. To choose the right pattern and to ensure its correct integration within a model constitute curbs with the systematic use of the good design practices. In order to reduce these tasks, we propose an approach based on the automatic inspection of models. In the same manner that there are code review activities aiming at checking the absence of bad coding practices in a program, we have tooled a design review activity identifying, explaining and correcting the bad design practices in a model. A spoiled pattern is comparable with a design pattern, its instantiations solving the same types of problems, but with a different and certainly improvable architecture. Experiments were carried out in order to collect spoiled patterns, allowing us to propose a catalog of bad practices, complementary to the GoF catalog. The detection of the instantiations of spoiled patterns in a UML model is related with a wide graph homomorphism. Graphs UML having typed vertexes, detection is based on local and global structural properties allowing the solving of this NP-Complete problem by successive filtering. Thus, this algorithm is able to detect all the possible instantiations of a spoiled pattern, by managing moreover prohibited and optional edges. The model fragment semantics is given by its intent which is validated by the designer. The intent of the detected fragments and the benefit of a replacement by the adequate pattern are deduced by requests on an ontology conceived for this purpose. The transformation of the fragments into instantiations of design pattern is carried out thanks to model refactoring automatically deduced from the structural differences between a spoiled pattern and an design pattern.; L'ingénierie des modèles considère les modèles comme des entités de première classe pour le développement logiciel. Les processus dirigés par les modèles se doivent d'être capables de prendre en compte le savoir-faire d'experts, généralement exprimé en termes de patrons, qu'ils soient d'analyse, de conception ou d'architecture. Choisir le bon patron et assurer sa bonne intégration au sein d'une modélisation constitue des freins à l'utilisation systématique des bonnes pratiques de conception. Afin d'alléger ces tâches, nous proposons une approche basée sur l'inspection automatique des modèles. De la même manière qu'il existe des revues de code visant à vérifier l'absence de mauvaises pratiques de codage dans un programme, nous avons outillé une activité de revue de conception identifiant, expliquant et corrigeant les mauvaises pratiques de conception dans un modèle. Un patron abîmé est comparable à un patron de conception, ses contextualisations résolvant les mêmes types de problèmes, mais avec une architecture différente et certainement améliorable. Des expérimentations ont été menées afin de collecter des patrons abîmés, nous amenant à proposer un catalogue de mauvaises pratiques, complémentaire au catalogue du GoF. La détection des contextualisations de patrons abîmés dans un modèle UML est apparentée à un morphisme de graphe étendu. Les graphes UML ayant des sommets typés, la détection s'appuie sur des particularités structurelles locales et globales permettant de résoudre ce problème NP-Complet par des filtrages successifs. Cet algorithme est ainsi capable de détecter toutes les contextualisations possibles d'un patron abîmé, en gérant de plus les arcs interdits et facultatifs. La sémantique d'un fragment de modèle est donnée par son intention et celle-ci est validée par le concepteur. L'intention des fragments détectés et les bénéfices d'un remplacement par le patron adéquat sont déduits par des requêtes sur une ontologie conçue à cet effet. La transformation des fragments en contextualisations de patrons de conception est réalisée grâce à des restructurations de modèles déduites automatiquement des différences structurelles entre un patron abîmé et un patron de conception.

Models driven engineering considers models first class entities for the software development. The models driven processes must be able to take into account the know-how of experts, generally expressed in terms of analysis, architectural of design patterns. To choose the right pattern and to ensure its correct integration within a model constitute curbs with the systematic use of the good design practices. In order to reduce these tasks, we propose an approach based on the automatic inspection of models. In the same manner that there are code review activities aiming at checking the absence of bad coding practices in a program, we have tooled a design review activity identifying, explaining and correcting the bad design practices in a model. A spoiled pattern is comparable with a design pattern, its instantiations solving the same types of problems, but with a different and certainly improvable architecture. Experiments were carried out in order to collect spoiled patterns, allowing us to propose a catalog of bad practices, complementary to the GoF catalog. The detection of the instantiations of spoiled patterns in a UML model is related with a wide graph homomorphism. Graphs UML having typed vertexes, detection is based on local and global structural properties allowing the solving of this NP-Complete problem by successive filtering. Thus, this algorithm is able to detect all the possible instantiations of a spoiled pattern, by managing moreover prohibited and optional edges. The model fragment semantics is given by its intent which is validated by the designer. The intent of the detected fragments and the benefit of a replacement by the adequate pattern are deduced by requests on an ontology conceived for this purpose. The transformation of the fragments into instantiations of design pattern is carried out thanks to model refactoring automatically deduced from the structural differences between a spoiled pattern and an design pattern.; L'ingénierie des modèles considère les modèles comme des entités de première classe pour le développement logiciel. Les processus dirigés par les modèles se doivent d'être capables de prendre en compte le savoir-faire d'experts, généralement exprimé en termes de patrons, qu'ils soient d'analyse, de conception ou d'architecture. Choisir le bon patron et assurer sa bonne intégration au sein d'une modélisation constitue des freins à l'utilisation systématique des bonnes pratiques de conception. Afin d'alléger ces tâches, nous proposons une approche basée sur l'inspection automatique des modèles. De la même manière qu'il existe des revues de code visant à vérifier l'absence de mauvaises pratiques de codage dans un programme, nous avons outillé une activité de revue de conception identifiant, expliquant et corrigeant les mauvaises pratiques de conception dans un modèle. Un patron abîmé est comparable à un patron de conception, ses contextualisations résolvant les mêmes types de problèmes, mais avec une architecture différente et certainement améliorable. Des expérimentations ont été menées afin de collecter des patrons abîmés, nous amenant à proposer un catalogue de mauvaises pratiques, complémentaire au catalogue du GoF. La détection des contextualisations de patrons abîmés dans un modèle UML est apparentée à un morphisme de graphe étendu. Les graphes UML ayant des sommets typés, la détection s'appuie sur des particularités structurelles locales et globales permettant de résoudre ce problème NP-Complet par des filtrages successifs. Cet algorithme est ainsi capable de détecter toutes les contextualisations possibles d'un patron abîmé, en gérant de plus les arcs interdits et facultatifs. La sémantique d'un fragment de modèle est donnée par son intention et celle-ci est validée par le concepteur. L'intention des fragments détectés et les bénéfices d'un remplacement par le patron adéquat sont déduits par des requêtes sur une ontologie conçue à cet effet. La transformation des fragments en contextualisations de patrons de conception est réalisée grâce à des restructurations de modèles déduites automatiquement des différences structurelles entre un patron abîmé et un patron de conception.

Mémoire numérisé par la Division de la gestion de documents et des archives de l'Université de Montréal.

This thesis deals with the development of automated systems while following the formal methods B and TLA+. We propose a formal methodology based on the refinement paradigm to specify and verify the system that we model by two components: the controlled system representing the physical device and its environment, and the controller that controls the system. A synchronised product on the actions of these two components is applied to specify the automated system. As a first contribution, we propose an approach combining the event B method and the language TLA+ in order to verify liveness properties defined in user requirements. Inspired by the temporal logic of actions TLA, we first extend the event B notation to specify liveness properties and we give semantics of this extended syntax over traces. Second, we give transformation rules from a temporal B model into a TLA+ module. We present, in particular, our prototype system called B2TLA+, that we have developed to support this transformation. To consider infinite systems, we use predicate diagrams as abstractions of systems modelled with TLA+. To consider the real-time concept in automated systems, we propose as a second contribution a technique explicitly representing time in B event systems. This technique is based on an interleaving between any event handling time and the other system events. By considering the well known co-design technique, we propose as a third contribution a refinement-based composition technique keeping a separation between controller and controlled systems in order to build correct automated systems satisfying user requirements. We prove a compositionality theorem with respect to refinement to get an efficient approach to verify the refinement of a synchronized composition between components. We verify the refinement of a synchronized composition by verifying separately the refinement of each component. Finally, we define, prove and use in a case study as a fourth contribution the concept of a refinement pattern for continuous processes in manufacturing systems. Such proven pattern allows us to use the discrete abstraction of the effect of continuous processes operating for a while; Le travail de thèse présente une méthode de développement de systèmes automatisés basée sur les méthodes formelles B et TLA+. Le développement par raffinement est au coeur de la méthode proposée. Un système automatisé est modélisé par deux composants, un contrôlé formé par le dispositif physique et son environnement et un contrôleur pilotant ce dernier. Il est exprimé par un produit synchronisé sur les actions de ces deux composants. La première contribution de la thèse concerne la proposition d'une approche qui combine le B événementiel et le langage de modélisation TLA+ pour la vérification des propriétés de vivacité. Nous définissons une extension syntaxique et sémantique du B événementiel permettant d'exprimer des propriétés de vivacité. Nous développons un prototype pour la transformation d'un modèle B en un module TLA+ sur lequel nous effectuons la preuve des propriétés de vivacité avec le model checker TLC. Pour la vérification de ce type de propriétés sur des systèmes infinis, nous proposons l'utilisation des diagrammes de prédicats qui sont des abstractions des systèmes modélisés en TLA+. La deuxième contribution est la proposition d'une technique pour représenter explicitement le temps en B événementiel. Cette technique s'appuie sur la réalisation d'un entrelacement entre un processus qui gère le temps avec les autres processus du système. Le temps modélisé est discret et son écoulement est modélisé par des événements. Cette approche est assez différente des systèmes temporisés où l'on considère que le temps s'écoule indépendamment du système. Dans la troisième contribution, nous proposons une approche de développement des systèmes automatisés en utilisant la technique de composition où il s'agit de développer conjointement le contrôleur et le composant physique qu'il contrôle et appliquer le raffinement aussi bien sur le contrôleur que le contrôlé. Le raffinement est une technique de base des méthodes que nous proposons et si notre objectif est de construire des contrôleurs corrects, le critère de correction porte sur le comportement du système automatisé qui résulte de la composition du contrôleur et du contrôlé. Nous présentons également un théorème de compositionnalité qui indique sous quelles conditions il est possible de déduire que le composé des raffinements des contrôleur et contrôlé est un raffinement du composé des contrôleur et contrôlé abstraits. La dernière contribution porte sur la définition, la preuve et l'utilisation d'un patron de raffinement pour les processus continus dans des systèmes de production manufacturière. Ce type de patron prouvé permet d'utiliser l'abstraction discrète de l'effet d'un processus continu agissant pendant un certain temps

National audience; Les concepteurs peuvent aujourd'hui justifier leurs décisions de conception à partir de patrons qu'ils ont appliqués. De même que la qualité d'un code source peut facilement être jugée par un regard rapide aux normes de codage qui ont été suivies, la qualité d'une conception peut maintenant être estimée d'après les patrons utilisés. De bons outils de conception logicielle embarquent une expertise de conception, sous une forme réutilisable, de patrons instanciables. Ces concepts sont transposables dans le domaine de la conception de système, en particulier selon le point de vue de leur vérification et de leur validation. Le raffinement est un outil d'ingénierie des systèmes corrects. Toutefois, cet outil, comme bien d'autres, nécessite une utilisation experte pour être efficace. Une telle expertise doit être cataloguée et réutilisée, quand cela est possible, sous la forme de patrons de conception. Ces patrons doivent cibler la vérification et la validation formelle, afin de fournir des outils de haut niveau dont l'usage permettrait de justifier l'atteinte d'objectifs de sécurité et de confiance. Construire de tels patrons nécessite des innovations théoriques. Nous pensons que les patrons de conception formels ou les patrons de conception prouvés vont être amenés à jouer un rôle vital dans la mesure, basée sur la vérification, de l'atteinte d'objectifs de sécurité et de confiance. Les patrons de conception prouvés ont une caractéristique très intéressante : ils sont construits d'après un objectif de validation des objets conçus et capturent l'information orientée preuve du système en cours de construction. Des premiers résultats ont été obtenus lors de l'étude de systèmes réactifs (INRS) et de la certification EAL5+ de politiques de sécurité de cartes à puces..

National audience; User interface (UI) plasticity is key to context-aware computing, given the large number of interactive devices, platform heterogeneity, user profiles as well as work situations diversity. Our contribution to UI plasticity consists in automatically generating plastic user interfaces from an abstract model specified according to our own design method for developing interactive systems, using a design pattern approach to generate final UIs from this abstract model, applicable both at the design stage and at runtime, integrating the resulting UI into an architecture based on business software components.; L’interface plastique est un des éléments les plus importants dans le domaine de l’informatique pervasive, si nous considérons un grand nombre de dispositifs d’interaction, sur diverses plates-formes, différents types d’utilisateurs, et diverses situations de travail. Notre contribution consiste à générer automatiquement l’interface plastique à partir de son modèle abstrait spécifié déjà dans une méthode de conception des systèmes interactifs, en utilisant la technique des patrons de conception au niveau du passage à l’interface finale et pendant l’adaptation de l’interface, et en intégrant une architecture de l’interface basée sur les composants métier logiciels.

Our research work concerns the contribution of the Aspect approach to the engineering of the information systems (IS) in general, and to design patterns in particular. The main goal of this work is to develop aspect-oriented patterns in order to facilitate and to guide the engineering of IS by pattern reuse.Object-oriented design patterns improve and accelerate the development while supporting SI evolution, adaptation and reuse. However, their use in a strict Object approach poses several problems and limits which are mainly related to the scattering and the tangling of the code of their imitations in the applications. The Aspect approach allows new solutions for these patterns that can keep visible and isolated the imitation of each pattern in the whole code of the applications, in order to mitigate their use problems and to improve their traceability and their reuse.However due to a certain lack of consensus on what are the basic aspect-oriented concepts and mechanisms and the diversity of the suggested models and programming languages related to the Aspect approach, make it uneasy to express aspect-oriented pattern structures in a way that is not dependent from a specific aspect-oriented programming technique. To mitigate this difficulty we have adopted a meta-modeling and model transformation approach. We based this approach on a general meta-model which integrates particularities of the Aspect approach, and two meta-models that are respectively specific to AspectJ and Hyper/J. The three proposed meta-models are defined as extensions of the UML meta-model. Transformation rules are also proposed.We used the general meta-model for expressing the aspect-oriented structures of the patterns that we consider in our work. This research led us to define a system of eight original patterns that capitalize expertises related to aspect-oriented design. The proposed patterns are coordinated and treated on a hierarchical basis what makes it possible to offer a method to carry out an aspect-oriented design and programs with good quality.; Ce travail de recherche concerne l'apport de l'approche Aspect à l'ingénierie des systèmes d'information (SI) en général et aux patrons de conception en particulier. L'objectif principal de ce travail est de développer des patrons à base d'aspects afin de faciliter et de guider l'ingénierie de SI par réutilisation de patrons.Les patrons de conception par objets améliorent et accélèrent le développement en favorisant l'évolution, l'adaptation et la réutilisation de SI. Leur utilisation dans une approche strictement Objet pose cependant plusieurs problèmes et limites qui sont principalement liés à la dispersion et à l'enchevêtrement du code de leurs imitations dans l'implémentation des applications. L'approche Aspect permet de nouvelles solutions pour ces patrons contribuant à garder visible et isolée l'imitation de chaque patron dans le code des applications, afin de pallier à leurs problèmes d'utilisation et d'améliorer leur traçabilité et leur réutilisation.Toutefois, un manque de consensus sur les concepts et mécanismes fondamentaux de l'approche Aspect et la diversité des modèles et langages de programmation proposés dans ce courant de recherche rendent difficile l'expression de structures par aspects de patrons indépendamment d'une technique de programmation par aspects particulière. Pour aborder cette difficulté, nous avons adopté une approche par métamodélisation et transformation de modèles. Nous avons basé cette approche sur un métamodèle général intégrant les particularités de l'approche Aspect et deux métamodèles spécifiques à AspectJ et Hyper/J. Les trois métamodèles proposés sont définis comme étant des extensions du métamodèle d'UML. Des règles de transformation sont également proposées.Nous avons utilisé le métamodèle général pour l'expression de nouvelles solutions par aspects des patrons de conception par objets que nous considérons. Cette étude nous a permis de définir un système de huit nouveaux patrons originaux capitalisant des expertises en matière de conception par aspects. Les patrons proposés sont coordonnés et hiérarchisés ce qui permet d'offrir un cadre pour une démarche pour réaliser une conception et une programmation par aspects de qualité.

National audience; Les systèmes temps réel embarqués sont très influencés par l'architecture matérielle de leurs environnements d'application, c'est pourquoi ils sont généralement développés à partir de zéro. L'utilisation des frameworks orientés objet dans le développement des applications temps réel peut réduire énormément le coût et la durée de développement de ces applications. D'autre part les patrons de conception sont des solutions prouvées à des problèmes récurrents. Leur utilisation pour la conception et le développement des frameworks augmente la qualité des applications développées. Dans ce travail nous proposons un framework orienté objet fondé sur les patrons de conception temps réel

Our research work concerns the contribution of the Aspect approach to the engineering of the information systems (IS) in general, and to design patterns in particular. The main goal of this work is to develop aspect-oriented patterns in order to facilitate and to guide the engineering of IS by pattern reuse.Object-oriented design patterns improve and accelerate the development while supporting SI evolution, adaptation and reuse. However, their use in a strict Object approach poses several problems and limits which are mainly related to the scattering and the tangling of the code of their imitations in the applications. The Aspect approach allows new solutions for these patterns that can keep visible and isolated the imitation of each pattern in the whole code of the applications, in order to mitigate their use problems and to improve their traceability and their reuse.However due to a certain lack of consensus on what are the basic aspect-oriented concepts and mechanisms and the diversity of the suggested models and programming languages related to the Aspect approach, make it uneasy to express aspect-oriented pattern structures in a way that is not dependent from a specific aspect-oriented programming technique. To mitigate this difficulty we have adopted a meta-modeling and model transformation approach. We based this approach on a general meta-model which integrates particularities of the Aspect approach, and two meta-models that are respectively specific to AspectJ and Hyper/J. The three proposed meta-models are defined as extensions of the UML meta-model. Transformation rules are also proposed.We used the general meta-model for expressing the aspect-oriented structures of the patterns that we consider in our work. This research led us to define a system of eight original patterns that capitalize expertises related to aspect-oriented design. The proposed patterns are coordinated and treated on a hierarchical basis what makes it possible to offer a method to carry out an aspect-oriented design and programs with good quality., Ce travail de recherche concerne l'apport de l'approche Aspect à l'ingénierie des systèmes d'information (SI) en général et aux patrons de conception en particulier. L'objectif principal de ce travail est de développer des patrons à base d'aspects afin de faciliter et de guider l'ingénierie de SI par réutilisation de patrons.Les patrons de conception par objets améliorent et accélèrent le développement en favorisant l'évolution, l'adaptation et la réutilisation de SI. Leur utilisation dans une approche strictement Objet pose cependant plusieurs problèmes et limites qui sont principalement liés à la dispersion et à l'enchevêtrement du code de leurs imitations dans l'implémentation des applications. L'approche Aspect permet de nouvelles solutions pour ces patrons contribuant à garder visible et isolée l'imitation de chaque patron dans le code des applications, afin de pallier à leurs problèmes d'utilisation et d'améliorer leur traçabilité et leur réutilisation.Toutefois, un manque de consensus sur les concepts et mécanismes fondamentaux de l'approche Aspect et la diversité des modèles et langages de programmation proposés dans ce courant de recherche rendent difficile l'expression de structures par aspects de patrons indépendamment d'une technique de programmation par aspects particulière. Pour aborder cette difficulté, nous avons adopté une approche par métamodélisation et transformation de modèles. Nous avons basé cette approche sur un métamodèle général intégrant les particularités de l'approche Aspect et deux métamodèles spécifiques à AspectJ et Hyper/J. Les trois métamodèles proposés sont définis comme étant des extensions du métamodèle d'UML. Des règles de transformation sont également proposées.Nous avons utilisé le métamodèle général pour l'expression de nouvelles solutions par aspects des patrons de conception par objets que nous considérons. Cette étude nous a permis de définir un système de huit nouveaux patrons originaux capitalisant des expertises en matière de conception par aspects. Les patrons proposés sont coordonnés et hiérarchisés ce qui permet d'offrir un cadre pour une démarche pour réaliser une conception et une programmation par aspects de qualité.

Mémoire numérisé par la Direction des bibliothèques de l'Université de Montréal.

Mémoire numérisé par la Direction des bibliothèques de l'Université de Montréal.

National audience; We present in this paper the evolution of the inter-operability needs of the functional languages, illustrated in Objective Caml by our tools and multi-languages applications. First of all we describe the inherent difficulties of the low-level interfaces of communication for memory management and context switching. Then we define a new code generator, called O'Jacaré, designed to facilitate interoperation between Java and Objective Caml through their object models. O'Jacaré defines a basic IDL (Interface Definition Language) for classes and interfaces description to communicate from Objective Caml to Java. The adaptation of O'Jacaré to .NET, called O'Jacaré.net, improves communication between Objective Caml and C# via this common runtime.

The primary thesis topic is to study how object-oriented technologies may bring to scientific applications all the benefits they bring to traditionnal sequential application like: better reuse and longer software life, design methodology, cleaner realization... The main scientific computing constraint, which is performance is kept in mind.After a survey of parallel and object-oriented programming concepts, the design and realization of a parallel linear algebra library is presented. We study two different object-oriented approaches. The first use C++// language, a concurrent object-oriented language derived from C++, which implements an active object model. The second is the use of MPI through a minimal object-oriented layer realized in C++.Both of them, raise problems, regarding performance and/or sequential/parallel reuse. We solve these problems.We propose a shared on read mecanism applicable to any active object model, showing its efficiency for our applications. The second approach leads us to the new concepts of matrix shapeand shaped matrices which enable us to reach our sequential/parallel reuse objectives.In the end, the implemented design enable us to instantiate both a sequential and parallel version of our linear algebra algorithms from the very same piece of code. The resulting parallel and sequential applications both exhibit satisfying performances., L'objectif de cette thèse est d'examiner comment les technologies orientées-objet peuvent apporter aux applications scientifiques tout ce qu'elles ont apporté dans la programmation des machines séquentielles: une meilleure réutilisabilité et pérennité des codes, des démarches méthodologiques de conception et de réalisation claires... La contrainte du calcul scientifique parallèle de ne pas sacrifier les performances devant être respectée.Après une revue des moyens de programmation parallèle et desconcepts objets, la conception et la réalisation d'une bibliothèque parallèle d'algèbre linéaire orientée-objet sont présentées. Nous étudions deux moyens de programmation parallèle, le premier, C++//, est un LAO parallèle à objets actifs dérivé de C++, le second est l'utilisation de MPI au travers d'une surcouche objet minimale.Ces deux approches objets posent des problèmes soit de performances soit de réutilisabilité séquentielle/parallèle qui sont présentés et résolus.Nous proposons notamment un mécanisme simple de partage en lecture pour les modèles à objets actifs, en montrant son utilité en terme de performances de nos applications. Suite à la seconde approche nous définissons les notions de formes de matrices et de matrices avec forme qui permettent d'atteindre nos objectifs de réutilisabilité séquentielle/parallèle.Au final, la conception et la réalisation permettent d'instancier, à partir du même code [séquentiel] d'algèbre linéaire, une version séquentielle et parallèle offrant des performances satisfaisantes.

International audience; Serious learning games can provide more than just an extra engagement to ITS. Some authors argue that those based on toys also transform their pedagogical aspects. The toy is then defined as an artifact you play "with" rather than the artifact you play "at". The exploratory and experimental qualities suggested by "with" are pointed out by these authors. In order to question serious game based on toys, we began with the investigation of their design. In this article, we propose three field studies conducted in an ecological situation. They aim to identify design patterns for the integration of toys into serious games. We discuss the results of the three studies and propose design pattern foundations for the design of a simulation, and for the design of playful interactions with it.; Les jeux sérieux destinés à l'apprentissage peuvent proposer plus qu'un supplément de motivation aux EIAH. Certains auteurs avancent que ceux fondés sur des jouets en transforment également les aspects pédagogiques. Le jouet est alors défini comme l'artefact « avec » lequel joue plutôt que celui « auquel » on joue. Ce sont les qualités exploratoires et expérimentales suggérées par « avec » que ces auteurs proposent d'exploiter. Dans la perspective de questionner la place du jouet dans un jeu sérieux, nous commençons par interroger leur conception. Dans cet article, nous proposons trois études de terrain menées en situation écologique. Elles visent à identifier des patrons de conception pour l'intégration de jouets dans les jeux sérieux. Nous discutons les résultats des trois études et proposons des fondations de patrons de conception pour la construction d'une simulation, et pour la conception des interactions ludiques avec elle.