Ken Thompson

Ken Thompson est l’un des programmeurs les plus influents de l’histoire de l’informatique. Aux Bell Labs, il participe à Multics avant de devenir l’un des créateurs d’Unix avec Dennis Ritchie et d’autres chercheurs. Mais son influence va bien au-delà : des expressions régulières et de grep au langage B, à UTF-8 puis à Go, son parcours traverse près de soixante ans d’histoire de l’informatique.

Un même principe relie ces travaux : partir d’un problème concret, construire l’outil nécessaire puis l’améliorer progressivement. Thompson ne cherche pas à concevoir immédiatement des systèmes gigantesques ; il avance par étapes, en veillant à conserver des mécanismes suffisamment simples pour pouvoir évoluer.

Fiche rapide

• Nom : Kenneth Lane Thompson
• Naissance : 4 février 1943
• Lieu de naissance : La Nouvelle-Orléans, Louisiane, États-Unis
• Nationalité : américaine
• Domaine : informatique, systèmes d’exploitation, langages de programmation
• Contributions majeures : Unix, langage B, expressions régulières, grep, Plan 9, UTF-8, Go
• Rôle : chercheur aux Bell Labs, co-créateur d’Unix, puis ingénieur chez Google

De Berkeley aux Bell Labs

Né en 1943, Kenneth Lane Thompson étudie l’électronique à l’université de Californie à Berkeley. C’est là qu’il découvre véritablement les ordinateurs et commence à passer une grande partie de son temps à les programmer. Il profite notamment des heures de nuit, lorsque certaines machines du campus sont disponibles, pour expérimenter librement avec différents systèmes et différents problèmes.

Cette pratique intensive forge son rapport à l’informatique. Thompson aime comprendre ce que fait réellement la machine, mais surtout l’utiliser pour résoudre un problème précis. En 1966, il rejoint les Bell Labs, l’un des grands centres de recherche de l’époque. Il y est notamment affecté à Multics, le vaste projet de système en temps partagé développé avec le MIT et General Electric.

Avant même que Multics ne transforme sa vision des systèmes d’exploitation, Thompson travaille cependant sur un outil beaucoup plus modeste en apparence : un éditeur de texte.

Ken Thompson, QED et la naissance de grep

À Berkeley, Thompson avait découvert QED, un éditeur développé notamment par Peter Deutsch. Aux Bell Labs, il reprend cette idée pour travailler dans l’environnement CTSS utilisé autour du développement de Multics. Il y ajoute une fonction qui deviendra essentielle : les expressions régulières, permettant de rechercher non plus seulement une chaîne de caractères précise, mais un motif.

Cette idée rend les recherches dans un texte beaucoup plus puissantes. On peut décrire, par exemple, tous les mots commençant par une lettre particulière ou toutes les lignes correspondant à une structure donnée. Thompson ajoute aussi une commande permettant d’appliquer une action à toutes les lignes correspondant à une expression. Dans l’éditeur qui deviendra ensuite ed, on retrouve notamment la notation :

g/re/p

Elle signifie approximativement global regular expression print : rechercher globalement une expression régulière puis afficher les lignes correspondantes. C’est de cette syntaxe que vient le nom de la commande grep, toujours utilisée quotidiennement sur Unix et Linux. L’épisode est révélateur : Thompson ne cherche pas à inventer un outil spectaculaire, mais à améliorer celui qu’il utilise lui-même. Cette logique va bientôt se retrouver à une échelle beaucoup plus grande avec les systèmes d’exploitation.

Multics : apprendre de la complexité

Multics poursuit une ambition considérable. Le système doit permettre à de nombreux utilisateurs de travailler simultanément sur une même machine, de partager ses ressources et d’accéder à l’informatique comme on accède à un service public. Le projet introduit des concepts avancés de temps partagé, de sécurité, de gestion de fichiers et de protection des utilisateurs.

Thompson reconnaît l’intérêt de plusieurs de ces idées, mais il est beaucoup plus critique sur la manière dont le projet est construit. Dans son témoignage, il décrit un système devenu extrêmement complexe, accompagné d’un matériel spécialisé et d’une documentation immense. Pour lui, Multics cherche à résoudre trop de problèmes à la fois et finit par devenir difficile à maîtriser.

Lorsque Bell Labs se retire du projet en 1969, l’expérience laisse des traces. L’entreprise ne souhaite plus investir immédiatement dans un autre système d’exploitation et Thompson raconte même avoir été découragé de poursuivre dans cette direction. Pourtant, c’est précisément à ce moment qu’il commence à construire le système qu’il aimerait lui-même utiliser.

1969 : Ken Thompson commence à construire Unix

La naissance d’Unix est souvent racontée à travers Space Travel, un jeu de simulation spatiale que Thompson porte sur un DEC PDP-7 disponible aux Bell Labs. Le jeu joue bien un rôle dans sa découverte de la machine, mais son propre récit montre que l’histoire est plus progressive. Ce qui l’intéresse particulièrement à ce moment-là est l’optimisation des accès aux disques et aux mémoires à tambour.

