ALGOL 60

Dans les années 1950, les ordinateurs deviennent capables d’effectuer des calculs scientifiques de plus en plus complexes. Avec des langages comme FORTRAN, les chercheurs peuvent désormais écrire des formules sans détailler chaque instruction du processeur. Pourtant, une difficulté demeure : les ordinateurs sont très différents et les méthodes de programmation varient d’une machine à l’autre. Comment un mathématicien peut-il décrire un algorithme de manière suffisamment précise pour qu’un autre chercheur puisse le comprendre, le vérifier et l’utiliser sur son propre ordinateur ?

Cette question réunit, à la fin des années 1950, des informaticiens européens et américains. Leur collaboration aboutit en 1960 à ALGOL 60, un langage dont l’influence dépassera largement son utilisation pratique. ALGOL ne se contente pas de proposer une autre façon d’écrire des calculs. Il contribue à établir des principes devenus fondamentaux : organiser les instructions en blocs, contrôler la portée des variables et définir rigoureusement la syntaxe d’un langage. Ces idées se retrouveront dans de nombreux langages ultérieurs, notamment Pascal, Simula et, par différentes filiations, C.

Pourquoi créer un nouveau langage alors que FORTRAN existe déjà ?

En 1957, FORTRAN, développé chez IBM sous la direction de John Backus, représente une avancée majeure. Un scientifique peut écrire des expressions mathématiques relativement proches de ses équations, puis laisser un compilateur les traduire en instructions machine. Ce progrès réduit considérablement le travail nécessaire pour programmer des calculs numériques. Mais FORTRAN a été conçu initialement pour les ordinateurs IBM, même s’il sera ensuite adapté à d’autres machines. Les chercheurs souhaitent aller plus loin dans l’indépendance entre les programmes et les constructeurs.

Imaginons deux laboratoires qui étudient le déplacement d’un satellite. Chacun possède un ordinateur différent. Les chercheurs peuvent naturellement échanger leurs équations, puisqu’ils utilisent le même langage mathématique. En revanche, échanger directement leurs programmes est beaucoup plus difficile : les syntaxes, les outils disponibles et les particularités des machines ne sont pas nécessairement les mêmes. L’objectif n’est donc pas seulement de programmer plus facilement. Il est aussi de disposer d’un langage commun pour décrire les méthodes de calcul, sans devoir les réinventer pour chaque ordinateur.

Cette ambition prend forme des deux côtés de l’Atlantique. En Europe, des chercheurs réunis autour de la GAMM (Gesellschaft für Angewandte Mathematik und Mechanik), une société savante allemande consacrée aux mathématiques appliquées et à la mécanique, travaillent sur un langage algorithmique universel. Aux États-Unis, l’ACM (Association for Computing Machinery) mène des réflexions comparables. Plutôt que de produire deux langages concurrents, les deux groupes décident de collaborer.

De Zurich à Paris : la naissance d’ALGOL 60

La première étape importante se déroule à Zurich, du 27 mai au 2 juin 1958. Des représentants européens et américains élaborent une proposition commune appelée International Algebraic Language (IAL). Ce langage, ensuite connu sous le nom d’ALGOL 58, constitue une première tentative de normalisation internationale. Il doit permettre de décrire précisément des algorithmes, de les présenter dans les publications scientifiques et de faciliter leur traduction sur différentes machines.

Ces objectifs imposent un compromis. La notation mathématique imprimée dans une revue scientifique peut employer des symboles qui ne sont pas directement disponibles sur les équipements informatiques de l’époque. Les concepteurs distinguent donc plusieurs représentations du langage : une représentation de référence définissant ses règles, une représentation destinée aux publications et des représentations adaptées aux machines. Ainsi, la manière d’écrire un algorithme dans un article scientifique n’est plus nécessairement limitée par le clavier ou le lecteur de bande perforée d’un ordinateur particulier.

1958 : les premiers programmes ALGOL deviennent exécutables

ALGOL 58 n’est pas resté une simple proposition théorique. Dès 1957, des chercheurs européens réunis dans le projet ZMMD, associant Zurich, Munich, Mayence et Darmstadt, travaillent à la réalisation de systèmes capables de traduire ce nouveau langage pour différents ordinateurs. Leur approche repose notamment sur l’utilisation d’une pile, une structure permettant de conserver temporairement les opérateurs et les informations nécessaires à l’analyse des expressions. Cette technique facilite le traitement des formules mathématiques, notamment lorsque celles-ci contiennent plusieurs opérations et des parenthèses.

