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 ?
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 :
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.
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 :
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 <a
href="http://www.ietf.org/rfc/rfc1149.txt">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.
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.
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 :
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 <a
href="http://www.acm.org/classics/sep95/">« 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.
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.
Nous avons déjà développé ailleurs pourquoi la publicité du code source
pouvait être un gage de fiabilité du logiciel, dans l’article <a
href="fiabilite-loglibre.html">« 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.
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.