Interface et transparence

L’informatique fut d’abord réservée aux informaticiens, aujourd’hui elle se met à la disposition du grand public ; de cette mutation on pourrait croire que le public a progressé « en informatique » : nous pensons qu’il n’en est rien. Ce n’est pas le public qui a progressé, mais l’ingénierie de l’interface, permettant à l’utilisateur d’utiliser des instruments d’une façon relativement intuitive, assez proche de notre univers naturel.

La complexité de l’informatique n’a pas diminué ; bien pire, elle augmente constamment. En revanche, parallèlement à cette complication exponentielle, l’on conçoit des interfaces de plus en plus simples. On aurait tort d’isoler ces deux phénomènes l’un de l’autre ; quels peuvent être les effets de la simplification des interfaces sur la conception des logiciels ?

Interface et duperie

Le développement des interfaces, d’abord négligé par les informaticiens, occupe aujourd’hui une place centrale dans l’industrie informatique, et ce à différentes échelles :

  1. à l’échelle des relais d’information (sites sur la Toile d’Araignée Mondiale, flux RSS, etc.) ;
  2. à l’échelle des logiciels et systèmes d’exploitation ;
  3. à l’échelle de la programmation, sous forme de « sucre syntaxique » et d’ergonomie des langages de programmation, ou encore d’environnements de développement.

Nous allons étudier successivement chacun de ces domaines, pour voir la place qu’y occupe la conception d’interfaces et ce qu’elle rend possible.

Interface des relais d’informations

L’information est un fait brut, que l’on peut généralement diffuser au moyen de simples textes, parfois également d’images, de son ou de vidéo. Il suffit pour cela d’avoir :

  1. des fichiers contenant, sous quelque format que ce soit, ces informations ;
  2. des protocoles réseau permettant la transmission de ces fichiers.

Les fichiers peuvent être en texte brut ou des fichiers tapés au moyen d’un traitement de texte dans un format binaire, des fichiers audio codés dans un format compressé ou non, des images compressées ou non, etc. Peu importe le format de ces fichiers, la seule chose qui compte est le fait qu’ils rassemblent des informations en entités uniques, identifiables par un nom unique.

Les protocoles peuvent également être très variés : protocole HTTP, FTP, SSH ou autre, peu importe ; qu’ils reposent sur UDP ou TCP, peu importe ; qu’ils utilisent le protocole Internet (IP) ou un autre, peu importe également : ce qui compte est simplement qu’ils utilisent un réseau permettant de relier deux hôtes, d’une façon ou d’une autre. À ce titre, le pigeon voyageur est un réseau comme un autre, permettant de faire transiter des informations, ce qui a pu donner lieu, le 1er avril 1990, à la norme RFC 1149 de procotole Internet sur pigeon voyageur - ce qui, au-delà du canular, est théoriquement possible.

Théoriquement, l’information, sous quelque forme qu’elle se présente et par quelque moyen qu’elle transite, peut être transmise sous forme brute. En pratique, cela a été vrai à une époque, et l’est encore avec certains protocoles (en particulier FTP), mais la grande majorité des informations transite actuellement sous une forme non brute. Quelle est cette forme ?

Cette forme non brute aujourd’hui majoritairement employée pour le transfert d’informations, on l’appelle la Toile d’Araignée Mondiale (traduction académique de l’anglais WorldWide Web) ; c’est sous ce nom qu’a été popularisé le protocole HTTP. Sa popularité est telle que beaucoup de personnes identifient Internet, voire la notion de réseau en général, à la seule Toile d’Araignée, qui n’en est pourtant qu’une petite partie. Pourquoi une telle confusion ? Parce que le public est comme le Thomas de l’Évangile : il ne croit qu’à ce qu’il voit. Aller sur Internet, ce n’est pas ouvrir un navigateur qui utilise le protocole IP pour se relier à un hôte par connexion TCP et recevoir des fichiers en suivant le protocole HTTP : c’est cliquer sur une icône et « aller sur le site de... ».

