Histoire des langages de programmation

Restez toujours informé : suivez-nous sur Google (☆)

Introduction

Cet article évoque les événements majeurs de l'histoire des langages de programmation. Pour une chronologie détaillée de ces événements, consultez la chronologie des langages de programmation.

Avant 1940

Les premiers langages de programmation précèdent l'ordinateur moderne. Au départ, les langages étaient de simples codes.

Pendant neuf mois entre 1842 et 1843, Ada Lovelace a traduit le mémoire du mathématicien italien Luigi Menabrea sur la Machine analytique, la dernière machine proposée par Charles Babbage. Elle ajouta cet article à une collection de notes dans lesquelles elle détaillait une méthode pour calculer les nombres de Bernouilli à l'aide de la Machine. Ces notes furent reconnues par certains historiens comme le premier programme informatique au monde Mais l'étendue des contributions originales d'Ada Lovelace, comparées à celles de son mari, est l'objet de débat parmi certains biographes..

En 1801, le métier Jacquard utilisait des trous dans des cartes perforées pour représenter les mouvements du bras du métier à tisser, et ainsi générer automatiquement des motifs décoratifs.

En observant les tickets de trains, où était décrite l'apparence du voyageur à l'aide de trous perforés sur les tickets (couleur des cheveux et des yeux, taille...), Herman Hollerith s'est rendu compte qu'il pouvait encoder de l'information sur des cartes perforées. Il a pu ainsi créer une machine à cartes perforées qui a servi au recensement de 1890.

À leurs débuts, les langages de programmation étaient très influencés par les restrictions matérielles. De ce fait, le premier vrai langage de programmation est difficile à identifier. Par exemple, les cartes perforées pouvaient avoir 80 colonnes, certaines d'entre elles étant utilisées comme numéro de tri sur chaque carte. Plus tard, les mémoires utilisées dans les premiers ordinateurs étaient faites de tambours magnétiques. Les programmes devaient donc tenir compte des rotations du tambour. Ils étaient donc beaucoup plus dépendants du matériel qu'à l'heure actuelle.

Pour certaines personnes, il est nécessaire que les « programmes » soient facilement lisibles par des êtres humains, et que la puissance mise en œuvre soit suffisante, pour pouvoir parler de langage de programmation. Le Métier Jacquart et la Machine Analytique de Charles Babbage avaient des langages extrêmement simples et limités pour décrire les actions effectuées par ces machines. On peut également considérer les rouleaux en papier d'un pianola (piano mécanique) comme un programme limité à un domaine très particulier, quoique non destiné à être exploité par des humains.

Les années 1940

Les premiers ordinateurs électriques de l'ère moderne sont apparus dans les années 1940. Les limitations en rapidité et en capacité de mémoire imposent une écriture des programmes laborieuse en langage assembleur voire langage machine, optimisés « à la main ». On constate très vite qu'en plus de nécessiter beaucoup d'effort intellectuel, cette manière de programmer engendre pas mal d'erreurs.

En 1948, Konrad Zuse publie un article sur son langage de programmation qu'il a développé entre 1943 et 1945 : le Plankalkül. Son créateur le considère comme étant le premier langage de programmation de haut niveau. Néanmoins, il n'aura jamais été implémenté à l'époque et les contributions de l'auteur sont d'ailleurs restées très isolées du courant dominant.

Parmi les langages importants développés à cette période on peut citer :

  • 1943 : Le Plankalkül
  • 1943 : Le langage de programmation de l'ENIAC
  • 1949 : Le langage C-10

Les années 1950 et 1960

Dans les années 1950, les trois premiers langages de programmation modernes ont été conçus :

  • FORTRAN, le traducteur de formules (FORmula TRANslator), inventé par John Backus et al.
  • LISP, spécialisé dans le traitement des listes (LISt Processor), inventé par John McCarthy et al.
  • COBOL, spécialisé dans la programmation d'application de gestion (COmmon Business Oriented Language), créé par le Short Range Committee dans lequel on retrouve entre autres Grace Hopper

Les descendants de ces trois langages sont actuellement encore très utilisés.

Une autre étape clé de ces années a été la publication à Zurich par une commission d'informaticiens européens et américains d'un nouveau langage permettant de décrire les problèmes de manière algorithmique : ALGOL (ALGorithmic Oriented Language). Le rapport, publié pour la première fois en 1958 fait la synthèse des principales idées circulant à l'époque, et propose deux innovations majeures :

  • Structure en blocs imbriqués : le programme peut être structuré en morceaux de codes logiques sans avoir besoin de donner un nom explicite à ce bloc de code ; on pourrait rapprocher cette notion du paragraphe dans le monde littéraire.
  • Notion de Portée : un bloc peut manipuler des variables qui lui sont propres ; aucun code en dehors de ce bloc ne peut y accéder, et encore moins les manipuler.

