CTSS (Compatible Time-Sharing System)

Au début des années 1960, utiliser un ordinateur demande de la patience. Le programmeur prépare son programme, souvent sur cartes perforées, le confie à un opérateur puis attend son exécution. Une erreur de syntaxe peut suffire à recommencer tout le processus.

Au MIT, une équipe dirigée par Fernando Corbató cherche une autre manière de travailler. Plutôt que de réserver l’ordinateur successivement à chaque utilisateur, pourquoi ne pas permettre à plusieurs personnes de l’utiliser presque en même temps, chacune depuis son terminal ?

En 1961, cette idée prend forme avec CTSS, le Compatible Time-Sharing System. Le système n’est pas le seul projet de temps partagé de cette époque, mais il montre de façon particulièrement convaincante que l’ordinateur peut devenir une machine avec laquelle on dialogue directement.

Avant CTSS : programmer puis attendre

Dans les centres de calcul des années 1950, le traitement par lots est courant. Les programmes sont regroupés puis exécutés les uns après les autres. Cette organisation exploite efficacement des machines rares et coûteuses, mais elle impose une séparation importante entre le programmeur et l’ordinateur.

Pour corriger une erreur ou tester une idée, il faut parfois attendre longtemps avant d’obtenir un résultat. L’ordinateur ressemble alors davantage à un service auquel on remet un travail qu’à un outil personnel.

L’idée du temps partagé cherche précisément à réduire cette attente. Un ordinateur suffisamment rapide peut consacrer successivement de très courts instants à plusieurs utilisateurs. Chacun a alors l’impression que la machine lui répond directement.

Au MIT, John McCarthy fait partie de ceux qui défendent cette idée à la fin des années 1950. Quelques années plus tard, Fernando Corbató et son équipe vont la transformer en système réellement utilisable.

1961 : CTSS prend forme au MIT

Corbató travaille avec Marjorie Merwin-Daggett et Robert Daley au centre de calcul du MIT. Une première version est développée sur un IBM 709, puis adaptée à l’IBM 7090.

En novembre 1961, une démonstration montre plusieurs utilisateurs travaillant depuis des terminaux tandis qu’un autre programme continue de s’exécuter en arrière-plan.

Vu d’aujourd’hui, quelques utilisateurs connectés à un ordinateur paraissent bien peu. À l’époque, le changement est considérable : plusieurs personnes peuvent taper des commandes, lancer des programmes et obtenir rapidement une réponse d’une même machine centrale.

Mais comment un seul processeur peut-il donner cette impression ?

Partager le processeur

Le processeur n’exécute pas réellement tous les programmes au même instant. CTSS le fait passer rapidement d’un utilisateur à l’autre.

Un programme s’exécute pendant un court moment, puis le système l’interrompt et donne le processeur au programme suivant. Après quelques instants, le cycle recommence. Pour l’utilisateur, ces changements sont suffisamment rapides pour que la machine semble disponible presque en permanence.

C’est le principe du time-sharing, ou temps partagé.

La faible quantité de mémoire disponible complique cependant le problème. Lorsque plusieurs utilisateurs travaillent simultanément, tous leurs programmes ne peuvent pas rester en mémoire. CTSS doit donc en déplacer certains temporairement vers un stockage secondaire avant de les recharger lorsque leur tour revient. Ce mécanisme est appelé swapping.

Derrière une idée apparemment simple — partager l’ordinateur — se cache donc déjà une grande partie du travail d’un système d’exploitation moderne : gérer le processeur, la mémoire et plusieurs utilisateurs sans qu’ils se gênent mutuellement.

Pourquoi « Compatible » ?

Le nom Compatible Time-Sharing System n’a pas été choisi au hasard.

Le MIT utilise déjà ses ordinateurs pour exécuter de nombreux programmes en traitement par lots. Impossible d’abandonner brutalement cet environnement simplement pour expérimenter le temps partagé.

CTSS est donc conçu pour cohabiter avec les méthodes existantes. Les programmes traditionnels peuvent continuer à fonctionner pendant que d’autres utilisateurs travaillent de manière interactive.

Cette compatibilité permet une transition progressive. Le temps partagé n’a pas besoin de remplacer immédiatement l’ancien fonctionnement : il peut d’abord s’y ajouter.

À mesure que CTSS prend de l’importance, le matériel lui-même évolue. Les IBM 7090 puis 7094 utilisés au MIT reçoivent notamment des mécanismes permettant de protéger la mémoire et d’interrompre automatiquement un programme.