Aussi l’ingénierie de l’interface a-t-elle su prendre en compte ces confusions et les intégrer à son cahier des charges, en maintenant l’illusion autant qu’il est possible. C’est pourquoi le public a l’impression de « progresser en informatique », sans voir que c’est l’ingénierie de l’interface qui vient vers lui, et qu’il n’a qu’à la laisser venir à lui. Le public n’en sait pas plus sur le fonctionnement des ordinateurs en 2005 qu’il n’en savait en 1980 ; mais les outils sont devenus plus accessibles en se rapprochant de son monde naturel, et en le transposant dans le domaine de l’interface. Joli dispositif de flagornerie, qui masque ses propres progrès pour donner à l’utilisateur l’illusion que c’est lui qui progresse.

Aux débuts de la Toile d’Araignée Mondiale, le langage HTML simple suffisait à transférer des informations, lorsque l’on voulait que celles-ci puissent pointer vers d’autres informations ; en cela le langage HTML était une révolution, car les informations n’étaient plus isolées entre elles comme elles l’étaient avec des fichiers indépendants les uns des autres, mais au contraire, au moyen des liens hypertexte, elles pouvaient être reliées entre elles. C’est ainsi que les informations ont pu former un véritable réseau, aussi cohérent qu’une « toile d’araignée ». On aurait pu s’en tenir là, mais l’efficacité ne suffit pas : pour gagner du public il faut de l’ergonomie.

C’est ainsi que se sont développées des techniques de présentation aboutissant aux cadres (frames) et aux feuilles de style (en particulier, actuellement, avec le langage CSS). La présence du contenu ne suffit plus : il faut qu’il soit bien présenté. Pourquoi cette exigence de belle présentation ? Là encore, parce que le public est resté dans l’idée d’un transposition du monde naturel en informatique : de même que l’on s’attend à ce qu’un bon morceau de viande ait l’air appétissant, une page mal présentée ne contient probablement pas de bonnes informations. Ce raisonnement est une aberration pour l’informaticien, mais c’est bien celui que conforte l’ingénierie de l’interface.

Interface logicielle

Avec le MS-DOS, pour copier un fichier, on tapait :

copy fichier repertoire

Sous Unix et ses dérivés (Linux, BSD, etc.), on tape :

cp fichier repertoire

Avec les interfaces graphiques modernes (KDE, Gnome ou les interfaces intégrées de MacOS ou Microsoft Windows), on peut se passer de ligne de commande pour déplacer un fichier, et croire en savoir autant ; ce faisant on se laisse duper par l’interface, car on n’a pas appris à déplacer un fichier, mais simplement selon quelles procédures et dans quelles limites le monde naturel avait été transposé en informatique, en l’occurrence dans la modification de systèmes de fichiers. Les interfaces se développant, le fonctionnement réel des ordinateurs devient de plus en plus opaque.

Si je veux déplacer un fichier, entité relativement abstraite, de tel répertoire à tel autre, je clique sur une image représentant ce fichier, et tout en maintenant appuyé le bouton de la souris, je déplace le curseur vers un autre « coin » de mon écran, où je lâche le bouton de ma souris. Le fichier, pour moi, a été déplacé. La procédure me paraît simple, en réalité elle est assez complexe, car là où je ne vois que des déplacements de souris, le système d’exploitation voit des modifications de système de fichier, des appels systèmes, etc. De tout cela, je n’ai aucun retour, par conséquent aucune connaissance ; ou plutôt je n’ai pas besoin d’en avoir connaissance.

Cette opacité s’accompagne donc d’une illusion de transparence, car à mesure que le fonctionnement réel nous est caché par les interfaces, celles-ci nous donnent l’impression de nous y donner un accès de plus en plus facile. En même temps qu’elles nous le cachent, les interfaces nous donnent donc un nouvel accès au fonctionnement de l’ordinateur, et ce nouvel accès est calqué sur le monde naturel. Sorte de pharmakon : médicament et poison à la fois.

Interface de programmation

On pourrait croire dégager de ce qui précède une partition des utilisateurs de l’informatique en deux groupes : ceux qui savent, et ceux qui croient savoir. Ce serait une partition bien simpliste, et il est bien plus vraisemblable que tous les utilisateurs d’informatique soient à ranger dans la catégorie de ceux qui croient simplement savoir - quoique à des degrés divers.

