Au début des années 1950, programmer un calcul scientifique signifie souvent traduire chaque formule en une longue suite d’instructions propres à un ordinateur. John Backus veut supprimer ce travail mécanique. L’équipe qu’il dirige chez IBM crée FORTRAN, un langage qui permet d’écrire des formules sous une forme reconnaissable puis de les faire traduire automatiquement.
Le défi n’est pas seulement de concevoir une notation plus lisible. Les scientifiques savent optimiser directement l’assembleur et se méfient d’un programme qui écrirait du code à leur place. Pour être adopté, le compilateur FORTRAN doit produire des programmes presque aussi rapides que ceux d’experts humains.
Backus consacrera ensuite sa carrière à deux autres questions : comment décrire rigoureusement la syntaxe d’un langage, puis comment sortir d’un modèle de programmation fondé sur la modification successive de la mémoire.
Pourquoi la programmation scientifique restait coûteuse
John Warner Backus naît en 1924 à Philadelphie. Son parcours scolaire est irrégulier et il ne découvre sa voie qu’après son service militaire. Il étudie d’abord la médecine, puis se tourne vers les mathématiques et obtient en 1950 un master à l’université Columbia.
La même année, il visite le siège d’IBM et découvre le Selective Sequence Electronic Calculator. Une conversation improvisée débouche sur son recrutement. Il travaille bientôt sur des programmes mathématiques et sur Speedcoding, système qui simplifie certains calculs sur l’IBM 701.
Speedcoding améliore la productivité, mais son interprétation ralentit fortement l’exécution. Ce compromis convient mal lorsque le temps de calcul est rare et coûteux. Les programmeurs continuent donc à écrire en langage machine ou en assembleur, au prix de semaines de travail et de nombreuses erreurs.
En 1953, Backus propose à IBM un système plus ambitieux : les utilisateurs écriraient des formules proches de leur notation mathématique, et un compilateur produirait un programme efficace pour le futur IBM 704.
FORTRAN est autant un compilateur qu’un langage
Backus réunit une équipe dont les compétences couvrent mathématiques, programmation et architecture des machines. Parmi ses membres figurent notamment Harlan Herrick, Irving Ziller, Peter Sheridan, Roy Nutt, Robert Nelson et Lois Haibt. Cette diversité est indispensable : aucun individu ne pouvait à lui seul concevoir le langage, optimiser le compilateur et tester toutes les formes de calcul.
Le nom FORTRAN vient de Formula Translation. Le langage permet d’écrire des expressions arithmétiques, des boucles et des branchements sans manipuler directement les codes de l’IBM 704. Une instruction peut décrire le calcul voulu ; le compilateur choisit les instructions de la machine.
Cette traduction doit préserver les performances. L’équipe développe des techniques d’analyse et d’optimisation capables d’organiser les calculs et l’utilisation des registres. La réalisation du premier compilateur demande plusieurs années et représente un programme considérable pour l’époque.
Lorsque FORTRAN est livré en 1957, son efficacité réduit l’argument principal en faveur de l’assembleur. Les scientifiques peuvent consacrer davantage de temps au modèle mathématique et moins à la mécanique du processeur. Le temps nécessaire pour produire un programme diminue, tandis que le même langage peut progressivement être adapté à d’autres machines.
Une réussite collective qui change l’économie du logiciel
Présenter Backus comme l’unique créateur de FORTRAN serait trompeur. Il propose le projet, dirige l’équipe et contribue à sa conception, mais le langage et son compilateur résultent d’un travail collectif chez IBM.
Son rôle reste décisif parce qu’il maintient deux objectifs difficiles à concilier : rendre le code plus proche des mathématiques sans renoncer à la vitesse. Le succès démontre qu’un langage de haut niveau peut être utilisé pour des calculs réels, et pas seulement comme outil pédagogique.
FORTRAN se diffuse dans les laboratoires, l’industrie et les universités. Il crée aussi un nouvel enjeu : le code scientifique peut vivre plus longtemps que l’ordinateur pour lequel il a été écrit. Ses versions ultérieures amélioreront la portabilité, la structuration et la prise en charge de nouveaux domaines, tout en conservant un vaste patrimoine de programmes numériques.
L’histoire de FORTRAN suit cette évolution du langage. La biographie de Backus éclaire le problème initial : rendre acceptable la traduction automatique auprès de programmeurs convaincus que seule l’écriture manuelle pouvait être efficace.
Décrire la grammaire d’un langage
Après FORTRAN, Backus participe aux discussions internationales sur ALGOL 58 puis ALGOL 60. Les concepteurs doivent décrire sans ambiguïté quelles suites de symboles constituent un programme valide.
Le langage courant ne suffit pas. Une phrase comme « une expression contient des nombres et des opérateurs » laisse de nombreuses questions ouvertes. Backus propose une notation formelle où chaque catégorie syntaxique est définie par des règles de remplacement.
Peter Naur adapte cette méthode pour le rapport ALGOL 60. Elle devient la forme de Backus-Naur, ou BNF. Une règle peut, par exemple, indiquer qu’une expression est un nombre ou la combinaison de deux expressions autour d’un opérateur. En appliquant récursivement les règles, on peut décrire une infinité de programmes avec un ensemble fini de productions.
La BNF sépare deux problèmes : la syntaxe définit la forme autorisée ; l’implémentation décide comment l’analyser et l’exécuter. Cette séparation aide les concepteurs de compilateurs, les auteurs de normes et les lecteurs d’une spécification. Ses variantes sont encore utilisées pour documenter des langages, des formats et des protocoles.
Remettre en cause le modèle qu’il avait contribué à diffuser
FORTRAN améliore radicalement la programmation impérative : un programme lit et modifie des valeurs stockées en mémoire, instruction après instruction. Backus finit pourtant par considérer que ce modèle conserve trop étroitement la structure des ordinateurs à programme enregistré.
Dans sa conférence du prix Turing de 1977, Can Programming Be Liberated from the von Neumann Style?, il critique ce qu’il appelle le goulot d’étranglement de von Neumann. Les programmes déplacent continuellement des valeurs entre processeur et mémoire, et leur raisonnement dépend d’une succession de changements d’état.
Backus présente FP, un système fondé sur la composition de fonctions. Au lieu de détailler chaque mise à jour, le programme combine des transformations. L’objectif est de rendre les propriétés du calcul plus faciles à comprendre et à raisonner mathématiquement.
FP ne remplace pas les langages impératifs. Son importance est intellectuelle : l’homme qui a dirigé l’un de leurs premiers grands succès montre aussi leurs limites. Cette critique rejoint une autre branche ouverte par le Lisp de John McCarthy, où fonctions et récursion occupent déjà une place centrale.
Composer des programmes plutôt que gérer chaque état
La proposition de Backus ne consiste pas simplement à ajouter des fonctions à un langage impératif. Dans FP, les fonctions sont combinées au moyen de formes fonctionnelles : composition, construction de paires, application d’une opération à tous les éléments ou réduction d’une suite vers une valeur.
Imaginons une liste de nombres dont on veut calculer la somme des carrés. Une écriture impérative crée un total, parcourt la liste, met le total à jour puis renvoie sa valeur. Une écriture par composition décrit trois transformations : élever chaque nombre au carré, puis combiner les résultats par addition. Le calcul est présenté par ses relations plutôt que par l’ordre détaillé des affectations.
Backus espère qu’une telle organisation permettra de raisonner sur les programmes au moyen de règles algébriques. Si deux compositions sont équivalentes, l’une peut remplacer l’autre sans suivre mentalement tous les états intermédiaires. Cette ambition préfigure des techniques modernes d’optimisation des chaînes de données et de parallélisation, même si FP lui-même reste peu adopté.
Sa critique vise donc autant l’architecture intellectuelle des programmes que le débit entre processeur et mémoire. Le « style de von Neumann » encourage, selon lui, des langages construits autour d’une cellule mémoire modifiée instruction après instruction. Changer de niveau d’abstraction suppose de donner la priorité aux transformations et à leur composition.
Un héritage qui dépasse FORTRAN
Backus reçoit le prix Turing en 1977 pour ses contributions aux langages de haut niveau, à leurs systèmes de compilation et à leur spécification. Il poursuit ses recherches comme IBM Fellow jusqu’à sa retraite en 1991 et meurt en 2007.
Son héritage relie trois niveaux souvent étudiés séparément. FORTRAN montre qu’un langage plus abstrait peut produire du code performant. La BNF permet de définir précisément la forme de ce langage. FP demande enfin si la manière dominante d’écrire les programmes est réellement la meilleure.
Les compilateurs modernes prolongent le premier problème en optimisant des langages bien plus riches. Les grammaires formelles prolongent le deuxième dans les analyseurs et les standards. La programmation fonctionnelle prolonge le troisième en limitant les changements d’état et en composant des transformations.
Backus n’a donc pas seulement rapproché le code des mathématiques. Il a successivement interrogé la traduction, la description et la structure même des programmes.
Chronologie
- 1924 : naissance de John Warner Backus à Philadelphie.
- 1950 : master de mathématiques à Columbia et entrée chez IBM.
- Début des années 1950 : développement de Speedcoding pour l’IBM 701.
- 1953 : proposition d’un système de traduction de formules pour l’IBM 704.
- 1954 : constitution de l’équipe chargée de FORTRAN.
- 1957 : livraison du premier compilateur FORTRAN.
- 1958–1960 : contribution aux travaux sur ALGOL et à la notation qui deviendra la BNF.
- 1963 : nomination comme IBM Fellow.
- 1977 : prix Turing et conférence sur les limites du style de von Neumann.
- 1978 : publication dans les Communications of the ACM de sa conférence et de sa présentation du système FP.
- Années 1970–1980 : recherches sur FP et la programmation fonctionnelle.
- 1991 : retraite d’IBM.
- 2007 : décès à Ashland, dans l’Oregon.
- Aujourd’hui : FORTRAN, les grammaires formelles et la composition fonctionnelle prolongent trois dimensions de son travail.
Questions fréquentes
John Backus a-t-il créé FORTRAN seul ?
Non. Il propose le projet et dirige l’équipe IBM, mais le langage et son compilateur sont une réalisation collective. Les différentes compétences de l’équipe ont permis de produire un code suffisamment performant pour convaincre les utilisateurs.
Pourquoi le premier compilateur FORTRAN était-il si important ?
Un langage plus lisible n’aurait pas été adopté si ses programmes avaient été beaucoup plus lents que l’assembleur. Les optimisations du compilateur ont montré qu’une traduction automatique pouvait offrir à la fois productivité et performances.
Backus a-t-il inventé la BNF seul ?
Il propose la notation initiale pour décrire ALGOL. Peter Naur l’adapte pour le rapport ALGOL 60. Le nom « forme de Backus-Naur » reconnaît cette succession de contributions.
FORTRAN est-il encore utilisé ?
Oui. Ses versions modernes restent présentes dans le calcul scientifique et les logiciels où existent de grandes bibliothèques numériques éprouvées. Le langage actuel diffère fortement de celui de 1957.
Pourquoi Backus a-t-il critiqué la programmation impérative ?
Il estimait que les programmes centrés sur la modification de la mémoire étaient difficiles à combiner et à raisonner. FP explorait une approche fondée sur la composition de fonctions plutôt que sur une suite d’affectations.
Quel lien existe entre Backus et Grace Hopper ?
Leurs équipes cherchent toutes deux à éloigner les programmeurs du code machine. FORTRAN vise d’abord le calcul scientifique ; FLOW-MATIC et COBOL visent surtout le traitement des données commerciales.
