From Decoupling to Unanticipated Component Assembly:
Design and Implementation of the Component-Oriented Language Scl
Du découpage à l'assemblage non anticipé de composants :
Conception et mise en oeuvre du langage à composants Scl
Résumé
Component-based software development (CBSD) promises costs reduction during the development, the maintenance and the evolution of a software. Currently, a lot of propositions claim to be "component-oriented" but they generally differ in several points like their objectives, their abstractions and their mecanisms. Moreover, it is difficult to use CBSD in practice because of the lack of semantically founded and really usable component-oriented languages (COL). In this context, we address the folowing problematics: What is a COL? What are the advantages of those languages? How to realise a COL?
This work purposes the programming language Scl to enable component-oriented programming (COP) in practice. Scl has been built to be: (i) miminal because all its abstractions and mechanisms respond to an identified need; (ii) simple because these abstractions and mechanisms are of a high-level; (iii) detailled because during the cocneption of Scl we study a lot of crucial points usually forgotten by other propositions such as self-references, arguments passing based on connections or considering base components (collections, integer, etc) in a unified world; (iv) dedicated to COP because it integrates the two key points that we identified: decoupling and unanticpation.
The core of Scl is built upon the following concepts: component, port, service, connector, glue code and the following mechanisms: port binding, service invocation. We also study the separation of concerns in the source code. In this area, Scl improves the "symmetric" aspect-oriented approaches and enables the use of a component as a regular component or a crosscutting component. Deeper in the separation of concerns, Scl also enables component connections based on state changes of their properties. Component programmers do not have to write special code in order to enable this kind of connections. Two prototypes of Scl are available. The more advanced one is written in Smalltalk and the other has been started in Ruby.
This work purposes the programming language Scl to enable component-oriented programming (COP) in practice. Scl has been built to be: (i) miminal because all its abstractions and mechanisms respond to an identified need; (ii) simple because these abstractions and mechanisms are of a high-level; (iii) detailled because during the cocneption of Scl we study a lot of crucial points usually forgotten by other propositions such as self-references, arguments passing based on connections or considering base components (collections, integer, etc) in a unified world; (iv) dedicated to COP because it integrates the two key points that we identified: decoupling and unanticpation.
The core of Scl is built upon the following concepts: component, port, service, connector, glue code and the following mechanisms: port binding, service invocation. We also study the separation of concerns in the source code. In this area, Scl improves the "symmetric" aspect-oriented approaches and enables the use of a component as a regular component or a crosscutting component. Deeper in the separation of concerns, Scl also enables component connections based on state changes of their properties. Component programmers do not have to write special code in order to enable this kind of connections. Two prototypes of Scl are available. The more advanced one is written in Smalltalk and the other has been started in Ruby.
Les composants logiciels sont des entités logicielles réutilisables promettant une réduction des coûts liés au développement, à la maintenance et à l'évolution d'un logiciel. Actuellement, de nombreuses propositions se réclament du mode de développement par assemblage de composants logiciels. Malgré un vocabulaire parfois commun (composant, port, interface, service, connexion, connecteur), ces propositions sont disparates de par leurs origines, leurs objectifs, leurs concepts ou encore leurs mécanismes. De plus, elles restent difficiles à utiliser en pratique par manque de véritables langages de programmation sémantiquement fondés et concrètement utilisables. Devant tant de profusion, nous nous intéressons, dans cette thèse, aux problématiques suivantes: qu'est-ce qu'un langage à composants? Quels sont les avantages de ces langages? Comment réaliser un langage à composants?
Cette thèse propose donc Scl, un langage de programmation à composants permettant de mettre en pratique réellement la programmation par composants (PPC). De par sa conception, Scl se veut être un langage : (i) minimal dans le sens où toutes les abstractions et tous les mécanismes qui lui sont intégrés répondent à un besoin identifié ; (ii) simple car ses abstractions et ses mécanismes sont de haut niveau ; (iii) détaillé car nous avons abordé un ensemble de questions souvent oubliées dans les autres propositions comme l'auto-référence, le passage d'arguments ou le statut des composants de base (collections, entiers, etc) dans un monde unifié ; (iv) dédié à la PPC, car prenant en compte les deux préoccupations que nous jugeons majeures en PPC et qui sous-tendent toute l'étude: le découplage et la non-anticipation.
Le coeur de Scl repose principalement sur les concepts de composant, de port, de service, de connecteur et de « code glue » ainsi que sur les mécanismes de liaison de ports et d'invocation de service. La séparation des préoccupations au niveau du code occupe une part importante de l'étude qui établit un lien entre la programmation par composants et la programmation par aspects (PPA). Scl propose dans ce cadre une amélioration des approches dites « symétriques » de la PPA, via une unification des concepts d'aspect et de composant et via un ensemble de différents types de liaisons de ports qui permettent d'utiliser un même composant de façon standard ou de façon transversale. Scl intègre aussi un mécanisme général permettant d'établir des connexions entre composants basées sur les changements d'états de leurs propriétés sans que leurs programmeurs n'aient à écrire une ligne de code spécifique à cet effet. Deux prototypes de Scl sont également présentés, le premier et le plus abouti est écrit en Smalltalk et le second en Ruby.
Cette thèse propose donc Scl, un langage de programmation à composants permettant de mettre en pratique réellement la programmation par composants (PPC). De par sa conception, Scl se veut être un langage : (i) minimal dans le sens où toutes les abstractions et tous les mécanismes qui lui sont intégrés répondent à un besoin identifié ; (ii) simple car ses abstractions et ses mécanismes sont de haut niveau ; (iii) détaillé car nous avons abordé un ensemble de questions souvent oubliées dans les autres propositions comme l'auto-référence, le passage d'arguments ou le statut des composants de base (collections, entiers, etc) dans un monde unifié ; (iv) dédié à la PPC, car prenant en compte les deux préoccupations que nous jugeons majeures en PPC et qui sous-tendent toute l'étude: le découplage et la non-anticipation.
Le coeur de Scl repose principalement sur les concepts de composant, de port, de service, de connecteur et de « code glue » ainsi que sur les mécanismes de liaison de ports et d'invocation de service. La séparation des préoccupations au niveau du code occupe une part importante de l'étude qui établit un lien entre la programmation par composants et la programmation par aspects (PPA). Scl propose dans ce cadre une amélioration des approches dites « symétriques » de la PPA, via une unification des concepts d'aspect et de composant et via un ensemble de différents types de liaisons de ports qui permettent d'utiliser un même composant de façon standard ou de façon transversale. Scl intègre aussi un mécanisme général permettant d'établir des connexions entre composants basées sur les changements d'états de leurs propriétés sans que leurs programmeurs n'aient à écrire une ligne de code spécifique à cet effet. Deux prototypes de Scl sont également présentés, le premier et le plus abouti est écrit en Smalltalk et le second en Ruby.
Fichier principal
these-lfabresse.pdf (3.6 Mo)
Télécharger le fichier
soutenance-lfabresse.pdf (1.71 Mo)
Télécharger le fichier
Format : Autre