Conception et mise en oeuvre d'un langage réflexif de modélisation et programmation par composants

• Main Author: Spacek, Petr
• Other Authors: Montpellier 2
• Language: en
• Published: 2013
• Subjects: Langage; Réflexif; Programmation; Composants; Héritage; Reflective; Component; Language; Programming; Inheritance
• Online Access: http://www.theses.fr/2013MON20156/document

L'ingénierie des logiciels à base de composants, produisant du logiciel en assemblant des composants sur « étagère » et « prêts-a-l’usage », promet la réduction des coûts au cours du développement, la maintenance et l'évolution d'un logiciel. La période récente a vu la production d'un ensemble très important de nouveaux résultats dans ce domaine. Comme le terme «composant» a un sens assez général, cet ensemble englobe de nombreuses recherches ayant des objectifs différents et offrant divers types d'abstractions et mécanismes. Cependant, une idée générale communément admise consiste a modéliser les logiciels avec des composants organisés en architectures, puis générer du code a partir de ces descriptions abstraites. Ceci est une bonne idée, mais la question qui se pose consiste a savoir quel langage est le meilleur candidat pour le code généré. Dans la pratique actuelle, la phase de conception se déroule dans le monde des composants alors que la phase de programmation se produit dans le monde des objets. Il semble aussi que les langages et technologies utilisés dans le développement a base de composants ne sont que partiellement à base de composants.Notre première revendication consiste à dire qu'il est important d'utiliser les langages à composants pour écrire du code exécutable, simplement parce que les artefacts à base de composants d'origine (comme, les besoins ou les architectures) ne disparaissent pas au moment de l'exécution, rendant les programmes plus compréhensibles et réversibles. En faisant cela, il est alors possible d'imaginer que la conception (modélisation) et la programmation peuvent être effectuées au même niveau conceptuel et pourquoi pas en utilisant le même langage. Généralement, les objets sont presque toujours choisis pour implémenter les conceptions à base de composants. Par ailleurs, il est vrai que c'est sans surprise les objets qui sont utilisés pour implémenter des conceptions à base de composants ; un objet étant certainement l'entité exécutable la plus proche d'un composant tel que c'est compris aujourd'hui. Par contre, ils sont proches mais il ne sont pas exactement les mêmes. Notre deuxième revendication est qu'il est possible d'atteindre des langages de programmation par composants en apportant des modifications souples aux langages à objets.Suivant ces idées, nous présentons dans cette thèse un exemple d'un nouveau langage pur de modélisation et de programmation par composants, nommé Compo intégrant d'une manière simple et uniforme, les concepts de base pour la description et l'implémentation des composants et des architectures à composants: composants, ports, services et connexions, et les mécanismes nécessaires suivants: l'instanciation, l'invocation de service, la composition et la substitution. Nous soutenons également que la description des composants, leurs architectures (structures) et leurs services (comportement) gagneraient (comme le font les descriptions d'objets) à utiliser des descriptions différentielles qui se basent sur un mécanisme d'héritage. En conséquence, nous proposons une spécification et une implémentation d'un système d'héritage en prenant en compte une politique de spécialisation covariante et un mécanisme de substitution dédié. Nous affirmons enfin que faire un tel langage totalement réflexif ouvrira une nouvelle alternative intéressante (dans le contexte des composants) pour n'importe quel genre de modèle ou de programme de vérification ou de transformation d'architecture. Nous revisitons quelques solutions standards pour obtenir une réification à composants originale pour construire un méta-modèle exécutable conçu sur l'idée du «tout est un composant». Une implémentation complète du prototype du langage Compo a été réalisée et est décrite dans cette thèse. === Component-based Software Engineering (CBSE), to produce software by connecting of the shelf ready-to-use components, promises costs reduction during the development, the maintenance and the evolution of a software.The recent period has seen the production of a very important set of new results in this field.As the term "component" is very general, it encompasses many researches having different objectives and offering various kind of abstractions and mechanisms.However one main overall accepted idea is to model software with components organized into architectures and to generate code from such abstract descriptions.This is a good idea but the question arise to know which languages are good candidate for the generated code.In the current practice the design phase happens in the component world and the programming phase occurs in the object-oriented world.It appears that languages and technologies used to achieve component-based development are only partially component-based.Our first claim is that to use component-based languages to write the executable code is primarily important just because the original component-based designs (eg requirements, architectures) do not vanish at run-time, making programs more understandable and reversible. By doing this, it is then possible to imagine that design (modeling) and programming can be done at the same conceptual level and why not using the same language.Usually, objects are most always chosen to implements component-based designs.It is true that an object is certainly the existing executable thing the closest to a component as they are understood today; close but not exactly the same.Our second claim is then that it is possible to achieve component-programming languages by smoothly modifying object-oriented ones.Following these ideas, we present in this thesis an example of a new pure component-based programming and modeling language, named Compo incorporating, in a simple and uniform way, core concepts and mechanisms necessary for the description and implementation of components and of component-based architectures: component, port, service, connection and the following mechanisms: instantiation, service invocation, composition and substitution.We also claim that describing components, their architectures (structures) and their services (behavior) would benefit (as objects descriptions do) from an inheritance-based differential description.In consequence we propose a specification and implementation of an inheritance system taking requirements into account on a covariant specialization policy base and with a corresponding dedicated substitution mechanism.We finally claim that making such a language fully reflective will open an interesting new alternative (in the component's context) for any king of model or program checking or transformation.We revisit some standard solutions to achieve an original component-oriented reification of concepts to build up an executable meta-model designed on the idea of "everything is a component".A complete prototype implementation of the Compo language has been achieved and is described in this thesis.