Concevoir et programmer des logiciels malléables

Designing and Programming Malleable Software

• Auteur / Autrice : Philip Tchernavskij
• Direction : Michel Beaudouin-Lafon
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 03/12/2019
• Etablissement(s) : Université Paris-Saclay (ComUE)
• Ecole(s) doctorale(s) : École doctorale Sciences et technologies de l'information et de la communication (Orsay, Essonne ; 2015-....)
• Partenaire(s) de recherche : Laboratoire : Laboratoire de recherche en informatique (Orsay, Essonne ; 1998-2020)
• Partenaire(s) de recherche : établissement opérateur d'inscription : Université Paris-Sud (1970-2019)
• Jury : Président / Présidente : Jean-Daniel Fekete
• Jury : Examinateurs / Examinatrices : Michel Beaudouin-Lafon, Jean-Daniel Fekete, Nicolai Marquardt, Stéphane Conversy, Jutta Treviranus, Myriam Lewkowicz
• Jury : Rapporteurs / Rapporteuses : Nicolai Marquardt, Stéphane Conversy

Mots clés

Mots clés contrôlés

Interfaces utilisateur (informatique)

Logiciels -- Développement

Interaction humain-machine

Mots clés libres

Interaction homme-machine

Modélisation conceptuelle

Ingénierie des systèmes interactifs

Human-computer interaction

Conceptual Modeling

Engineering of interactive systems

Résumé

Les besoins des utilisateurs en matière de fonctionnalités et d'interfaces logicielles sont variés et changeants. Mon objectif est de permettre aux utilisateurs eux-mêmes de facilement modifier ou faire modifier leur logiciel en fonction de l'évolution de leurs besoins. Toutefois, à mon avis, les approches actuelles ne traitent pas cette question de façon adéquate : L'ingénierie logicielle favorise la flexibilité du code mais, dans la pratique, cela n'aide pas les utilisateurs finaux à apporter des changements à leurs logiciels. Les systèmes permettant à l'utilisateur de programmer en direct (“live programming”) ou de modifier le code du logiciel (“end-user programming”) permettent aux utilisateurs de personnaliser les interfaces de leur logiciel en accédant et modifiant le code source. J'adopte une approche différente, qui cherche à maximiser les modifications qui peuvent être faites à travers des interactions habituelles, par exemple la manipulation directe d'éléments d'interface. J'appelle cette approche la malléabilité logicielle. Pour comprendre les besoins des utilisateurs et les obstacles à la modification des logiciels interactifs, j'étudie comment les logiciels actuels sont produits, maintenus, adoptés et appropriés dans un réseau de communautés travaillant avec des données sur la biodiversité. Je montre que le mode de production des logiciels, c'est-à-dire les technologies et les modèles économiques qui les produisent, est biaisé en faveur de systèmes centralisés et uniformisés. Cela m'amène à proposer un programme de recherche interdisciplinaire à long terme pour repenser les outils de développement logiciel afin de créer des infrastructures pour la pluralité. Ces outils peuvent aider de multiples communautés à collaborer sans les forcer à adopter des interfaces ou représentations de données identiques. Le logiciel malléable représente une telle infrastructure, dans laquelle les systèmes interactifs sont des constellations dynamiques d'interfaces, de dispositifs et de programmes construits au moment de leur utilisation. Ma contribution technologique est de recréer des mécanismes de programmation pour concevoir des comportements interactifs. Je généralise les structures de contrôle existantes pour l'interaction en ce que j’appelle des intrications (“entanglements”). J'élabore une structure de contrôle d'ordre supérieur, les intricateurs (“entanglers”), qui produisent ces intrications lorsque des conditions préalables particulières sont remplies. Ces conditions préalables sont appelées co-occurrences. Les intricateurs organisent l'assemblage des interactions dynamiquement en fonction des besoins des composants du système. Je développe ces mécanismes dans Tangler, un prototype d’environnement pour la construction de logiciels interactifs malléables. Je démontre comment Tangler supporte la malléabilité à travers un ensemble de cas d'étude illustrant comment les utilisateurs peuvent modifier les systèmes par eux-mêmes ou avec l'aide d'un programmeur. Cette thèse est un premier pas vers un paradigme de programmation et de conception de logiciels malléables capables de s'adapter à la diversité des usages et des utilisateurs.

User needs for software features and interfaces are diverse and changing, motivating the goal of making it as easy as possible for users themselves to change software, or to have it changed on their behalf in response to their developing needs. However, in my opinion, current approaches do not address this issue adequately: software engineering promotes flexible code, but in practice this does not help end-users effect change in their software. End-user and live programming systems help users customize their interfaces by accessing and modifying the underlying source code. I take a different approach, seeking to maximize the kinds of modifications that can take place through regular interactions, e.g. direct manipulation of interface elements. I call this approach malleable software. To understand contemporary needs for and barriers to modifying software, I study how it is produced, maintained, adopted, and appropriated in a network of communities working with biodiversity data. I find that the mode of software production, i.e. the technologies and economic relations that produce software, is biased towards centralized, one-size-fits-all systems. This leads me to propose a long-term, interdisciplinary research program in reforming the tools of software development to create infrastructures for plurality. These tools should help multiple communities collaborate without forcing them to consolidate around identical interfaces or data representations. Malleable software is one such infrastructure, in which interactive systems are dynamic constellations of interfaces, devices, and programs assembled at the site of use. My technological contribution is a reconstruction of the programming mechanisms used to create interactive behavior. I generalize existing control structures for interaction as entanglements, and develop a higher-order control structure, entanglers, which produces entanglements when particular pre-conditions, called co-occurrences, are met. Entanglers cause interactions to be assembled dynamically as system components come and go. I develop these mechanisms in Tangler, a prototype environment for building malleable interactive software. I demonstrate how Tangler supports malleability through a set of benchmark cases illustrating how users can modify systems by themselves or with programmer assistance. This thesis is an early step towards a paradigm for programming and designing malleable software that can keep up with human diversity.