À l’automne 1958, trois programmeurs entreprennent la réalisation de premiers traducteurs expérimentaux pour les ordinateurs ERMETH, PERM et Zuse Z22. Achevés à la fin de l’année, ces systèmes fonctionnent dès janvier 1959. Ils commencent comme des interpréteurs, avant d’évoluer vers des générateurs de programmes exécutables. La programmation de ces outils nécessite de travailler au plus près des capacités des machines, bien avant que des compilateurs de haut niveau puissent être utilisés pour développer leurs propres successeurs.

Cette expérience montre que la conception d’un langage et celle de son compilateur sont deux travaux complémentaires. Les chercheurs doivent non seulement imaginer des instructions plus simples pour les programmeurs, mais aussi trouver comment les traduire en opérations élémentaires exécutables par les ordinateurs. Les difficultés rencontrées avec ALGOL 58 contribueront aux réflexions qui aboutiront à une définition plus précise du langage en 1960.

1958 : les premiers programmes ALGOL deviennent exécutables

ALGOL 58 n’est pas resté une simple proposition théorique. Dès 1957, des chercheurs européens réunis dans le projet ZMMD, associant Zurich, Munich, Mayence et Darmstadt, travaillent à la réalisation de systèmes capables de traduire ce nouveau langage pour différents ordinateurs. Leur approche repose notamment sur l’utilisation d’une pile, une structure permettant de conserver temporairement les opérateurs et les informations nécessaires à l’analyse des expressions. Cette technique facilite le traitement des formules mathématiques, notamment lorsque celles-ci contiennent plusieurs opérations et des parenthèses.

À l’automne 1958, trois programmeurs entreprennent la réalisation de premiers traducteurs expérimentaux pour les ordinateurs ERMETH, PERM et Zuse Z22. Achevés à la fin de l’année, ces systèmes fonctionnent dès janvier 1959. Ils commencent comme des interpréteurs, avant d’évoluer vers des générateurs de programmes exécutables. La programmation de ces outils nécessite de travailler au plus près des capacités des machines, bien avant que des compilateurs de haut niveau puissent être utilisés pour développer leurs propres successeurs.

Cette expérience montre que la conception d’un langage et celle de son compilateur sont deux travaux complémentaires. Les chercheurs doivent non seulement imaginer des instructions plus simples pour les programmeurs, mais aussi trouver comment les traduire en opérations élémentaires exécutables par les ordinateurs. Les difficultés rencontrées avec ALGOL 58 contribueront aux réflexions qui aboutiront à une définition plus précise du langage en 1960.

Paris, janvier 1960 : un langage redéfini

ALGOL 58 suscite beaucoup d’intérêt, mais son premier rapport contient des imprécisions. Certaines constructions, notamment les procédures et les paramètres, demandent des définitions plus rigoureuses. Du 11 au 16 janvier 1960, treize représentants venus de sept pays se réunissent à Paris pour résoudre ces difficultés. Parmi eux figurent John Backus, déjà connu pour FORTRAN, l’Américain Alan Perlis, les Européens Friedrich Bauer, Heinz Rutishauser et Peter Naur, ainsi que le Français Bernard Vauquois.

Peter Naur, informaticien danois, joue un rôle particulièrement important. Il prépare un nouveau projet de rapport, qui sert de base aux discussions, puis assure la rédaction du document collectif. Les participants ne se limitent pas à corriger ALGOL 58 : ils en retravaillent profondément la définition. Le résultat, ALGOL 60, est présenté dans un rapport diffusé dès mars 1960, puis publié notamment dans la revue Communications of the ACM en mai de la même année. Le langage tire son nom d’Algorithmic Language, c’est-à-dire « langage algorithmique ».

La portée de ce travail tient autant aux règles du langage qu’à la précision avec laquelle elles sont formulées. Pour mesurer cette nouveauté, il faut regarder comment ALGOL organise les instructions et les variables à l’intérieur d’un programme.

Comment les premiers compilateurs ALGOL ont-ils été programmés ?