Il n’est en effet aucunement garanti que les programmeurs soient préservés de cette duperie généralisée. Et ils sont dupes, sans doute, de trois façons :

  1. au quotidien, ils sont des utilisateurs comme les autres, et se laissent duper comme tout autre individu par les interfaces qui s’offrent à lui, en plaquant inconsciemment et aveuglément des représentations et des préjugés issus du monde naturel ;
  2. tandis qu’il programme, l’illusion de maîtrise et d’intelligence lui masque l’opacité des outils qu’il utilise, en particulier des compilateurs, interpréteurs, débugueurs et environnements de développement ;
  3. quoique dupe, il se berne de l’idée de ne pas être dupe : à ce titre il est sans doute dupe parmi les dupes, ou dupe au carré, car il est dupe d’un dispositif qui le persuade qu’il n’est pas dupe.

Prenons un exemple caractéristique, celui du programmeur dupe de son compilateur, exemple que nous avons déjà developpé ailleurs, dans l’article « Qu’est-ce qu’un langage de programmation ? ». Dans sa conférence « Reflections on Trusting Trust », Ken Thompson, créateur d’UNIX avec Dennis Ritchie, avoue avoir écrit un compilateur qui, s’il reconnaissait que le code compilé était tel programme dont l’intérêt est central pour la sécurité, y ouvrait une porte dérobée (backdoor) lui permettant de se connecter en usurpant l’identité de n’importe quel utilisateur. Pire encore : si le compilateur repérait que l’utilisateur était en train de compiler un nouveau compilateur, il y reproduisait le générateur de portes dérobées.

Par conséquent, un programmeur écrivant son programme en langage C, langage relativement proche de la machine, peut se croire maître de ce qu’il compose : en réalité il est à la merci des concepteurs de son compilateur. De même, le programmeur en assembleur, langage plus proche encore de la machine, est à la merci de son compilateur ; et celui qui code directement en langage binaire est à son tour dupe des circuits imprimés et de la conception de son processeur. Sans compter sur les erreurs involontaires, qui sont également possibles : en supposant que l’on conçoive soi-même un processeur et des compilateurs, il faudrait avoir un génie bien extraordinaire pour ne pas commettre la moindre erreur susceptible de causer des dysfonctionnements dans des programmes ultérieurs.

On appelle « sucre syntaxique », selon l’expression de Peter J. Landin, les caractéristiques d’un langage informatique destinées à simplifier son utilisation. Par exemple, au lieu d’écrire la formule :

n = n + 1 ;

qui est extrêmement fréquente dans de nombreux langages de programmation (donc le C, le C++, Java, etc), on autorise souvent le raccourci suivant :

n++ ;

La généralisation de ce type de procédés décroche le programmeur du fonctionnement réel de l’ordinateur, en lui donnant à manipuler des notions de plus en plus proches de l’univers naturel ; à ce titre, la programmation orientée objet et la programmation orientée aspect atteignent des sommets. C’est cette duperie qui rend possible la conception de programmes complexes et évolués, car elle évite au programmeur bien des détours et des répétitions ; mais elle l’amène aussi à « oublier » la fragilité de son support, qu’il ne mesure pas, sinon empiriquement.

La duperie n’est donc pas évitable : elle est même la norme, car les réalités informatiques sont complexes et imbriquées, et que sans interface elles sont inutilisables. La duperie corrélative à l’interface, à défaut d’être un bien, est donc au moins un moindre mal.

Duperie et confiance

Nous avons identifié la corrélativité entre la conception d’interface et la duperie qui l’accompagne inévitablement. Mais sans doute faut-il aller plus loin encore, en se demandant si le constat de cette inéluctable dispositif de duperie ne peut pas amener à des effets pervers, c’est-à-dire s’il n’est pas possible d’abuser de cette duperie. On pourrait ainsi, au sein de cette duperie fondamentale et fatale, distinguer plusieurs niveaux.

Une fois que l’ingénierie de l’interface a constaté qu’une information bien présentée est plus attirante qu’une information vraie, elle dispose des moyens de contrôler l’attrait, partant d’en abuser. Par exemple, lorsque vous voulez télécharger un logiciel gratuit, le seul moyen dont vous disposez pour savoir s’il est fiable ou non, c’est la présentation de la page qui le propose. Si cette page est bien présentée, vous aurez plus confiance que si elle a été conçue à la va-vite, et vous le téléchargerez peut-être.

