Histoire des langages de programmation : pourquoi ont-ils évolué ?

Au début des années 1950, écrire un programme exige de connaître intimement l’ordinateur qui doit l’exécuter. Ses instructions, ses registres et l’organisation de sa mémoire dictent une grande partie du travail. Quelques décennies plus tard, un étudiant peut programmer un jeu en BASIC, une entreprise gérer ses comptes en COBOL et un développeur créer un site en JavaScript ou en PHP. Ce ne sont pas seulement les machines qui ont changé : la manière de leur donner des instructions s’est transformée.

On raconte souvent l’histoire des langages de programmation comme une succession de noms et de dates. Pourtant, leur apparition suit une logique plus intéressante. À chaque époque, les programmeurs rencontrent des obstacles : écrire les calculs plus vite, traiter des fichiers, enseigner l’informatique, organiser des logiciels volumineux ou faire fonctionner une application sur des machines différentes. De nouveaux langages naissent pour répondre à ces besoins. Les anciens, eux, ne disparaissent pas nécessairement.

Parler le langage de la machine

Un processeur exécute des instructions définies par son architecture : charger une valeur, effectuer une addition, comparer deux nombres ou poursuivre l’exécution à une autre adresse. Ces instructions sont représentées par des codes numériques. Dans les premiers ordinateurs, le programmeur doit maîtriser cette mécanique, parfois jusqu’à calculer lui-même des adresses mémoire.

L’assembleur apporte une première amélioration : des noms symboliques remplacent certains codes numériques et des étiquettes permettent de désigner des emplacements du programme. Un logiciel, lui-même appelé assembleur, transforme ensuite ces indications en instructions exécutables. Mais l’essentiel reste attaché à un processeur précis. Un programme écrit pour une machine ne fonctionne pas automatiquement sur une autre.

À mesure que les projets grandissent, cette proximité avec le matériel devient coûteuse. Il faut du temps pour écrire, vérifier et corriger les programmes. Surtout, de nombreuses tâches semblent inutilement répétitives. Pourquoi demander à un humain de convertir chaque opération en instructions élémentaires, alors qu’un programme pourrait effectuer cette traduction ?

Dans les années 1950, plusieurs équipes explorent la programmation automatique. Grace Hopper développe notamment le système A-0 pour automatiser l’utilisation de sous-programmes. Chez IBM, Speedcoding simplifie certains calculs scientifiques, au prix d’une exécution moins efficace. Ces outils ne sont pas encore les langages généralistes modernes, mais ils déplacent déjà une partie du travail du programmeur vers la machine.

Le changement décisif sera de pouvoir décrire davantage le problème à résoudre et moins les détails du processeur. Un compilateur traduit alors un programme écrit dans un langage plus abstrait en code adapté à une machine. D’autres environnements permettent une exécution interprétée, instruction par instruction ou à l’aide de représentations intermédiaires. Dans les deux cas, un logiciel sert d’intermédiaire entre les intentions humaines et l’ordinateur.

Années 1950 : les scientifiques et les entreprises n’ont pas les mêmes besoins

Cette nouvelle liberté fait apparaître une évidence : tous les utilisateurs ne demandent pas la même chose à leurs ordinateurs. Les scientifiques veulent calculer ; les administrations et les entreprises doivent traiter d’immenses quantités de données. Un seul langage ne répond pas nécessairement aussi bien à ces deux mondes.

FORTRAN : laisser les scientifiques écrire des formules

Chez IBM, l’équipe de John Backus s’attaque au coût de la programmation scientifique. Sur l’IBM 704, les ingénieurs souhaitent exprimer directement des calculs plutôt que d’en détailler chaque instruction machine. Le FORTRAN, diffusé à partir de 1957, offre une écriture proche des formules mathématiques.

L’enjeu n’est pas seulement la lisibilité : le programme obtenu doit rester rapide. À l’époque, beaucoup doutent qu’un compilateur puisse produire un code comparable à celui d’un spécialiste de l’assembleur. L’efficacité du compilateur FORTRAN contribue à lever cette objection. Des physiciens, des ingénieurs et des mathématiciens peuvent consacrer davantage de temps à leurs modèles et moins à leur traduction en instructions.