Thompson veut mettre au point un meilleur algorithme d’ordonnancement des accès au disque. Pour le tester, il lui faut naturellement lire et écrire des données. Il développe donc un système de fichiers, puis des programmes capables de tester ce système. De fil en aiguille apparaissent les entrées-sorties, les mécanismes d’exécution et les fonctions nécessaires pour manipuler les fichiers.

À un certain moment, Thompson réalise qu’il a déjà construit une grande partie d’un système d’exploitation. Il manque encore un éditeur, un assembleur, un chargeur et les mécanismes nécessaires pour faire fonctionner plusieurs programmes ou plusieurs utilisateurs. Ces éléments sont ajoutés progressivement, tandis que Dennis Ritchie, Doug McIlroy, Bob Morris et d’autres chercheurs commencent à s’intéresser au système.

Le PDP-7 reste pourtant une petite machine. Thompson ne cherche donc pas à lui faire accomplir d’immenses calculs, mais à rendre les tâches courantes rapides et interactives : éditer un programme, l’assembler, le charger, le tester puis recommencer. Pour le programmeur, l’ordinateur doit répondre immédiatement au lieu d’imposer l’attente caractéristique du traitement par lots.

C’est dans ce contexte qu’apparaît progressivement Unix. Il ne naît donc pas d’un plan détaillé rédigé à l’avance, mais d’une succession de problèmes pratiques résolus les uns après les autres.

Unix : construire le système dont on a besoin

Cette origine explique plusieurs caractéristiques d’Unix. Thompson explique qu’il ne conçoit généralement pas un système entier d’un seul coup : il construit d’abord la prochaine chose dont il a besoin, tout en veillant à ce qu’elle puisse être étendue. Unix se développe donc autour de mécanismes relativement simples, que les utilisateurs peuvent combiner.

Le shell, par exemple, reste un programme distinct plutôt qu’une partie profondément intégrée au noyau. Les outils sont souvent spécialisés dans une tâche précise et peuvent être enchaînés. Lorsque Doug McIlroy propose les pipes, cette logique devient encore plus visible : la sortie d’un programme peut devenir directement l’entrée du suivant.

La culture des Bell Labs favorise aussi cette évolution. Thompson se souvient d’un environnement où les sources sont largement accessibles et où chacun peut examiner le travail des autres, proposer une amélioration ou modifier un programme. Le système évolue donc au contact de ses utilisateurs, qui sont aussi souvent ses concepteurs. Cette liberté d’expérimentation va jouer un rôle tout aussi important dans l’évolution du langage utilisé pour écrire Unix.

Du langage B au langage C

Les premières versions d’Unix sont encore fortement dépendantes de l’assembleur. Thompson cherche donc un langage plus pratique et développe B, inspiré de BCPL. La filiation est désormais bien connue : BCPL → B → C. B possède notamment une qualité importante : il est relativement facile à porter d’une machine à une autre.

Mais le langage a aussi une limite majeure. Il manipule essentiellement des mots machine et ne possède pas de véritable système de types. Lorsque l’équipe adopte le PDP-11, capable de manipuler efficacement des octets, cette conception devient gênante. Dennis Ritchie commence alors à faire évoluer le langage afin de mieux exploiter la nouvelle architecture.

Thompson tente parallèlement de réécrire Unix avec les différentes versions du langage. Quand certaines structures deviennent trop difficiles à exprimer, il en discute avec Ritchie, qui modifie encore le langage. L’introduction des types puis des structures permet finalement de disposer d’un outil suffisamment puissant pour écrire le système : cette évolution devient le langage C.

En 1973, Unix est largement réécrit en C. Le changement est décisif, car le système n’est plus aussi étroitement lié à une seule architecture matérielle. Unix peut être adapté plus facilement à d’autres machines, ce qui contribuera fortement à sa diffusion dans les universités puis dans l’industrie.

1983 : jusqu’où peut-on faire confiance au logiciel ?

En 1983, Ken Thompson et Dennis Ritchie reçoivent ensemble le prix Turing pour leurs contributions aux systèmes d’exploitation et à Unix. La conférence donnée par Thompson à cette occasion devient elle-même un texte majeur de l’histoire de la sécurité informatique : Reflections on Trusting Trust.

Thompson y imagine un compilateur C volontairement compromis. Celui-ci pourrait reconnaître le programme chargé de l’authentification et y introduire secrètement une porte dérobée. Mais il pourrait aussi reconnaître son propre code source et réinjecter automatiquement le mécanisme lorsqu’une nouvelle version du compilateur est produite.

On pourrait alors nettoyer entièrement le code source visible sans supprimer réellement l’attaque. La démonstration conduit à une conclusion beaucoup plus générale : faire confiance à un programme suppose aussi de faire confiance aux outils qui l’ont construit. Plusieurs décennies avant les débats actuels sur la chaîne d’approvisionnement logicielle, Thompson montrait déjà que la sécurité ne s’arrête pas au code que l’on peut lire.

