Annexe A Quelques éléments d'histoire

Dès 1864, Babbage avait proposé un "moteur analytique" contenant un "magasin" où étaient stockées toutes les variables, et un "moulin" dans lequel étaient chargées les quantités sur lesquelles s'effectuaient les opérations. Les bases des architectures informatiques actuelles ont cependant été posées à Princeton vers 1940, par von Neumann. Un ordinateur est composé de :

une unité centrale de traitement (CPU), composée elle-même
- d'une unité arithmétique et logique (UAL), chargée d'effectuer les calculs proprement dits,
- d'une unité de contrôle chargée du pilotage des calculs,
- d'une unité d'entrées-sorties, car un ordinateur qui ne communiquerait pas d'une manière ou d'une autre avec le monde extérieur serait un système fermé et n'aurait bien entendu pas beaucoup de sens.
une mémoire, constituée de cases repérables par une adresse, dans lesquelles sont stockées les données sur lesquelles on travaille et les programmes.

La première machine de von Neumann ne traitait que des données entières. Elle savait effectuer des opérations arithmétiques et stocker les résultats dans un accumulateur. La valeur de cet accumulateur pouvait être rangée dans une case quelconque de la mémoire. Le contrôle était constitué par un flot séquentiel d'instructions, interrompu par des branchements conditionnels ou inconditionnels.

Il est important de noter que dans la machine de von Neumann, la mémoire ne contient pas seulement les données, mais aussi le programme lui-même ; cela permet notamment les branchements conditionnels ou inconditionnels, c'est-à-dire la continuation de l'exécution à partir d'une adresse en mémoire non consécutive à l'adresse courante. Cette adresse de branchement peut être calculée ou stockée en mémoire.

Les instructions qu'on pouvait effectuer sur la machine de von Neumann étaient très simples :

des instructions arithmétiques :

  A := A + M[i] ; A := A - M[i] ; A := A + |M[i]| ; 
  A :=  A - |M[i]| ; A := M[i] ; A := -M[i] ; 
  A := |M[i]| ; A := - |M[i]| ;
  A := A*2 ; A := A div 2 ; 
  A, R := (M[i]*R) div 2^39, (M[i]*R) mod 2^39  ;
  A, R := A mod M[i], A div M[i] ;

des déplacements entre l'accumulateur, le registre et la mémoire:
```
  A := M[i] ;
  M[i] := A ; R := M[i] ; A := R ;
```

des instructions de transfert du contrôle:

  goto M[i].{left,right} ;
  if A >= 0 goto M[i].{left,right} ;

la possibilité de modifier la partie gauche ou la partie droite de M[i], correspondant à une adresse stockée.

Le langage machine est la notation directement compréhensible par la machine. Le langage machine "colle" au jeu d'instructions de l'ordinateur. Les tout premiers programmes étaient d'ailleurs entrés par le positionnement de clés correspondant aux 0 et 1 ! Mais rapidement, la notion de programme sur support extérieur s'est imposée ; d'ailleurs, cette idée était antérieure à l'informatique, puisque le métier à tisser de Jacquard au début du 19e siècle était déjà contrôlé par un programme sur cartes perforées.

À la base, les programmes restent encore de nos jours des séquences de 0 et de 1, ou d'octets, ou de nombres, correspondant au jeu d'instructions de la machine sur laquelle ils sont exécutés. Toutefois, il est rapidement devenu nécessaire d'augmenter la lisibilité des programmes grâce aux langages d'assemblage (souvent appelés incorrectement assembleur), qui indiquent par des mots clés mnémotechniques les instructions du processeur et les divers registres disponibles.

Le premier langage de haut niveau a été FORTRAN, issu des besoins de création de gros programmes de calcul numérique. FORTRAN a continué à évoluer et reste le langage de choix pour ce type d'applications. En parallèle naissait le besoin d'un langage permettant d'exprimer et de structurer aisément les constructions algorithmiques. Algol 60 est l'ancêtre d'une longue lignée. Une première branche s'est poursuivie par Algol 68, qui a lui-même inspiré des langages tels que Pascal (1971), Modula-2 (1983), BCPL (1969) ou C (1972). Une deuxième branche, suscitée au départ par des besoins de simulation du monde réel, a donné la notion de langage à objets, avec l'ancêtre Simula-67, le fondateur Smalltalk (1972, puis 1980), ou Eiffel. C++ (1986) fait une synthèse de ces deux branches en gardant les constructions de C tout en ajoutant la programmation objet. Java, le langage que nous utilisons comme support de ce cours, est conceptuellement plus proche de Smalltalk, mais reprend beaucoup d'éléments de syntaxe de C++.

Ce très bref historique serait incomplet si on n'évoquait pas quelques-unes des autres familles, nées de besoins divers et ayant chacune ses fondements en termes de modèles de calcul et de modèles de données : les langages orientés gestion dans la lignée de COBOL, les langages fonctionnels (LISP, ML), la programmation logique (Prolog), la programmation parallèle/concurrente, etc.