Ces protections sont indispensables. Dans un système partagé, le programme d’un utilisateur ne doit pas pouvoir modifier accidentellement la mémoire d’un autre ou bloquer toute la machine.

Un ordinateur sur lequel on retrouve son travail

Le temps partagé modifie également la manière dont les utilisateurs organisent leurs données.

Chaque personne dispose d’un compte et peut conserver ses propres fichiers. Un système de mot de passe contrôle l’accès. Après s’être connecté, l’utilisateur retrouve ainsi son environnement de travail.

La différence avec le traitement par lots devient considérable. Le programmeur peut modifier un fichier, compiler son programme, l’exécuter, observer le résultat, corriger une erreur puis recommencer immédiatement.

Des langages comme Lisp, MAD ou l’assembleur sont utilisés sous CTSS. Le système devient également un environnement de développement : c’est notamment au MIT que Martin Richards réalise quelques années plus tard un compilateur opérationnel de BCPL.

La programmation se rapproche alors de ce que nous connaissons aujourd’hui : une succession rapide d’essais, de corrections et de nouvelles exécutions.

Et lorsque les utilisateurs commencent à travailler quotidiennement dans le même système, de nouveaux besoins apparaissent naturellement.

Automatiser les commandes

Entre 1963 et 1965, l’ingénieur français Louis Pouzin travaille au MIT sur CTSS. Il développe notamment RUNCOM, un outil permettant de placer plusieurs commandes dans un fichier puis de les exécuter automatiquement.

Plutôt que de retaper toujours la même succession d’instructions, l’utilisateur peut préparer une procédure et la réutiliser.

Le principe paraît banal aujourd’hui, mais il préfigure les scripts de commandes que l’on retrouvera plus tard dans les environnements Unix et les shells modernes.

CTSS commence ainsi à dépasser le simple partage du processeur. Il devient progressivement un environnement complet dans lequel on programme, organise son travail et automatise des tâches.

Quand les utilisateurs commencent à communiquer

Le fait de réunir plusieurs personnes sur le même ordinateur entraîne une autre évolution : elles commencent à utiliser la machine pour communiquer.

En 1965, Tom Van Vleck et Noel Morris développent la commande MAIL. Un utilisateur peut laisser un message à un autre, qui le retrouvera lors de sa prochaine connexion.

Il ne s’agit pas encore du courrier électronique d’Internet : les messages restent à l’intérieur du même système. Le principe est néanmoins déjà reconnaissable.

CTSS dispose également d’outils de préparation de documents. RUNOFF permet de mettre en forme du texte à partir d’instructions placées dans un fichier. Cette idée influencera ensuite plusieurs logiciels de composition de texte du monde Unix.

L’ordinateur partagé n’est donc plus uniquement utilisé pour calculer. Il sert aussi à écrire, programmer, automatiser et communiquer.

C’est précisément cette multiplication des usages qui va révéler les limites de CTSS.

De CTSS à Multics

CTSS avait été construit en adaptant des ordinateurs qui n’avaient pas été conçus dès l’origine pour accueillir une grande communauté d’utilisateurs.

Son succès pousse donc le MIT à imaginer un système beaucoup plus ambitieux, pensé dès le départ pour le temps partagé, la sécurité et l’utilisation simultanée par de nombreux utilisateurs.

Ce projet devient Multics.

CTSS continue néanmoins à être utilisé pendant plusieurs années. La dernière installation du MIT est arrêtée en 1973, plus de dix ans après les premières expérimentations. À cette date, son héritage dépasse largement la machine sur laquelle il fonctionnait.

Pourquoi CTSS compte dans l’histoire de l’informatique

CTSS n’a pas inventé à lui seul le temps partagé. Plusieurs équipes travaillent sur des idées proches au tournant des années 1960.

Son importance vient surtout de ce qu’il a montré concrètement : un ordinateur pouvait devenir un environnement interactif utilisé quotidiennement par plusieurs personnes.

Avec CTSS, l’utilisateur se connecte, possède ses fichiers, lance des commandes, programme depuis un terminal, automatise certaines tâches et échange des messages avec d’autres utilisateurs.

Ces pratiques nous paraissent aujourd’hui ordinaires. Elles ne l’étaient pas au début des années 1960.

L’ordinateur cesse progressivement d’être une machine à laquelle on remet un travail pour devenir une machine dans laquelle on travaille.

Cette évolution ne s’arrête pas avec CTSS. Au MIT, elle mène directement à Multics, puis quelques années plus tard, aux Bell Labs, une partie de cette histoire contribuera à la naissance d’UNIX.