Définir un langage de programmation ne suffit pas à le faire fonctionner. En janvier 1960, les chercheurs disposent des règles d’ALGOL 60, mais aucun ordinateur ne comprend directement ses instructions. Les processeurs exécutent uniquement leur propre langage machine, composé d’instructions codées en nombres binaires. Pour utiliser ALGOL, il faut donc écrire un programme capable de traduire ce nouveau langage en instructions exécutables : un compilateur. Mais une difficulté apparaît immédiatement : comment programmer ce compilateur alors qu’il n’existe pas encore de compilateur ALGOL permettant de le développer ?

La solution consiste à partir des outils déjà disponibles. À cette époque, les programmeurs utilisent notamment l’assembleur, un langage de bas niveau dans lequel des instructions symboliques correspondent étroitement aux opérations du processeur. Un programme appelé assembleur traduit ensuite ces instructions en code machine. On peut donc écrire un compilateur en assembleur, puis l’utiliser pour traduire des programmes rédigés dans un langage de plus haut niveau. C’est ainsi que les chercheurs vont rendre ALGOL exécutable.

1960 : Dijkstra et Zonneveld programment le compilateur de l’Electrologica X1

Aux Pays-Bas, au Centre de mathématiques d’Amsterdam, Edsger Dijkstra et Jaap Zonneveld entreprennent dès la fin de 1959 la réalisation d’un compilateur ALGOL 60 destiné à l’ordinateur Electrologica X1. Leur programme est écrit dans le langage assembleur propre à cette machine. Les difficultés sont nombreuses : il faut reconnaître les instructions ALGOL, gérer les variables, organiser les procédures et produire un programme que le X1 pourra exécuter. Le compilateur doit fonctionner dans un espace mémoire de seulement 4 096 mots de 27 bits, partagé entre ses instructions et ses données de travail.

Le fonctionnement initial repose sur des bandes perforées. Le programme écrit en ALGOL est lu une première fois pour préparer sa traduction, notamment en repérant les blocs et certaines informations nécessaires. Une seconde lecture permet de produire le programme objet, lui-même enregistré sur une bande perforée. Un programme de chargement transforme ensuite ce résultat en instructions exécutables, avec l’aide de routines spécialisées. Pour réaliser une simple addition exprimée en ALGOL, l’ordinateur doit finalement effectuer les opérations élémentaires nécessaires : accéder aux valeurs, les additionner et conserver le résultat.

La réalisation ne se limite d’ailleurs pas au compilateur. Deux autres membres de l’équipe, M. J. H. Römgens et S. J. Christen, développent les routines assurant notamment les opérations arithmétiques nécessaires à l’exécution. L’ensemble représente approximativement 4 000 instructions de bas niveau, dont la moitié pour le compilateur. En août 1960, le système devient opérationnel. Des programmes écrits dans le nouveau langage peuvent enfin être traduits puis exécutés sur l’Electrologica X1.

Cette réalisation marque une étape importante. Les programmeurs n’ont plus besoin d’écrire directement en assembleur chaque application scientifique : ils peuvent utiliser ALGOL, à condition de disposer d’un compilateur adapté à leur ordinateur. Le langage reste défini indépendamment de la machine, mais sa mise en œuvre dépend encore d’un travail considérable de programmation de bas niveau. C’est cette séparation entre le langage utilisé par les scientifiques et les instructions réellement exécutées par le processeur qui contribue à transformer durablement la programmation.

Des blocs pour donner une structure aux programmes

À mesure que les programmes grandissent, une difficulté apparaît : il devient de plus en plus compliqué de suivre les instructions et de savoir où les variables sont utilisées. Dans certaines organisations de programmes, plusieurs parties du code peuvent modifier les mêmes informations. Une modification effectuée à un endroit risque alors d’avoir des conséquences inattendues ailleurs. ALGOL 60 propose une organisation plus rigoureuse grâce aux blocs d’instructions.

Un bloc est délimité par les mots-clés begin et end. Il peut contenir des déclarations de variables et plusieurs instructions. Surtout, un bloc peut lui-même contenir d’autres blocs, ce qui permet de construire progressivement un programme composé de parties bien délimitées.

