Histoire du tube !

L’histoire du tube (pipe) dans les systèmes Unix, Linux et FreeBSD est une des histoires les plus fondamentales et élégantes de l’informatique. C’est l’histoire d’une idée simple qui a révolutionné la façon de concevoir les logiciels.

Le Problème Originel (Avant le Tube)

Au début des années 1970, chez Bell Labs, les développeurs des premiers Unix (comme Ken Thompson, Dennis Ritchie) écrivaient des programmes qui généraient des données. Pour traiter ces données avec un autre programme, il fallait des étapes laborieuses :

1. programme_A > fichier_temporaire (Écrire la sortie dans un fichier)
2. programme_B < fichier_temporaire (Lire le fichier en entrée)
3. rm fichier_temporaire (Nettoyer le fichier temporaire)

C’était lent (beaucoup d’écritures sur le disque), encombrant et peu élégant.

L’Éclair de Génie : L’Invention du Tube (1973)
Le héros de cette histoire est Douglas McIlroy.

McIlroy était un fervent défenseur d’une philosophie de programmation où de petits outils spécialisés coopèrent pour accomplir des tâches complexes. Il répétait sans cesse : « Faites en sorte que les programmes fassent une seule chose et la fassent bien. Écrivez des programmes qui travaillent ensemble. »

Mais il manquait le « ciment » pour faire collaborer ces programmes. Il a donc poussé Ken Thompson, le principal développeur d’Unix à l’époque, pour implémenter ce « ciment ».

La légende raconte que Ken Thompson a implémenté le premier prototype des tubes en une seule nuit en 1973. Le lendemain matin, la syntaxe | était née dans le shell, et la philosophie Unix était soudainement devenue pratique.

La réaction de McIlroy fut mémorable : « La syntaxe du tube [|] est de Ken. Et Ken l’a aussi implémentée sur-le-champ. La beauté de la chose, c’est que dès le lendemain, nous avons tous arrêté d’utiliser les anciennes méthodes. Personne ne s’est dit ‘Ah, il faut que je sois prudent’. Nous avons juste su que c’était une meilleure façon de faire. »

Comment ça Marchait ? La Magie Technique
Le tube est une file d’attente (FIFO) en mémoire, gérée par le noyau. Techniquement, c’est un canal de communication unidirectionnel entre deux processus.

Quand vous tapez ls | grep « .txt », le shell fait un fork() pour créer deux processus.

Il crée ensuite un tube (un buffer en mémoire avec deux descripteurs de fichier : un pour lire, un pour écrire).

Il utilise dup2() pour rediriger la sortie standard (stdout) de ls vers l’entrée d’écriture du tube.

Il redirige l’entrée standard (stdin) de grep vers la sortie de lecture du tube.

Les deux processus s’exécutent en parallèle. Dès que ls produit une ligne, grep peut la consommer. Aucun fichier temporaire n’est nécessaire. C’est extrêmement rapide.

L’Évolution : Les Tubes Nommés (FIFOs)
Les tubes anonymes (|) étaient limités aux processus ayant une relation parent-enfant (créés par le même shell). Pour une communication plus générale, une nouvelle forme était nécessaire.

En 1975, la version 6 d’Unix a introduit les « tubes nommés » ou FIFOs. Créés avec la commande mknod (puis mkfifo), ils apparaissent comme des fichiers dans le système de fichiers. N’importe quel processus peut ensuite les ouvrir pour lire ou écrire, permettant la communication entre des programmes totalement indépendants.

C’était un pas de géant pour la programmation système et les démons (daemons).

L’Héritage dans Linux et FreeBSD
Linux, créé dans les années 1990, a hérité de cette merveille directement depuis Unix. Linus Torvalds a implémenté les tubes (anonymes et nommés) dans le noyau Linux dès le début. Leur comportement est identique à celui des systèmes Unix traditionnels.

FreeBSD, descendant direct de l’Unix de Berkeley (BSD), a lui aussi hérité de cette fonctionnalité fondamentale. Les tubes sont une partie intrinsèque et non-négociable de son système.

Aujourd’hui, dans les trois systèmes, le principe est resté inchangé :

Tube anonyme (|) : Créé par le shell ou avec l’appel système pipe().

Tube nommé (mkfifo) : Créé comme un fichier spécial.

Le tube simple ou tube anonyme (pipe)

Le tube permet de faire communiquer 2 processus, en shell bash le tube est le symbole |

exemple:

ls /bin | sort
bruno@debian13:~$ ls /bin | sort
[
411toppm
7z
7za
7zr
aa-enabled
...
zstdcat
zstdgrep
zstdless
zstdmt

ls /bin envoi son flux de texte dans la fonction sort , qui va trier par ordre croissant, si on veut décroissant utiliser l’option -r pour sort ( man sort )

Le tube nommé (named pipe)

on va fabriquer des tubes nommé avec la commande mkfifo

fifo est la contraction de First In First Out ( notion électronique ) , en français premier entré premier sorti !

Création d’un pipe nommé ici en exemple mon_pipe

bruno@debian13:~/Works/pipe$ mkfifo mon_pipe 
bruno@debian13:~/Works/pipe$ ls -l mon_pipe 
prw-rw-r-- 1 bruno bruno 0  2 nov.  12:31 mon_pipe
bruno@debian13:~/Works/pipe$ 

utilisons notre tube

dans un terminal

bruno@debian13:~/Works/pipe$ ls /bin > mon_pipe 

on note que c’est bloquant ( ctrl c pour débloquer ) et dans un autre terminal on va vider le tube

bruno@debian13:~/Works/pipe$ cat mon_pipe 
[
411toppm
7z
7za
7zr
....

et on débloque le terminal 1 (on a vider le tube /bin est bien rempli)

Conclusion :

Une Idée Immortelle
L’histoire du tube est l’histoire d’une abstraction parfaite. En fournissant un moyen simple et universel de connecter des programmes, il a :

Éliminé la complexité des fichiers temporaires.

Encouragé la modularité et la création de petits outils réutilisables.

Créé un « langage de composition » qui est au cœur de la puissance de la ligne de commande, 50 ans plus tard.

La commande | est probablement l’opérateur le plus puissant et le plus utilisé par les administrateurs système et les développeurs. Et tout a commencé avec une idée de Douglas McIlroy et une nuit de code de Ken Thompson.