COBOL : traiter des dossiers plutôt que des équations

Une compagnie d’assurance ne manipule pas principalement des trajectoires ou des équations. Elle gère des clients, des contrats, des montants et des fichiers. Les programmes doivent durer, être compris par plusieurs équipes et, si possible, survivre au remplacement d’un ordinateur.

Des projets comme FLOW-MATIC, développé par l’équipe de Grace Hopper, explorent des instructions proches de l’anglais. Le COBOL, élaboré collectivement à partir de 1959, poursuit cette orientation. Il place les enregistrements, les fichiers et les opérations de gestion au centre du langage. Sa standardisation cherche aussi à réduire la dépendance envers un constructeur.

FORTRAN et COBOL ne représentent donc pas deux étapes où l’un remplacerait l’autre. Ils répondent à des besoins différents qui coexistent : le calcul scientifique d’un côté, la gestion administrative de l’autre.

Lisp : quand les données ne sont plus seulement des nombres

À la même période, une autre difficulté apparaît dans les recherches en intelligence artificielle. Comment faire manipuler à l’ordinateur des symboles, des expressions ou des structures qui s’emboîtent les unes dans les autres ? À partir de 1958, John McCarthy développe Lisp, dont les listes et les fonctions se prêtent particulièrement bien à ces travaux.

Lisp explore une manière de programmer où les fonctions peuvent elles-mêmes être manipulées comme des valeurs. Il contribue ainsi à diffuser des idées associées à la programmation fonctionnelle. Ce paradigme ne consiste pas à abandonner tout calcul classique, mais à exprimer un traitement en combinant des fonctions, souvent en limitant les modifications d’état. Le langage propose une autre manière de représenter un problème.

Années 1960-1970 : rendre la programmation accessible et les programmes compréhensibles

Les langages de haut niveau facilitent le travail des professionnels, mais programmer reste longtemps une activité réservée à des spécialistes. À Dartmouth College, John Kemeny et Thomas Kurtz souhaitent ouvrir l’ordinateur à des étudiants d’autres disciplines. Le BASIC, mis en service le 1er mai 1964 avec un système à temps partagé, répond à cette ambition.

Ses instructions simples ne suffiraient pas, à elles seules, à expliquer son succès. Le temps partagé permet surtout d’écrire un programme à un terminal, de le lancer et d’observer rapidement le résultat. L’apprentissage devient une succession d’essais et de corrections. Dans les années 1970 et 1980, le BASIC accompagnera ensuite des micro-ordinateurs comme l’Apple II, le ZX81 ou l’Amstrad CPC. Pour beaucoup d’utilisateurs, allumer un ordinateur signifie aussi pouvoir le programmer.

Mais la simplicité des premiers programmes ne résout pas une difficulté croissante : comment comprendre et modifier un logiciel de plusieurs milliers de lignes ? Lorsque les branchements se multiplient dans tous les sens, suivre son fonctionnement peut devenir un casse-tête.

Avec ALGOL 60, la programmation dispose d’une expression plus rigoureuse des blocs de code, des procédures et de la portée des variables. La réflexion sur la programmation structurée encourage ensuite l’usage de séquences, de conditions et de boucles organisées plutôt que l’accumulation de sauts difficiles à suivre. Le Pascal, présenté par Niklaus Wirth en 1970, prolonge cette recherche de clarté : il permet aussi d’enseigner la construction méthodique des programmes.

Dans le même temps, les systèmes d’exploitation posent un problème un peu différent. Ils ont besoin de rester proches du matériel, mais leur écriture en assembleur les rend difficiles à adapter à de nouveaux processeurs. Aux Bell Labs, Dennis Ritchie développe le langage C en 1972 (son développement s’étend de 1969 à 1973, avec une période particulièrement décisive en 1972), à partir du langage B de Ken Thompson. Le C permet de conserver un contrôle précis sur la mémoire et les données, tout en facilitant l’écriture de programmes moins dépendants d’une architecture particulière.