Prenons un exemple simple, écrit dans une forme de la syntaxe d’ALGOL 60 :

begin
    integer total;
    total := 0;

    begin
        integer note;
        note := 12;
        total := total + note
    end
end

Dans cet exemple, integer indique qu’une variable contient un nombre entier. Le symbole := signifie « affecter une valeur ». Le programme commence par déclarer total, puis lui attribue la valeur zéro. Un second bloc est ensuite ouvert : il déclare une variable note, lui donne la valeur 12 et ajoute cette valeur à total. À la fin de cette opération, total vaut donc 12. À première vue, cet exemple paraît élémentaire, mais il illustre une propriété essentielle du langage.

La portée des variables : chaque nom a son domaine

La variable note est déclarée dans le bloc intérieur. Elle n’est donc pas accessible depuis le bloc extérieur après la fermeture du bloc intérieur. En revanche, total, déclarée dans le bloc extérieur, reste accessible depuis le bloc intérieur. Cette règle correspond à ce que l’on appelle la portée lexicale des variables : leur visibilité dépend de la structure du programme et de l’endroit où elles sont déclarées.

ALGOL 60 permet même de réutiliser un nom déjà employé dans un bloc extérieur. La nouvelle déclaration désigne alors une autre variable, dont la portée est limitée au bloc intérieur. Le langage fournit ainsi des règles explicites pour savoir à quelle variable correspond chaque nom. Cette organisation facilite la compréhension des programmes, mais également leur traduction par les compilateurs.

Cela ne signifie pas qu’ALGOL a inventé à lui seul toutes les formes de programmation structurée. Des mécanismes voisins existaient déjà, et le langage conserve notamment l’instruction goto, qui permet de modifier directement le déroulement de l’exécution. ALGOL contribue néanmoins à donner une base solide aux programmes organisés en blocs, une approche que plusieurs de ses successeurs approfondiront.

Boucles, procédures et récursivité : décrire un calcul avec méthode

Les blocs ne servent pas uniquement à isoler des variables. Ils permettent aussi de réunir des instructions dans une organisation cohérente. ALGOL 60 dispose de conditions avec if, then et else, ainsi que d’une instruction for permettant de répéter un traitement. Ces constructions rendent les étapes d’un algorithme plus faciles à identifier dans le programme lui-même.

Imaginons un programme qui calcule la somme des trois premiers entiers :

begin
    integer i, somme;
    somme := 0;

    for i := 1 step 1 until 3 do
        somme := somme + i
end

L’instruction for fait successivement prendre à i les valeurs 1, 2 et 3. À chaque passage, la valeur courante est ajoutée à somme. Le calcul donne finalement 1 + 2 + 3 = 6. Le lecteur peut ainsi identifier la répétition et ses limites sans devoir suivre une succession de sauts vers des numéros de ligne. Ce mécanisme s’inscrit dans une évolution plus générale : rapprocher la structure du programme de celle du raisonnement utilisé pour résoudre le problème.

Les procédures : réutiliser un traitement

Une autre possibilité importante est la définition de procédures, c’est-à-dire de traitements que l’on peut appeler depuis différentes parties d’un programme. Une procédure peut recevoir des paramètres. Par exemple, un algorithme de calcul numérique peut utiliser une procédure pour effectuer plusieurs fois la même opération avec des valeurs différentes, sans réécrire toutes les instructions nécessaires.

ALGOL 60 définit notamment deux modes de transmission des paramètres : le passage par valeur et le passage par nom (call by name). Dans le premier cas, une valeur calculée est transmise à la procédure. Dans le second, le mécanisme est plus subtil : l’argument conserve un lien avec l’expression ou la variable fournie lors de l’appel, et son évaluation dépend du contexte prévu par le langage. Il ne s’agit donc pas simplement d’un passage par référence tel qu’on le rencontrera dans d’autres langages. Cette distinction, complexe à implémenter, montre le degré de précision recherché par les concepteurs.

Une procédure peut s’appeler elle-même

ALGOL 60 permet également la récursivité. Une procédure récursive est une procédure capable de s’appeler elle-même pour résoudre progressivement un problème. Prenons le calcul d’une factorielle. La factorielle de 4, notée 4!, vaut 4 × 3 × 2 × 1, soit 24. Mais ce même calcul peut se décomposer en remarquant que 4! = 4 × 3!. Le calcul d’une factorielle peut donc faire appel au même calcul pour un nombre plus petit, jusqu’au cas de base 0! = 1.

