! ! !"#$%&'(&)'*+,-"+"&.(.$/&'/0'('1"0-"2.$3"'4/+,/&"&.567$"&.")' 87/%7(++$&%'(&)'9/)"-$&%':(&%;(%"' <=' 8".7'>8?4@A' ACADÉMIE DE MONTPELLIER U NIVERSITÉ M ONTPELLIER II — SCIENCES ET TECHNIQUES DU LANGUEDOC — THÈSE présentée au Laboratoire d’Informatique de Robotique et de Microélectronique de Montpellier pour obtenir le diplôme de doctorat SPÉCIALITÉ : INFORMATIQUE Formation Doctorale : Informatique École Doctorale : Information, Structures, Systèmes Design and Implementation of a Reflective Component-Oriented Programming and Modeling Language par Petr SPACEK Soutenue le 17 decembre 2013 at ??h, devant le jury composé de : Lionel SEINTURIER, Professeur, Inria, University Lille 1, France . Rapporteur Ivica CRNKOVIC, Professeur, IDT, Mälardalen University, Sweden, . Rapporteur Pierre COINTE, Professeur, LINA, Université de Nantes, France . Examinateur Roland DUCOURNAU, Professeur, LIRMM, Université Montpellier II, France . Président Christophe DONY, Professeur, LIRMM, Université Montpellier II, France . Directeur de Thèse Chouki TIBERMACINE, Associer Professeur, LIRMM, Université Montpellier II, France . Co-Directeur de Thèse Version of October 27, 2013 Contents Contents iii Acknowledgement vii Abstract ix Résumé xi 1 Introduction 1 1.1 Context: Component-based Software Engineering ...................... 2 1.2 Limitations of the Existing Approaches ............................. 4 1.3 SCL, the predecessor of our work ................................ 7 1.4 The problematic of the thesis .................................. 8 1.5 Characteristics of the contribution ............................... 11 1.6 Structure of the thesis ....................................... 12 2 Component Models and their Implementations 15 2.1 Advantages and promises of the component-based approach . 16 2.1.1 Reuse ............................................ 16 2.1.2 Distribution ........................................ 19 2.1.3 Explicitness ........................................ 21 2.2 Presentation of the main Component-based approaches . 21 2.2.1 Families of the component-based approaches ................... 21 2.2.2 Frameworks family .................................... 23 2.2.3 Generative family ..................................... 43 2.2.4 Component-oriented languages family ........................ 52 2.3 Comparison ............................................ 59 2.4 Conclusion ............................................. 65 3COMPO’s basics 67 3.1 The language philosophy ..................................... 68 3.2 Concepts .............................................. 70 3.2.1 Components and Descriptors ............................. 70 3.2.2 Ports ............................................ 77 iii iv Contents 3.2.3 Services .......................................... 85 3.2.4 Connections ........................................ 87 3.3 Mechanisms ............................................ 90 3.3.1 Component instantiation ................................ 90 3.3.2 Service invocation .................................... 92 3.3.3 Composition mechanism ................................ 99 3.3.4 Substitution mechanism ................................ 102 3.4 Recapitulation ........................................... 105 3.4.1 Definitions ........................................ 106 3.4.2 Choices .......................................... 107 3.5 Related work ............................................ 108 3.6 Summary .............................................. 110 4 Integrating inheritance 111 4.1 Introduction: Do we need inheritance? ............................ 112 4.2 Inheritance for structural and behavioral reuse ........................ 118 4.2.1 Multiple inheritance, yes or no? ............................ 119 4.3 Descriptors and basic inheritance ............................... 120 4.3.1 The ExtCalc Example .................................. 120 4.4 Addition & specialization of services .............................. 122 4.4.1 The service lookup mechanism ............................ 123 4.5 Addition & specialization of provided port descriptions ................... 126 4.6 Addition & specialization of external required ports descriptions . 129 4.6.1 The DynamicHTTPServer example .......................... 131 4.7 Extension & specialization of architectures .......................... 134 4.8 Related work ............................................ 136 4.9 Summary .............................................. 139 4.9.1 Definitions made ..................................... 140 4.9.2 Choices made ....................................... 140 5 Integrating reflection 143 5.1 MDE, the motivation for reflection ............................... 144 5.2 Reflection & Reification ...................................... 145 5.3 Requirements for the meta-model architecture ........................ 147 5.4 The meta-model .......................................... 149 5.5 First-class descriptors and components ............................ 151 5.6 First-class ports .......................................... 158 5.7 First-class services ......................................... 163 5.8 Related work ............................................ 171 5.9 Summary .............................................. 173 5.9.1 Definitions made ..................................... 174 5.9.2 Choices made ....................................... 174 6COMPO in Practice 175 Contents v 6.1 Designing an HTTP server .................................... 176 6.2 Designing a collection hierarchy ................................ 180 6.3 Transformation to a bus-oriented architecture ........................ 182 6.4 Verifying architecture constraints ................................ 185 6.4.1 Verifying the bus-oriented architecture ........................ 186 6.4.2 Verifying the Pipe & Filter architecture ........................ 188 6.5 Summary .............................................. 191 7 The prototype 193 7.1 Why Smalltalk? ........................................... 194 7.2 Technology choices ........................................ 194 7.3 Bootstrap Implementation .................................... 195 7.4 The implemented model ..................................... 197 7.5 Services invocation implementation .............................. 199 7.6 Connection mechanism implementation ........................... 201 7.7 Inheritance implementation ................................... 202 7.8 Instantiation mechanism implementation .......................... 203 7.9 Toward a graphical development environment ........................ 204 7.10 Summary .............................................. 205 8 Conclusion 207 A Grammar 211 A.1 Lexan rules ............................................. 211 A.2 Parser rules ............................................. 212 B Usage sources 215 B.1 Collection hierarchy sources ................................... 215 B.2 Constraints sources ........................................ 222 B.2.1 Pipes&Filters ....................................... 222 List of Figures 227 List of Tables 230 List of Listings 231 Bibliography 235 Acknowledgement Saying thank you is more than good manners. It is good spirituality. Alfred PAINTER. It hardly seems possible to me that I have finally reached the end of this long process, and that it only remains to thank the people who have helped me along the way. Even beyond the formal aspects of my education, I have learned much and gained much from the people around me over the last seven years, and I know that I will never be able to truly express my appreciation. I can only say: Thank you! To Christophe and Chouki, I say: Thank you! You have taught me about research, about speaking, and writing, about software architecture, and about life. You have supported me at every stage, from my first arrival here at LIRMM to the final completion of my dissertation. You have supported me when I was coasting along not getting much accomplished and when I was pushing hard to do more than seemed possible. You have helped make my dissertation the best that I can make it. You have been patient with me when I had nothing to give you and responsive when I gave you too much all at once. You have truly gone beyond the call of duty. To the MAREL group, I say: Thank you! You put up with my half-baked ideas and my buggy prototypes and turned them into something real and even useful. Your feedback and your example have enriched my experience as well as my work. To my office mates, past and present, I say: Thank you! You have tolerated my muttering and teasing and aggressive work-avoidance tactics. You have helped me to know that it can be done, and to remember that there is more to computer science than my little corner of it. To my family, and especially to HER (she knows), I say: Thank you! Your support has kept me going when I thought I couldn’t go on. You have kept me in perspective, and helped me keep my priorities straight. You are what makes it all worthwhile. vii Abstract 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