La réécriture d’une grande partie d’UNIX en C en 1973 illustre cette évolution : porter un système vers une autre architecture devient plus réaliste, même si certaines parties doivent toujours être adaptées. Le Pascal privilégie la lisibilité et l’enseignement ; le C répond notamment à l’exigence d’un logiciel système efficace et plus portable. Aucun n’efface les autres.

Années 1970-1980 : les logiciels deviennent trop vastes pour être pensés comme un seul bloc

Quand les applications grandissent, un autre obstacle se présente. Une banque, une usine ou un logiciel graphique comporte de nombreuses entités qui évoluent et interagissent. Il ne suffit plus de décrire la suite des calculs : il faut organiser les informations, répartir les responsabilités et limiter les conséquences d’une modification.

Les travaux norvégiens d’Ole-Johan Dahl et Kristen Nygaard sur Simula, notamment Simula 67, apportent les notions de classes et d’objets à la simulation. Une entité du programme peut réunir des données et les opérations qui les concernent. Au Xerox PARC, Smalltalk, développé à partir de 1972 autour d’Alan Kay, Dan Ingalls et leurs collègues, pousse beaucoup plus loin cette approche dans un environnement interactif et graphique.

Pour saisir l’idée, imaginons une application de bibliothèque. Une approche procédurale organise le traitement en fonctions : enregistrer un prêt, calculer une date de retour, vérifier une disponibilité. Une approche orientée objet peut représenter un livre, un emprunt ou un lecteur comme des objets possédant leurs informations et des comportements associés. Ce ne sont pas deux façons incompatibles de programmer ; elles mettent simplement l’accent sur des organisations différentes.

Dans les années 1980, Bjarne Stroustrup développe le C++ pour combiner des mécanismes de structuration inspirés notamment de Simula avec les performances et la maîtrise du matériel associées au C. Parallèlement, Ada répond à une préoccupation forte des grands projets, notamment dans les systèmes critiques : contrôler plus rigoureusement les types, les interfaces et la fiabilité des logiciels.

La programmation évolue donc dans plusieurs directions à la fois : mieux organiser le code, mieux maîtriser sa complexité et réduire certains risques d’erreur.

Années 1990 : les langages s’adaptent au réseau et au Web

L’arrivée des ordinateurs personnels a multiplié les utilisateurs. Avec le développement des réseaux et du Web, les programmes doivent désormais circuler entre des systèmes variés et interagir avec des personnes à distance. La vitesse de développement compte autant que la puissance des machines.

En 1991, Guido van Rossum rend disponibles les premières versions de Python, développé aux Pays-Bas dans le prolongement du langage ABC. Sa syntaxe lisible et son environnement interactif facilitent l’écriture de petits outils, l’automatisation et, plus tard, de nombreuses applications scientifiques. Son succès futur reposera aussi largement sur l’extension de ses bibliothèques et de sa communauté : un langage utile ne se réduit pas à sa grammaire.

Avec Java, présenté publiquement en 1995 après un projet initialement destiné à des équipements électroniques, la portabilité prend une autre forme. Au lieu de produire directement un programme pour chaque processeur, le compilateur fournit un code intermédiaire, le bytecode, exécuté par une machine virtuelle Java. L’objectif est de limiter les adaptations nécessaires d’une plateforme à l’autre, même si les bibliothèques et les environnements restent déterminants.

Le Web, lui, fait apparaître deux besoins complémentaires. Une page HTML peut présenter des informations, mais comment la rendre réactive aux actions de son lecteur ? Chez Netscape, Brendan Eich conçoit JavaScript en 1995 pour exécuter des scripts dans le navigateur. Malgré son nom, JavaScript n’est pas une déclinaison de Java.

Et comment produire une page dont le contenu dépend d’un formulaire, d’un compte utilisateur ou d’une base de données ? Des outils exécutés côté serveur répondent à cette nécessité. PHP naît des outils développés par Rasmus Lerdorf en 1994, rendus publics en 1995, puis évolue vers un langage permettant de construire des sites dynamiques.

