Reconciling positional and nominal binding

We define an extension of the simply-typed lambda calculus where two different binding mechanisms, by position and by name, nicely coexist. In the former, as in standard lambda calculus, the matching between parameter and argument is done on a positional basis, hence alpha-equivalence holds, whereas in the latter it is done on a nominal basis. The two mechanisms also respectively correspond to static binding, where the existence and type compatibility of the argument are checked at compile-time, and dynamic binding, where they are checked at run-time.Comment: In Proceedings ITRS 2012, arXiv:1307.784

Intersection types for unbind and rebind

We define a type system with intersection types for an extension of lambda-calculus with unbind and rebind operators. In this calculus, a term with free variables, representing open code, can be packed into an "unbound" term, and passed around as a value. In order to execute inside code, an unbound term should be explicitly rebound at the point where it is used. Unbinding and rebinding are hierarchical, that is, the term can contain arbitrarily nested unbound terms, whose inside code can only be executed after a sequence of rebinds has been applied. Correspondingly, types are decorated with levels, and a term has type decorated with k if it needs k rebinds in order to reduce to a value. With intersection types we model the fact that a term can be used differently in contexts providing different numbers of unbinds. In particular, top-level terms, that is, terms not requiring unbinds to reduce to values, should have a value type, that is, an intersection type where at least one element has level 0. With the proposed intersection type system we get soundness under the call-by-value strategy, an issue which was not resolved by previous type systems.Comment: In Proceedings ITRS 2010, arXiv:1101.410

Acute: high-level programming language design for distributed computation

Existing languages provide good support for typeful programming of standalone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper we discuss programming language support for such systems, focussing on their typing and naming issues. We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. The main features are: (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type-safety of associated values, e.g. values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility. These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language runtime from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries

Constrained Polymorphic Types for a Calculus with Name Variables

We extend the simply-typed lambda-calculus with a mechanism for dynamic rebinding of code based on parametric nominal interfaces. That is, we introduce values which represent single fragments, or families of named fragments, of open code, where free variables are associated with names which do not obey alpha-equivalence. In this way, code fragments can be passed as function arguments and manipulated, through their nominal interface, by operators such as rebinding, overriding and renaming. Moreover, by using name variables, it is possible to write terms which are parametric in their nominal interface and/or in the way it is adapted, greatly enhancing expressivity. However, in order to prevent conflicts when instantiating name variables, the name-polymorphic types of such terms need to be equipped with simple {inequality} constraints. We show soundness of the type system

Dynamic Rebinding for Marshalling and Update, with Destruct-Time λ

Most programming languages adopt static binding, but for distributed programming an exclusive reliance on static binding is too restrictive: dynamic binding is required in various guises, for example when a marshalled value is received from the network, containing identifiers that must be rebound to local resources. Typically it is provided only by ad-hoc mechanisms that lack clean semantics. In thi

Dynamic Rebinding for Marshalling and Update, with Destruct-time λ

Most programming languages adopt static binding, but for distributed programming an exclusive reliance on static binding is too restrictive: dynamic binding is required in various guises, for example when a marshalled value is received from the network, containing identifiers that must be rebound to local resources. Typically it is provided only by ad-hoc mechanisms that lack clean semantics

Du génie logiciel pour déployer, gérer et reconfigurer les logiciels

As a discipline, software engineering embraces various schools of thought, yet remains consistent with respect to its objective. It aims at providing means for effective and inexpensive production of software by contributing mathematical frameworks, methods and tools. Consequently, we witness some automation in software production process that, as of today, allows producing astronomical amounts of lines of code daily. This rapidly and massively produced software is required for all computer equipment that has invaded our daily life in various forms of other devices (PC, tablet, phone, refrigerator, car, etc.). In this world of large software consumption, it is somewhat surprising that the management of software, after its production, remains dominated by manual practices like searching in lists, downloading units and manual installations. In this context, I organized my research activities such that they aim at providing mathematical frameworks, methods and tools to deploy, distribute or update massive amounts of software since 2001, the year of my PhD defense. These research activities were mainly conducted in Brest at the CS department of Telecom Bretagne as part of the PASS team of IRISA. This document puts into perspective my various scientific contributions, undertaken projects, endeavors in training research students and efforts invested as a teacher. My scientific contributions can be divided into five parts: mathematical models and algorithms for dependency management in software deployment; software component models; processes and tools for massive software deployment; dynamic update of programs at runtime; languages for the design and implementation of software development processes. All these works complement each other, thus making it possible to imagine the proposition of methods and tools for large-scale software deployment.Le génie logiciel est une discipline constituée de nombreux courants mais cohérente par l'objectif affiché. Il s'agit d'aider à la production, de manière efficace et peu coûteuse, de logiciels en offrant des cadres mathématiques, des méthodes et des outils. Ainsi, on a pu assister à une certaine industrialisation du processus de production de logiciel qui permet aujourd'hui de produire, chaque jour, des quantités astronomiques de logiciel. Ce logiciel produit rapidement et en grande quantité est nécessaire pour tous les équipements informatiques qui ont envahi notre quotidien (ordinateur, tablette, téléphone, réfrigérateur, voiture, ...). Dans ce monde de grande consommation du logiciel, il est cependant surprenant de constater que la gestion des logiciels après leur production est resté dominé par des pratiques manuelles de recherche dans des listes, de téléchargement unitaire et d'installation manuelle. C'est dans ce cadre que j'ai développé une activité de recherche visant à fournir des cadres mathématiques, des méthodes et des outils pour déployer, diffuser ou mettre à jour massivement les logiciels depuis 2001 année de ma soutenance de thèse. Ces activités de recherche ont été conduites principalement à Brest au sein du département informatique de Télécom Bretagne dans le cadre de l'équipe PASS de l'IRISA. Mon Habilitation à Diriger des Recherches est l'occasion de remettre en perspective mes différentes contributions scientifiques, les étudiants formés à la recherche, les projets réalisés ainsi que mon investissement en tant qu'enseignant. Les contributions scientifiques peuvent être classées en cinq parties : - des modèles mathématiques et les algorithmes associés pour la gestion des dépendances de logiciels lors de leur déploiement ; - les modèles de composants logiciels ; - les processus et outils pour le déploiement de logiciel massif ; - la mise à jour de programmes sans interrompre leur exécution ; - des langages pour la conception et la réalisation de processus de développement logiciel. Tous ces travaux qui se nourrissent et se complètent permettent d'imaginer la proposition de méthodes et outils pour passer à l'échelle dans la gestion du déploiement des logiciels