Plan 9 : repenser Unix pour le réseau

Après Unix, Thompson participe avec Rob Pike et d’autres chercheurs des Bell Labs au développement de Plan 9. Le contexte a changé : les ordinateurs ne sont plus seulement des machines isolées ou des terminaux reliés à un système central. Le réseau devient lui-même une composante essentielle de l’informatique.

Plan 9 reprend donc plusieurs principes d’Unix et les étend aux ressources distantes. Fichiers, terminaux, périphériques et services réseau peuvent être manipulés à travers des interfaces relativement uniformes. Thompson restera très attaché à ce système, qu’il juge plus cohérent qu’Unix, même s’il ne connaîtra jamais la même diffusion.

Plan 9 va néanmoins produire l’une des inventions les plus universelles associées à Thompson : UTF-8.

1992 : Ken Thompson et Rob Pike créent UTF-8

Au début des années 1990, l’équipe de Plan 9 cherche une manière pratique d’utiliser Unicode. ASCII convient bien à l’anglais mais ne permet pas de représenter l’ensemble des alphabets et systèmes d’écriture du monde. Une nouvelle représentation devient indispensable, mais elle doit aussi éviter de rendre obsolète l’immense quantité de logiciels déjà fondés sur ASCII.

Thompson et Rob Pike testent d’abord une proposition existante. Elle fonctionne, mais son décodage nécessite des opérations coûteuses, notamment des divisions, qui posent problème sur certains processeurs de l’époque. Lors d’un repas, Thompson esquisse alors sur une serviette en papier une autre façon d’organiser les bits.

L’idée est élégante : les caractères ASCII restent codés exactement comme auparavant, tandis que les autres caractères utilisent plusieurs octets. Thompson et Pike retournent travailler sur Plan 9 et remplacent leur première solution pratiquement en une nuit. Après quelques essais, le nouvel encodage est proposé au comité de normalisation et devient UTF-8.

La solution est rapide, extensible et surtout compatible avec les anciens logiciels ASCII. Plusieurs décennies plus tard, UTF-8 est devenu l’encodage dominant du Web. Le problème a changé d’échelle, mais la méthode de Thompson reste la même : supprimer une complication technique en cherchant une représentation plus simple.

2007 : Ken Thompson participe à la création de Go

Thompson quitte Bell Labs en 2000 puis rejoint Google quelques années plus tard. Il y retrouve un phénomène familier : avec le temps, les systèmes accumulent des couches, des dépendances et des outils jusqu’à devenir difficiles à maîtriser. Chez Google, certaines compilations peuvent mobiliser de nombreuses machines et imposer de longues attentes, même pour des programmes relativement courts.

Avec Rob Pike et Robert Griesemer, Thompson commence alors à réfléchir à une alternative. Sa proposition est radicale : plutôt que continuer à ajouter des mécanismes aux langages existants, pourquoi ne pas en construire un nouveau ? Le projet devient Go.

Les trois concepteurs adoptent notamment une règle simple : une fonctionnalité n’est ajoutée que s’ils sont tous convaincus de son utilité. L’objectif est de conserver un langage relativement petit, rapide à compiler et facile à comprendre. Près de quarante ans séparent B et Go, mais on retrouve donc la même préoccupation : éviter que la complexité de l’outil ne finisse par gêner le travail qu’il est censé faciliter.

Une influence qui dépasse largement Unix

Ken Thompson occupe ainsi une place particulière dans l’histoire de l’informatique. Unix suffirait déjà à expliquer son importance, mais son parcours relie également les expressions régulières, grep, le langage B, C, la sécurité des compilateurs, Plan 9, UTF-8 et Go. Peu de programmeurs ont laissé une empreinte aussi profonde sur des domaines aussi différents.

Ce qui relie ces travaux n’est pas seulement une préférence pour la simplicité. C’est une méthode de conception : observer un problème réel, construire la solution minimale qui fonctionne, l’utiliser soi-même puis l’améliorer lorsque ses limites apparaissent. Unix est probablement le meilleur exemple de cette approche. Thompson ne s’assoit pas devant une feuille blanche avec le projet de créer l’un des systèmes les plus influents de l’histoire ; il cherche d’abord à mieux utiliser un disque, puis construit progressivement ce dont il a besoin autour de ce premier problème.

Plus d’un demi-siècle après le PDP-7, cette manière de penser reste visible dans Linux, macOS, les outils en ligne de commande, les expressions régulières, UTF-8 et de nombreux langages modernes. C’est peut-être là que réside l’héritage le plus durable de Ken Thompson : montrer que les systèmes les plus puissants ne sont pas toujours ceux qui accumulent le plus de fonctions, mais souvent ceux dont les mécanismes restent suffisamment simples pour être compris, combinés et transformés.