La manière-même dont le langage a été décrit est innovante en soi : la syntaxe du langage a été décrite de manière mathématique, en utilisant le métalangage BNF. Presque tous les langages à venir utiliseront une variante de cette notation BNF pour décrire leur syntaxe (ou au-moins la sous-partie non-contextuelle de leur syntaxe).

Algol 60 est particulièrement influent pour la conception de langages ultérieurs. Certains d'entre eux sont rapidement devenus populaires. Par exemple les systèmes industriels de Burroughs sont conçus pour être programmés via un sous-ensemble d'Algol étendu.

Les idées essentielles d'Algol se retrouvent finalement dans Algol 68 :

  • La syntaxe et la sémantique deviennent encore plus orthogonales, avec des procédures anonymes, un système de types récursifs, des fonctions d'ordre supérieur...
  • Toute la syntaxe et la sémantique du langage sont décrites formellement, et plus seulement la partie non-contextuelle de la syntaxe. Un formalisme conçu spécialement dans ce but a été créé : la grammaire van Wijngaarden.

Certaines fonctionnalités peu utilisées d' Algol 68 (comme la concurrence et les blocs parallèles) ainsi que ses systèmes complexes de raccourcis syntaxiques, et de transtypage automatique, l'ont rendu impopulaire auprès des programmeurs chargés de l'utiliser. On le dit difficile d'accès. Un certain Niklaus Wirth abandonne alors la commission de conception d' Algol, et à partir de ses travaux sur Algol-W (pour Wirth) créera un langage plus simple, le Pascal.