La distinction est concrète : JavaScript peut réagir immédiatement à une action dans le navigateur, tandis que PHP peut traiter une demande sur le serveur et préparer une réponse. Le Web ne crée pas un langage unique ; il favorise un ensemble d’outils complémentaires, chacun adapté à une partie de l’application.

Aujourd’hui : sécurité, coopération et nouveaux compromis

L’histoire ne s’arrête pas aux années 1990. Les logiciels s’exécutent sur des téléphones, des serveurs, des objets connectés et des infrastructures distribuées. Ils sont développés par des équipes parfois dispersées dans le monde entier. Les erreurs de mémoire, les difficultés de maintenance et la concurrence entre tâches prennent davantage d’importance.

De nouveaux langages tentent de répondre à ces contraintes. Go met l’accent sur la simplicité des outils et sur les services exécutant de nombreuses tâches simultanément. Rust cherche à prévenir, dès la compilation, plusieurs catégories d’erreurs liées à la gestion de la mémoire, sans imposer de ramasse-miettes. Dans le même temps, Python, JavaScript, Java, C, C++, COBOL ou FORTRAN continuent d’évoluer et de répondre à des usages parfois très spécialisés.

Il serait donc trompeur de voir l’histoire des langages comme une course dans laquelle chaque nouveau venu remplace le précédent. Une simulation scientifique écrite en FORTRAN, une application de gestion en COBOL et un service réseau en Go peuvent tous être de bons choix selon les contraintes, les compétences disponibles et le coût de maintenance.

Il faut aussi distinguer la date de conception, la première version disponible et la diffusion à grande échelle d’un langage. Ces étapes peuvent être séparées de plusieurs années, voire de plusieurs décennies. BASIC, par exemple, naît à Dartmouth en 1964, mais devient particulièrement visible du grand public avec les micro-ordinateurs des années 1970 et 1980.

Ce que l’histoire des langages nous apprend

De l’assembleur à JavaScript, l’histoire des langages de programmation suit une même ambition : permettre aux humains d’exprimer leurs intentions sans devoir maîtriser chaque détail du fonctionnement des machines. Chaque langage est apparu pour répondre à des besoins particuliers : calcul scientifique, gestion, enseignement, développement de systèmes ou applications Web.

Mais l’intelligence artificielle pourrait aujourd’hui bouleverser cette évolution. Désormais, il devient possible de décrire un problème en langage naturel et de laisser une IA produire le programme correspondant. Une nouvelle question apparaît : faudra-t-il encore apprendre à coder pour programmer ?

Les langages ne vont probablement pas disparaître. L’ordinateur aura toujours besoin d’instructions précises, et les programmes générés devront être compris, vérifiés et corrigés. En revanche, le rôle du programmeur pourrait évoluer : moins écrire chaque instruction, davantage concevoir, expliquer et contrôler.

Au fond, depuis les premiers langages jusqu’aux IA génératives, l’objectif reste le même : réussir à se faire comprendre des machines.

Et si l’avenir de la programmation consistait moins à apprendre leur langage qu’à leur apprendre à comprendre le nôtre ?

Sources historiques et documents de référence

• IBM — Fortran : contexte de la programmation automatique et objectifs du compilateur de John Backus.
• Computer History Museum — Software & Languages Timeline : repères historiques sur les langages et leurs premiers usages.
• Dartmouth College — BASIC Begins at Dartmouth : naissance du BASIC et lien avec le temps partagé en 1964.
• Computer History Museum — Smalltalk at 50 : développement de Smalltalk à Xerox PARC à partir de 1972.
• Bjarne Stroustrup — A History of C++: 1979–1991 : naissance du C++ et motivations de son concepteur.
• Documentation Python — Histoire du logiciel : origine de Python et influence du langage ABC.
• Java Language Specification — Préface : origine d’Oak et objectifs de portabilité de Java.
• MDN — Présentation de JavaScript : création du langage chez Netscape.
• Manuel officiel PHP — Histoire de PHP : outils de Rasmus Lerdorf et diffusion publique en 1995.
• Go — FAQ officielle et Rust — Understanding Ownership : motivations de conception de langages plus récents.