La récursivité ne date pas d’ALGOL : elle possède une longue histoire en mathématiques et apparaît également dans d’autres travaux informatiques de l’époque. ALGOL 60 contribue cependant à en faire un mécanisme explicite dans la conception de langages procéduraux. Avec les blocs, les procédures et les structures de contrôle, le programme devient plus facile à organiser. Encore faut-il que toutes ces constructions soient définies sans ambiguïté, afin qu’un compilateur puisse les reconnaître correctement.

La BNF : décrire un langage avec une grammaire précise

Dans une langue naturelle, les règles grammaticales permettent de distinguer différentes constructions de phrases. Un langage de programmation possède lui aussi des règles : il faut savoir comment écrire une déclaration, une expression mathématique, une condition ou un appel de procédure. Pour un compilateur, ces règles doivent être suffisamment précises pour éviter les interprétations contradictoires. C’est ici qu’intervient l’une des contributions les plus durables d’ALGOL 60 : l’utilisation systématique d’une notation formelle pour décrire la syntaxe.

John Backus avait proposé, dans ses travaux sur ALGOL 58, une méthode reposant sur des règles de production. Peter Naur en reprend et en adapte l’écriture pour le rapport d’ALGOL 60. Cette notation deviendra connue sous le nom de BNF, pour Backus–Naur Form.

Une règle pour décrire les écritures autorisées

Considérons cet exemple pédagogique simplifié :

<signe> ::= + | -

La notation indique que l’élément <signe> peut prendre deux formes : + ou -. Le symbole ::= se lit « est défini comme », tandis que la barre verticale | exprime une alternative. On peut représenter les chiffres décimaux par une règle analogue :

<chiffre> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Ces règles ne réalisent aucun calcul. Elles décrivent les constructions autorisées dans un langage. Le rapport d’ALGOL 60 utilise cette approche pour définir des éléments beaucoup plus élaborés : nombres, expressions, déclarations, instructions et blocs. La grammaire sert ainsi de référence commune aux personnes qui étudient le langage comme à celles qui développent ses compilateurs.

Cette méthode apporte également une distinction importante. La syntaxe indique comment une instruction peut être écrite, tandis que la sémantique précise ce qu’elle signifie et comment elle doit être interprétée. La BNF ne suffit donc pas, à elle seule, à définir le comportement complet d’un programme. Le rapport associe les règles grammaticales à des explications décrivant le sens des constructions. Cette combinaison devient une référence pour les travaux sur les compilateurs et contribue à faire de la conception des langages une discipline plus rigoureuse.

Un langage influent, mais qui ne domine pas les ordinateurs

Avec ses blocs, ses procédures et sa définition rigoureuse, ALGOL 60 dispose d’atouts considérables. Pourquoi n’a-t-il pas remplacé FORTRAN dans les applications scientifiques ? Une première difficulté tient à la standardisation. Le rapport définit le cœur du langage, mais ne prévoit pas d’instructions standard pour lire et écrire les données. Cela ne signifie pas qu’un programme ALGOL est incapable d’afficher un résultat ou de lire un fichier : les différentes implémentations proposent des procédures et des bibliothèques adaptées à leurs machines. Cependant, ces fonctionnalités ne sont pas uniformes d’un système à l’autre.

Un programme peut ainsi nécessiter des adaptations lorsqu’il passe d’un ordinateur à un autre, malgré l’ambition initiale d’indépendance. La réalisation des compilateurs représente également un défi technique. Certaines caractéristiques du langage, notamment les procédures et le passage des paramètres par nom, exigent des mécanismes complexes. Des équipes développent néanmoins des implémentations dès 1960. Aux Pays-Bas, Edsger Dijkstra et Jaap Zonneveld participent notamment à la réalisation d’un compilateur ALGOL 60 pour l’ordinateur Electrologica X1.

De leur côté, les constructeurs qui utilisent déjà FORTRAN disposent d’outils, de bibliothèques et d’une communauté d’utilisateurs. Changer de langage implique des coûts, et les avantages théoriques ne suffisent pas toujours à justifier cette transition. ALGOL 60 ne devient donc pas le langage industriel dominant, même s’il connaît des utilisations réelles, notamment sur certains ordinateurs européens et dans des environnements universitaires.

