Histoire des langages de programmation

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 Bernoulli à 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[2].

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 constitués 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 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 :

• 1943 : Le Plankalkül
• 1943 : Le langage de programmation de l'ENIAC
• 1948 : Le langage machine du premier programme enregistré, i.e. le jeu d'instructions de la SSEM : première machine à programme enregistré.
• 1949 : Le langage C-10

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.

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)

La période courant de la fin des années 1960 au début 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 :

• Simula 67, inventé par Nygaard et Dahl comme surcouche d'Algol 60, est le premier langage conçu pour pouvoir intégrer la programmation orientée objet et la simulation par événements discrets.
• C, un des premiers langages de programmation système, est développé par Dennis Ritchie et Ken Thompson pour le développement d'Unix aux laboratoires Bell entre 1969 et 1973.
• Smalltalk (milieu des années 1970) est l'un des premiers langages de programmation à disposer d'un environnement de développement intégré complètement graphique.
• Prolog (PROgrammation LOGique), défini en 1972 par Colmerauer, Roussel et Kowalski (en) est le premier langage de programmation logique.
• ML (Meta Language) inventé par Robin Milner en 1973, construit sur un typage statique fort et polymorphe au-dessus de Lisp, pionnier du langage de programmation généraliste fonctionnel.

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
• 1971 - LSE (Langage Symbolique d'Enseignement), pour l'expérimentation de l'informatique sur l'opération dite « Expérience des 58 lycées »
• 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 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, mettent 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 :

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

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 .

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

• 1990 - Haskell
• 1991 - Python
• 1993 - Ruby
• 1993 - Lua
• 1994 - ANSI Common Lisp
• 1995 - JavaScript
• 1995 - Java
• 1995 - PHP
• 2000 - C#

La liste des langages développées pendant les années 2010 et 2020 est très longue : ne seront listés que les principaux et les plus emblématiques. Cette explosion de langages peut être présentée sur 3 axes : sûreté, langages fonctionnels, performances.

Sûreté - Les années 2010 tendent vers des langages plus sûrs. Il y a plus de vérification lors de compilation pour éviter les erreurs pendant que le programme tourne. Les valeurs « null » se retrouvent supprimées pour être remplacées par des structures plus sécurisées, obligeant le développeur à rendre son code plus sûr.

• 2010 - Rust
• 2011 - Ceylon
• 2012 - Elm

Langages fonctionnels - Initié dans les années 2000 y compris à partir de méta-langage, des variantes de divers langages intégrent des spécifications permettant un développement fonctionnel.

• 2007 Clojure (à partir de Lisp)
• 2004,2006 mais vraiment développé à partir de 2011 Scala (à partir de Java)
• 2010 F# proposé par Microsoft (à partir de C#)

Performances et web - Ces évolutions visent à développer des nombreux langages pour remplacer ceux des années 90 et 2000 en développant la performance, le portabilité et/ou la facilité. Les orientations sont variées :

• Go - programmation système depuis 2009-2010 par Google
• Dart - pour le multi-plateforme depuis 2011 ou Kotlin (fonctionnel également) en particulier pour les mobiles Android depuis 2017
• Swift - pour les systèmes Apple (dont les mobiles) depuis 2014
• TypeScript - avec pour ambition de remplacer Javascript
• Carbon proposé en 2022 avec pour ambition de remplacer C++ (mais Rust peut également tenir ce rôle de remplaçant de C++).

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

1. Ajouter de la sécurité et de la 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).

• Grace Hopper, conceptrice du premier compilateur en 1951 (A-0 System) et du langage COBOL en 1959.
• John Backus, inventeur de Fortran et des grammaires BNF (Backus Naur Form).
• John McCarthy, inventeur de LISP.
• Niklaus Wirth inventeur de PL360, Algol W, Pascal, Modula, Obéron
• Alan Cooper, développeur de Visual Basic.
• Edsger Dijkstra, qui a mis au point le cadre d'une bonne programmation.
• James Gosling, développeur de Oak, précurseur de Java.
• Anders Hejlsberg, développeur de Turbo Pascal et C#.
• Kenneth E. Iverson, développeur de APL.
• Bill Joy, inventeur de vi, auteur des débuts BSD Unix, et à l'origine de SunOS, qui devint Solaris.
• Alan Kay, précurseur de la programmation orientée objet et à l'origine de Smalltalk.
• John von Neumann, inventeur du l'Architecture de von Neumann (elle-même inspirée des travaux d'Alan Turing), sur laquelle se basent nombre de langages de programmation.
• Dennis Ritchie, inventeur du langage C ; et Brian Kernighan, coauteur du premier livre sur le langage C, coauteur des langages AWK et AMPL.
• Ken Thompson, inventeur de Unix.
• Linus Torvalds, inventeur de Linux
• Bjarne Stroustrup, développeur de C++.
• Adriaan van Wijngaarden, principal concepteur d'Algol 68 et des grammaires à deux niveaux, traitant des types récursifs et de cohérence des programmes.
• Jean Ichbiah, principal concepteur de LIS et d'Ada 83.
• Bertrand Meyer, concepteur d'Eiffel.
• Brendan Eich, créateur de JavaScript et un des initiateurs de Rust.
• Martin Odersky, créateur de Scala.

La Keynote de Mark Rendle : The History Of Programming (https://www.youtube.com/watch?v=Tr9E_vzKRVo) Les pages wikipedia sur ces différents langages (et leurs références)