Deux exemples historiques illustrent bien ce comportement : les logiciels espions apportés par le logiciel Kazaa et le virus I love you. Le logiciel Kazaa a été très populaire à une époque ; il était gratuit et téléchargeable librement, ce qui contribua à sa popularité. Mais lors de l’installation, il installe à l’insu de l’utilisateur des « logiciels espions » (spyware) qui sont exécutés sans prévenir l’utilisateur et enregistrent des informations sur lui, puis les transmettent à des entreprises intéressées. Pourtant, Kazaa a gardé sa popularité, parce qu’il était facile à utiliser et que la majorité de ses utilisateurs ignorait la présence de ces logiciels espions. Quant au virus I love you, il se présentait sous forme d’un faux fichier texte (en réalité un fichier d’extension .txt.vbs, qui avec le logiciel Microsoft Outlook paraissait simplement porter l’extension inoffensive .txt), et se révéla particulièrement ravageur. Là encore, il jouait sur la duperie liée à l’interface pour en abuser.

Ces exemples mettent au jour une notion corrélative à celle de duperie : la confiance. L’utilisateur est nécessairement dupe, mais s’il veut avoir accès à des outils informatiques, il ne peut dépasser cette duperie : il lui faut faire confiance. Et lorsqu’il appuie cette confiance sur la seule présentation, sur la seule interface des outils informatiques, il est possible d’en abuser, c’est-à-dire de tromper sa confiance au moyen d’une interface séduisante.

La confiance repose sur la duperie : là où toute certitude est impossible, seul un rapport social de confiance peut se substituer à la certitude ; c’est parce qu’il y a cette inévitable duperie liée à l’interface que la confiance doit intervenir. Inversement, la duperie repose sur la confiance : ce n’est que parce qu’il y a un rapport de confiance que la duperie est possible ; aussi dans cette duperie peut-on distinguer deux niveaux : une duperie fondamentale, inévitable et nécessaire, liée à l’interface ; et une duperie contingente et malveillante, liée à l’abus de confiance ; à l’articulation de ces deux duperies se trouve la confiance.

Confiance et transparence

Nous avons déjà développé ailleurs pourquoi la publicité du code source pouvait être un gage de fiabilité du logiciel, dans l’article « Peut-on se fier aux logiciels libres ? » ; nous nous contenterons ici d’en reprendre les grandes lignes. Pour de plus amples développements, illustrés par des exemples, reportez-vous à cet article.

Le rapport entre l’utilisateur et les ressources informatiques est médié par des interfaces, et par conséquent repose sur une duperie librement consentie. Librement consentie, cette duperie devient confiance. Toutefois, la possibilité d’abuser de ce dispositif de confiance mène à une nouvelle duperie, qui n’est en quelque sorte que l’actualisation de ce que la première rendait possible.

Ce qui facilite cette seconde duperie, abus de la première, c’est le fait que l’utilisateur ne sache pas comment sont véritabelemnt conçus les outils qu’il utilise. S’il avait su comment le virus I love you était conçu, il l’aurait effacé sans le laisser agir. L’opacité est un milieu qui favorise les abus. À l’inverse, si le code source des programmes est public, et de tous les programmes que l’on utilise (système d’exploitation, serveurs, logiciels, compilateurs, etc.) sont libres (c’est-à-dire que leur code source n’est pas caché), l’opacité est réduite, et la confiance trouve un nouveau fondement : la transparence.

De fait, l’immense majorité des utilisateurs de logiciels n’ira pas consulter le code source ; de droit elle sait qu’elle en a le pouvoir, et que certains le font. Ainsi, un logiciel libre qui tenterait d’abuser de la confiance des utilisateurs se tirerait une balle dans le pied en publiant la recette de son poison et en s’en avouant le concepteur.

Conclusion

On ne peut pas réduire sur la duperie fondamentale, qui est nécessaire, et indissociable de l’existence des interfaces ; la confiance doit suppléer une impossible certitude absolue. Mais la liberté du logiciel permet d’éviter l’emballement de la duperie en duperie généralisée.

Le logiciel libre donne pour garant de la confiance qu’on lui prête un autre lien social : la transparence.

Haut de page