Son influence se développe surtout dans les universités, les laboratoires et les publications scientifiques. Pendant de nombreuses années, des algorithmes seront présentés dans une notation inspirée d’ALGOL, même lorsqu’ils ne sont pas destinés à être exécutés directement. Son succès doit ainsi être mesuré autrement que par le nombre d’ordinateurs sur lesquels il fonctionne : ALGOL joue un rôle déterminant dans la manière dont les informaticiens conçoivent et décrivent leurs programmes.

D’ALGOL à Pascal, Simula et C : un héritage durable

À mesure que les programmes deviennent plus complexes, les concepteurs de langages cherchent à mieux organiser les données, les traitements et les relations entre les différentes parties d’un logiciel. ALGOL 60 fournit une partie des mécanismes nécessaires à cette évolution, mais ses successeurs vont emprunter des directions différentes.

En Norvège, Ole-Johan Dahl et Kristen Nygaard développent Simula, dont la version Simula 67 reprend une base issue d’ALGOL et introduit des mécanismes de classes et d’objets. Ces travaux constitueront une étape fondamentale dans l’histoire de la programmation orientée objet. Ils montrent notamment comment les mécanismes de structuration des programmes peuvent être étendus à la représentation d’entités possédant leurs propres données et comportements.

De son côté, l’informaticien suisse Niklaus Wirth participe aux réflexions sur les successeurs d’ALGOL. Après ses travaux sur ALGOL W, il conçoit Pascal, présenté en 1970. Pascal conserve notamment les blocs, les procédures et les règles de portée, tout en développant une organisation plus explicite des types et des structures de données. Il jouera un rôle important dans l’enseignement de la programmation, en proposant un langage adapté à l’apprentissage d’une démarche rigoureuse.

Une autre filiation passe par le langage CPL, puis par BCPL, conçu par Martin Richards en 1967. BCPL influence directement B, développé par Ken Thompson, avant l’apparition du langage C, conçu principalement par Dennis Ritchie au début des années 1970. Il serait toutefois incorrect d’affirmer que C descend directement d’ALGOL 60 sans intermédiaire : les influences passent par plusieurs projets et s’accompagnent de transformations importantes.

L’histoire d’ALGOL se poursuit également avec ALGOL 68, dont le rapport est publié en 1968. Plus ambitieux et plus complexe, ce nouveau langage explore d’autres possibilités de définition et de composition des types. Il ne remplace cependant pas ALGOL 60 comme langage universel de programmation. Ces différentes évolutions montrent qu’un langage peut exercer une influence considérable sans devenir lui-même un outil de programmation largement utilisé.

Ce qu’ALGOL 60 a véritablement changé

ALGOL 60 n’a inventé ni les langages de haut niveau, ni les procédures, ni toutes les techniques de programmation structurée. Son importance réside dans la manière dont il a réuni et précisé plusieurs principes au sein d’une définition cohérente. Les blocs permettent de délimiter clairement les parties d’un programme. Les règles de portée indiquent où les variables peuvent être utilisées. Les procédures organisent les traitements réutilisables. Enfin, la BNF fournit un moyen rigoureux de décrire les constructions autorisées.

En 1960, ces choix contribuent à faire de la conception des langages de programmation un domaine d’étude à part entière. Aujourd’hui encore, lorsqu’un développeur déclare une variable locale, organise un programme en fonctions ou consulte la grammaire d’un langage, il retrouve des principes dont ALGOL 60 a contribué à établir la forme moderne.

L’héritage le plus profond d’ALGOL n’est donc pas une instruction particulière. C’est l’idée qu’un langage de programmation doit être défini avec autant de rigueur que les algorithmes qu’il permet d’exprimer.

Sources historiques

• Backus et al. — Report on the Algorithmic Language ALGOL 60, Communications of the ACM, volume 3, numéro 5, mai 1960.
• Paul McJones — History of ALGOL, archives et documents historiques consacrés à la famille ALGOL.
• Huub de Beer — ALGOL, more than just ALGOL, étude historique sur la naissance et l’évolution du langage.