Histoire des langages de programmation

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

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[modifier | modifier le code]

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[1] Mais l'étendue des contributions originales d'Ada Lovelace, comparées à celles de son mari, est l'objet de débat parmi certains biographes.[réf. souhaitée].

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[modifier | modifier le code]

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 un certain nombre 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 :

Les années 1950 et 1960[modifier | modifier le code]

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 eut une influence particulière sur 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 de van Wijngaarden (en).

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 ; aussi est-il réputé 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[modifier | modifier le code]

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 : certains langages n'intégrant pas GOTO, beaucoup sont donc contraints d'utiliser la programmation structurée. Bien que ce débat ait fait rage à l'époque, un très large consensus existe désormais 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, héritier d'Algol plus convivial
  • 1970 - Forth
  • 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[modifier | modifier le code]

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 dans la construction des programmes.

Les groupes de langages fonctionnels continuent à normaliser ML et Lisp, élaborés pendant la décennie précédente plutôt que d'inventer de nouveaux modèles. De nombreux chercheurs ont développé les idées des langages précédents 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.

Une nouvelle tendance dans la conception des langages, comme Modula, Ada, et ML, met l'accent sur la programmation pour une large gamme d'applications grâce à l'utilisation de modules. Ce sont des unités de programmes paramétrables, qui peuvent donc être largement réutilisés. Les modules sont la première forme de programmes génériques, qui se développeront avec le polymorphisme paramétrique dans les langages à objets.

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 faciliter l'écriture des 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 agressives des techniques de compilation, le mouvement RISC a permis des évolutions dans la technologie de compilation des langages de haut niveau jusque dans les années 1990.

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

Les années 1990 : l'ère Internet[modifier | modifier le code]

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é, pour augmenter la productivité des programmeurs et la fiabilité des programmes. Beaucoup de langages pour le « développement rapide d'applications » (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 (mise à jour des tables d'allocation de mémoire pour récupérer les emplacements qui ne sont plus utilisés). C'est ainsi que sont apparus Pascal Objet, Visual Basic et C#.

Java, de Sun Microsystem est un langage comportant une large palette de classes réutilisables. Il possède un ramasse-miettes. Il a eu un développement important dans l'industrie du logiciel.

Les nouveaux langages de scripts, héritiers des langages de commande intégrés dans les systèmes d'exploitation, ont une approche plus novatrice parce qu'ils sont interprétés. Certains sont intégrés dans des pages Web. Ils présentent de nouvelles caractéristiques syntaxiques et de nouvelles fonctionnalités leur sont incorporées de manière à faciliter l'enchaînement de commandes simples. Ils fonctionnent bien quand les programmes sont petits. Les programmes plus gros sont plus difficiles à mettre en œuvre et à maintenir que des programmes compilés analogues [citation nécessaire].

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

Tendances actuelles[modifier | modifier le code]

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

  1. 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).
  2. Nouveaux concepts concernant la modularité : les mixin, la délégation, la programmation orientée aspect.
  3. Le développement orienté composant.
  4. La métaprogrammation, et en particulier la réflexivité ou la manipulation de l'arbre syntaxique abstrait.
  5. Concentration sur la distribution et la mobilité.
  6. Intégration avec les bases de données, en particulier les bases de données relationnelles et XML.
  7. Internationalisation avec le support de l'Unicode dans le code source : possibilité d'utiliser différents caractères dans le code source (en dépassant les limites de l'ASCII).
  8. Utilisation généralisée d'XML, notamment pour les interfaces graphiques (XUL, XAML).

Personnalités importantes dans l'histoire des langages de programmation[modifier | modifier le code]

Références[modifier | modifier le code]

  1. (en) J. Fuegi et J. Francis, « Lovelace & Babbage and the creation of the 1843 'notes'. », Annals of the History of Computing, vol. 25, no 4,‎ octobre-décembre 2003, p. 19-25 (ISSN 10.1109/MAHC.2003.1253887)

(en) Cet article est partiellement ou en totalité issu de l’article de Wikipédia en anglais intitulé « History of programming languages  » (voir la liste des auteurs)

Voir aussi[modifier | modifier le code]

Articles connexes[modifier | modifier le code]