Gérer l'évolution des logiciels est une tâche complexe mais nécessaire. Tout au long de son cycle de vie, un logiciel doit subir des changements, pour corriger des erreurs, améliorer ses performances et sa qualité, étendre ses fonctionnalités ou s’adapter à son environnement. A défaut d’évoluer, un logiciel se dégrade, devient obsolète ou inadapté et est remplacé. Cependant, sans évaluation de leurs impacts et contrôle de leur réalisation, les changements peuvent être sources d’incohérences et de dysfonctionnements, donc générateurs de dégradations du logiciel. Cette thèse propose une approche améliorant la gestion de l'évolution des logiciels dans les processus de développement orientés composants. Adoptant une démarche d’ingénierie dirigée par les modèles (IDM), cette approche s’appuie sur Dedal, un langage de description d’architecture (ADL) séparant explicitement trois niveaux d’abstraction dans la définition des architectures logicielles. Ces trois niveaux (spécification, configuration et assemblage) correspondent aux trois étapes principales du développement d’une architecture (conception, implémentation, déploiement) et gardent la trace des décisions architecturales prises au fil du développement. Ces informations sont un support efficace à la gestion de l’évolution : elles permettent de déterminer le niveau d’un changement, d’analyser son impact et de planifier sa réalisation afin d’éviter la survenue d’incohérences dans la définition de l’architecture (érosion, dérive, etc.). Une gestion rigoureuse de l’évolution nécessite la formalisation, d’une part, des relations intra-niveau liant les composants au sein des modèles correspondant aux différents niveaux de définition d’une architecture et, d’autre part, des relations inter-niveaux liant les modèles décrivant une même architecture aux différents niveaux d’abstraction. Ces relations permettent la définition des propriétés de consistance et de cohérence servant à vérifier la correction d’une architecture. Le processus d’évolution est ainsi décomposé en trois phases : initier le changement de la définition de l’architecture à un niveau d’abstraction donné ; vérifier et rétablir la consistance de cette définition en induisant des changements complémentaires ; vérifier et rétablir la cohérence globale de la définition de l’architecture en propageant éventuellement les changements aux autres niveaux d’abstraction.Ces relations et propriétés sont décrites en B, un langage de modélisation formel basé sur la théorie des ensembles et la logique du premier ordre. Elles s’appliquent à des architectures définies avec un adl formel écrit en B dont le méta-modèle, aligné avec celui de Dedal, permet d’outiller la transformation de modèles entre les deux langages. Cette intégration permet de proposer un environnement de développement conjuguant les avantages des approches IDM et formelle : la conception d’architectures avec l’outillage de Dedal (modeleur graphique); la vérification des architectures et la gestion de l’évolution avec l’outillage de B (animateur, model-checker, solver). Nous proposons en particulier d’utiliser un solver B pour calculer automatiquement des plans d’évolution conformes à notre proposition et avons ainsi défini l’ensemble des règles d’évolution décrivant les opérations de modification applicables à la définition d’une architecture. Le solver recherche alors automatiquement une séquence de modifications permettant la réalisation d’un changement cible tout en préservant les propriétés de consistance et de cohérence de l’architecture. Nous avons validé la faisabilité de cette gestion de l’évolution par une implémentation mêlant optimisation et génie logiciel (search-based software engineering), intégrant notre propre solver pourvu d’heuristiques spécifiques qui améliorent significativement les temps de calcul, pour expérimenter trois scénarios d’évolution permettant de tester la réalisation d’un changement à chacun des trois niveaux d’abstraction. / Managing software evolution is a complex task. Indeed, throughout their whole lifecycle, software systems are subject to changes to extend their functionalities, correct bugs, improve performance and quality, or adapt to their environment. If not evolved, software systems degrade, become obsolete or inadequate and are replaced. While unavoidable, software changes may engender several inconsistencies and system dysfunction if not analyzed and handled carefully hence leading to software degradation and phase-out.This thesis proposes an approach to improve the evolution management activity in component-based software development processes. The solution adopts a Model-Driven Engineering (MDE) approach. It is based on Dedal, an Architecture Description Language (ADL) that explicitly separates software architecture descriptions into three abstraction levels: specification, configuration and assembly. These abstraction levels respectively correspond to the three major steps of component-based development (design, implementation and deployment) and trace architectural decisions all along development. Dedal hence efficiently supports evolution management: It enables to determine the level of change, analyze its impact and plan its execution in order to prevent architecture inconsistencies (erosion, drift, etc.). Rigorous evolution management requires the formalization, on the one hand, of intra-level relations linking components within models corresponding to different architecture abstraction levels and on the other hand, of the formalization of inter-level relations linking models describing the same architecture at different abstraction levels. These relations enable the definition of the consistency and coherence properties that prove necessary for architecture correctness analysis. The evolution process therefore consists of three steps: First, change is initiated on an architecture description at a given abstraction level; then, the consistency of the impacted description is checked out and restored by triggering additional changes; finally, the global coherence of the architecture definitions is verified and restored by propagating changes to other abstraction levels.Relations and properties are expressed in B, a set-theoretic and first-order logic language. They are applied on B formal ADL, the meta-model of which is mapped to Dedal's and helps automatic model transformations. This integration enables to implement a development environment that combines the benefits of both MDE and formal approaches: Software architecture design using Dedal tools (graphical modeler) and architecture analysis and evolution management using B tools (animator, model-checker, solver).In particular, we propose to use a B solver to automatically calculate evolution plans according to our approach. The solver explores a set of defined evolution rules that describe the change operations that can apply on architecture definitions. It automatically searches for a sequence of operations that both changes the architecture as requested and preserves architecture consistency and coherence properties. The feasibility of the evolution management approach is demonstrated through the experimentation of three evolution scenarios, each addressing a change at different abstraction level. The experimentation relies on an implementation of a search-based software engineering approach mixing software engineering and optimization and integrates our own solver with specific heuristics that significantly improve calculation time.
| Identifer | oai:union.ndltd.org:theses.fr/2015MONTS131 |
| Date | 14 December 2015 |
| Creators | Mokni, Abderrahman |
| Contributors | Montpellier, Huchard, Marianne |
| Source Sets | Dépôt national des thèses électroniques françaises |
| Language | English |
| Detected Language | French |
| Type | Electronic Thesis or Dissertation, Text |
Page generated in 0.0072 seconds