Vue d'ensemble :

  • 1951 - Regional Assembly Language
  • 1952 - AUTOCODE
  • 1954 - FORTRAN
  • 1955 - FLOW-MATIC, ou encore B-0 (Business Language version 0) [ancêtre de COBOL]
  • 1957 - COMTRAN (COMmercial TRANslator) [ancêtre de COBOL]
  • 1958 - LISP
  • 1958 - ALGOL 58
  • 1959 - FACT (Fully Automated Compiling Technique) [ancêtre de COBOL]
  • 1959 - COBOL
  • 1962 - APL (A Programming Language)
  • 1962 - Simula I (Simple universal language)
  • 1964 - BASIC (Beginner's All-purpose Symbolic Instruction Code)
  • 1964 - PL/I (Programming Language number 1)

1967 à 1978 : mise en place des paradigmes fondamentaux

La période courant de la fin des années 1960 à la fin des années 1970 a vu un véritable foisonnement des langages de programmation. La plupart des paradigmes des principaux langages sont inventés durant cette période :

Chacun de ces langages, a donné naissance à toute une famille de descendants, et la plupart des langues modernes comptent au-moins l'un d'entre eux dans son ascendance. Les années 1960 et 1970 ont également été l'époque d'un considérable débat sur le bien-fondé de la programmation structurée, qui signifie essentiellement la programmation sans l'utilisation de GOTO. Ce débat a été étroitement lié à la conception de langages : certaines langages n'intégrant pas GOTO, beaucoup sont donc contraints d'utiliser la programmation structurée. Bien que ce débat a fait rage à l'époque, désormais un très large consensus existe parmi les programmeurs : même dans des langages qui intègrent GOTO, utiliser cette instruction est devenu quasiment tabou, sauf dans de rares circonstances.

Certains autres langages importants ont été développés au cours de cette période dont :

  • 1970 - Pascal
  • 1970 - Forth
  • 1972 - C
  • 1972 - Smalltalk
  • 1972 - Prolog
  • 1973 - ML
  • 1978 - SQL (Structured Query Language), au départ seulement un langage de requêtes, puis étendu par la suite à la construction de programme procédural de type SQL/PSM, PL/SQL,...

Les années 1980 : consolidation, modules, performance

Certaines langages importants ont été développés au cours de cette période : les années 1980 furent des années d'une relative consolidation. C++ combine la programmation système et orientée-objet. Le gouvernement des États-Unis normalise Ada, un langage de programmation système destiné à être utilisés par les sous-traitants de la défense.

Au Japon et ailleurs, des sommes énormes ont été dépensées pour étudier ce qu'on appelle les langages de "cinquième génération" des langages qui intègrent la logique de construction des programmes.

Les groupes de langages fonctionnels continuent à normaliser ML et Lisp ces idées élaborées et inventées pendant la décennie précédente plutôt que d'inventer de nouveaux modèles.

Toutefois, une nouvelle tendance importante dans la conception de langage fut est de mettre davantage l'accent sur la programmation pour une large gamme de systèmes grâce à l'utilisation de modules, ou à des unités de code organisationnels de large échelle. Modula, Ada, et ML ont tous mis au point d'éminents modules systèmes dans les années 1980.

Les module systèmes étaient souvent rattachés à la construction de programmes générique — générique étant, en substance, des modules paramétrés (voir aussi le polymorphisme paramétrique).

Bien que des nouveaux modèles de langages de programmation ne semblent pas avoir apparu, de nombreux chercheurs ont développé sur les idées des langages précédent et les ont adaptés à de nouveaux contextes. Par exemple, les langages systèmes de Argus and Emerald adaptés à la programmation orientée-objet pour les systèmes distribués.

Les années 1980 ont également apporté des progrès dans la mise en œuvre des langages de programmation. Le mouvement RISC dans l'architecture des ordinateurs a postulé que le matériel devait être conçu pour les compilateurs plutôt que pour les programmeurs en assembleur. Aidés par les progrès en vitesse des processeurs qui a permis des améliorations de plus en plus agressive les techniques de compilation, le mouvement RISC a suscité plus d'intérêt dans la technologie de compilation des langages de haut niveau.

La technologie des langage a continué sur cette lignée jusque dans les années 1990.

Certains langages importants qui ont été développés au cours de cette période comprenant :

  • 1983 - Ada
  • 1983 - C++
  • 1985 - Eiffel
  • 1987 - Perl
  • 1989 - FP (Backus)

Les années 1990 : l'ère Internet

Les années 1990 voient peu de nouveautés fondamentales apparaître. Au contraire, beaucoup d'idées anciennes sont combinées et portées à maturité, dans l'objectif principal d'augmenter la productivité du programmeur. Beaucoup de langages "développement rapide d'application" (RAD : rapid application development) apparaissent. Ce sont souvent des descendants de langages plus anciens. Ils sont généralement, orientés objet, et fournis avec un environnement de développement intégré ainsi qu'avec un ramasse-miettes (récupération d'emplacements en mémoire qui ne sont plus utilisés par le système, mise à jour des tables d'allocation de mémoire). C'est ainsi que sont apparus Object Pascal, Visual Basic et C#. Java est un langage plus conservateur qui implémente également le ramasse-miettes, et a été un important centre d'intérêt.

Les nouveaux langages de script ont une approche plus novatrice et aussi plus radicale. Ceux-ci ne descendent pas directement d'autres langages : ils présentent de nouvelles syntaxes et de nouvelles fonctionnalités leur sont incorporés de manière plus souple. Beaucoup considèrent que ces langages de script sont plus productifs que les langages RAD. Cependant, si les programmes les plus petits sont effectivement plus simples, on peut considérer que des programmes plus gros seront plus difficiles à mettre en œuvre et à maintenir [Citation nécessaire]. En dépit de ces raisons, les langages de script sont devenus les plus utilisés dans un contexte Web.

Quelques langages importants ayant été développés cours de cette période :

Tendances actuelles

L'évolution des langages de programmation continue, à la fois dans l'industrie et la recherche. Quelques tendances actuelles :

  • Ajouter de sécurité et de sûreté, notamment dans la vérification du langage (analyse statique de programmes), dans le contrôle du flux d'information (format des entrées/sorties) et dans la protection lors de l'exécution de threads simultanés (threadsafe).
  • Nouveaux concepts concernant la modularité : les mixin, la délégation, la programmation orientée aspect.
  • Le développement orienté composant.
  • La métaprogrammation, et en particulier la réflexivité ou la manipulation de l'arbre syntaxique abstrait.
  • Concentration sur la distribution et la mobilité.
  • Intégration avec les bases de données, en particulier les bases de données relationnelles et XML.
  • Internationalisation avec le support de l'Unicode dans le code source : possibilité d'utiliser des caractères spéciaux (autres que ASCII) dans le code source.
  • Utilisation généralisée d'XML, notamment pour les interfaces graphiques (XUL, XAML).

Personnalités importantes dans l'histoire des langages de programmation