Pascal

Un programme peut donner le bon résultat tout en restant difficile à comprendre ou à modifier. Dans les années 1960, alors que les logiciels grandissent, cette difficulté devient un véritable enjeu.

En 1970, l’informaticien suisse Niklaus Wirth présente Pascal, conçu à l’École polytechnique fédérale de Zurich (ETH Zurich). Son objectif : réunir des mécanismes déjà connus dans un langage cohérent, qui aide à organiser les données et le raisonnement. Pascal marquera durablement l’enseignement, mais son histoire dépasse les salles de cours : ses différentes implémentations accompagneront aussi l’essor des micro-ordinateurs.

Pourquoi un nouveau langage en 1970 ?

Les premiers grands langages répondent à différents besoins : FORTRAN facilite les calculs scientifiques, COBOL la gestion et BASIC l’apprentissage de la programmation.

Mais quand un programme s’allonge, suivre son exécution devient compliqué. L’instruction GOTO, par exemple, permet de sauter à un autre endroit du code ; utilisée sans méthode, elle rend le parcours difficile à suivre. La programmation structurée privilégie au contraire des enchaînements explicites : exécuter des instructions, choisir selon une condition et répéter un traitement. Ce n’est pas une question de présentation : lorsqu’on suit facilement le chemin d’exécution, il devient plus simple de vérifier un résultat et de repérer une erreur.

Pascal n’invente pas cette démarche. Il s’inscrit dans une réflexion collective sur la lisibilité des logiciels : une instruction doit pouvoir être comprise à partir de sa place dans le programme, plutôt qu’en suivant une série de sauts. Pour comprendre les choix de Wirth, il faut remonter à son principal prédécesseur : ALGOL 60.

D’ALGOL 60 à Pascal : les choix de Niklaus Wirth

Publié en 1960 par un groupe international de chercheurs, ALGOL 60 vise à exprimer les algorithmes indépendamment des particularités d’un ordinateur. Il contribue à diffuser les blocs d’instructions, les procédures et la portée des variables : une variable déclarée dans un bloc n’est pas accessible partout. Sa syntaxe est décrite rigoureusement à l’aide d’une notation formelle, la BNF (Backus-Naur Form). Cette précision facilite le travail des concepteurs de compilateurs et la comparaison entre langages. Plutôt que de laisser chaque programmeur deviner les constructions permises, une grammaire précise ce qui constitue une instruction ou une déclaration correcte.

Son influence se retrouve dans plusieurs lignées : Pascal en hérite directement ; Simula 67 développe, à partir d’ALGOL, des classes et des objets ; une autre filiation, passant notamment par CPL, BCPL et B, mène au langage C. Les blocs et les règles de visibilité restent familiers aux programmeurs de C++, Java ou JavaScript, même si la syntaxe a changé. Il s’agit d’un héritage intellectuel transmis par plusieurs lignées, et non d’une succession de copies directes d’ALGOL.

Dans les années 1960, Wirth participe aux discussions sur l’évolution d’ALGOL. Il défend une approche moins complexe que celle qui conduira à ALGOL 68 et contribue à ALGOL W, développé à Stanford. Cette expérience nourrit une conviction : un langage gagne à proposer un petit ensemble de mécanismes cohérents plutôt qu’une collection de possibilités difficiles à maîtriser. Les travaux qui conduisent à ALGOL 68 suivent, eux, une voie plus ambitieuse.

De retour à Zurich en 1968, il poursuit cette recherche de simplicité avec Pascal, nommé en hommage à Blaise Pascal. Son rapport The Programming Language Pascal paraît en novembre 1970. Le langage continuera ensuite d’évoluer : 1970 désigne ici sa présentation historique, non une version commerciale figée. Wirth cherche autant à fournir un outil efficace qu’à aider les étudiants à réfléchir à la construction d’un programme avant de l’écrire.

L’enjeu n’est donc pas d’accumuler des nouveautés : Wirth veut que les règles du langage aident le programmeur à construire une solution claire. Cela commence par la façon de décrire les données.

Comment Pascal aide à structurer un programme

Des données typées et des instructions lisibles

Imaginons un programme qui additionne trois notes sur 20. Une note n’est pas simplement un nombre quelconque : 75 serait une valeur incohérente dans ce système.

Les langages précédents, comme FORTRAN et ALGOL, distinguaient déjà plusieurs types de données, notamment les entiers et les nombres réels. Pascal reprend cette idée et développe la possibilité de créer ses propres types, adaptés aux informations manipulées.

Le programmeur peut ainsi définir un type Note limité aux entiers de 0 à 20, puis l’utiliser dans un tableau. Cette déclaration rend explicite ce que les données représentent et permet au compilateur de détecter certaines erreurs.

program Notes;
type
  Note = 0..20;
var
  notes: array[1..3] of Note;
  total, i: integer;
begin
  notes[1] := 12;
  notes[2] := 15;
  notes[3] := 18;
  total := 0;
  for i := 1 to 3 do
    total := total + notes[i];
  writeln(total);
end.

Le programme affiche 45 : il additionne successivement 12, 15 et 18. type définit un type, var déclare les variables, begin et end délimitent le bloc principal. La boucle for parcourt le tableau ; := signifie « affecter une valeur ». Les données sont donc déclarées d’abord, puis les opérations sont réunies dans un bloc dont le déroulement se lit de haut en bas. Le lecteur peut identifier les valeurs manipulées, puis suivre leur transformation, sans connaître les détails de la machine.

Le typage statique permet au compilateur de repérer certaines incompatibilités avant l’exécution. En revanche, la vérification effective des limites d’un intervalle dépend des contrôles mis en œuvre : aucun langage ne supprime à lui seul les erreurs. L’intérêt est surtout de rendre les règles visibles et de détecter plus tôt certaines fautes. Pascal conserve d’ailleurs GOTO, tout en encourageant les constructions régulières comme for, while et repeat ... until.

Des enregistrements, des procédures et des fonctions

Pascal propose aussi des enregistrements (record) pour regrouper des informations liées. Par exemple, un élève possède un numéro et une note :

type
  Eleve = record
    numero: integer;
    note: Note;
  end;

Chaque champ possède un nom et un type : on peut manipuler une fiche d’élève sans multiplier des variables isolées dont il faudrait se rappeler les correspondances. Le principe existait avant Pascal, notamment dans COBOL et ALGOL W, et se retrouve dans les struct de C. Il ne faut pas le confondre avec la programmation orientée objet : dès 1967, Simula associait déjà des données et des opérations au sein de classes et d’objets. Ce lien est une parenté de concepts, pas la preuve que les objets seraient nés des record de Pascal. Un record Pascal ne définit pas, à lui seul, des méthodes.

Les procédures regroupent des instructions réalisant une tâche ; les fonctions calculent et renvoient une valeur. Elles non plus ne sont pas nouvelles : FORTRAN II et ALGOL 60 utilisaient déjà des sous-programmes. Pascal en fait des outils naturels pour découper un problème. Par exemple, si plusieurs parties d’une application calculent une moyenne, une fonction commune évite de copier le calcul partout. Une correction ne nécessite alors qu’une modification. Le découpage en sous-programmes oblige aussi à décider quelles informations leur transmettre et quel résultat en attendre : une habitude qui aide à concevoir des logiciels plus grands.

Cette cohérence explique son intérêt pédagogique. Mais un langage bien conçu ne suffit pas : il faut aussi pouvoir le faire fonctionner sur des machines différentes.

Du centre de calcul aux micro-ordinateurs

Au début des années 1970, Pascal est enseigné notamment à l’ETH Zurich sur de grands ordinateurs. Pour faciliter son adaptation à d’autres machines, les travaux autour de Pascal-P, à partir de 1973, utilisent un code intermédiaire appelé p-code.

Le compilateur traduit le texte Pascal en p-code, qu’une machine virtuelle adaptée à l’ordinateur peut exécuter. Cette machine virtuelle est un logiciel qui reconnaît les instructions intermédiaires et les réalise sur le matériel disponible. Autrement dit, le programme n’est plus lié directement à un jeu d’instructions matériel : pour changer de machine, il suffit en grande partie d’y disposer d’un système capable de comprendre le p-code. Il reste possible que certaines entrées-sorties ou bibliothèques nécessitent des adaptations. Cette portabilité facilite la diffusion d’un compilateur sur plusieurs familles d’ordinateurs, alors qu’écrire un compilateur entièrement nouveau serait coûteux.

L’idée rappelle celle du bytecode de Java, exécuté par la JVM depuis 1995, ou du code intermédiaire de .NET. Les systèmes modernes disposent toutefois de leurs propres techniques, notamment la compilation à la volée (JIT) : il s’agit d’une parenté de principe, pas d’une filiation technique directe démontrée.

UCSD Pascal et l’arrivée sur les micro-ordinateurs

Dans les années 1970, à l’université de Californie à San Diego, l’équipe de Kenneth Bowles développe UCSD Pascal et l’UCSD p-System, associant langage, outils et environnement portable. L’ensemble offre un cadre de travail plus complet que le seul compilateur et arrive sur plusieurs micro-ordinateurs, dont l’Apple II avec Apple Pascal. La portabilité du système et la diffusion du matériel se renforcent ainsi mutuellement. Pour un étudiant, l’intérêt est très concret : disposer d’un environnement de programmation sur une machine personnelle plutôt que dépendre exclusivement d’un centre de calcul.

Pascal sort ainsi des grands centres de calcul. Reste à rendre l’écriture, la compilation et la correction des programmes plus rapides et plus accessibles au quotidien.

1983 : Turbo Pascal change l’expérience du développement

En 1983, Borland, dirigée par Philippe Kahn, lance Turbo Pascal. Son compilateur repose sur les travaux d’Anders Hejlsberg. Ce n’est pas le langage original de 1970, mais une implémentation commerciale accompagnée d’outils de développement.

Turbo Pascal réunit un éditeur et un compilateur rapide dans un même environnement, vendu à un prix accessible. À une époque où l’on doit souvent passer d’un programme à l’autre pour écrire, compiler, puis repérer une erreur, ce changement est concret : le développeur peut tester une correction presque immédiatement. Le produit rencontre un large public sur les machines CP/M puis MS-DOS, dans l’enseignement comme chez les programmeurs indépendants.

Ses versions successives ajoutent des extensions, notamment pour organiser de plus grands programmes et, plus tard, programmer avec des objets. La rapidité de l’outil ne doit cependant pas faire oublier que ce succès commercial intervient treize ans après la présentation du langage. C’est pourquoi il faut distinguer Pascal, le langage conçu par Wirth, de Turbo Pascal, l’un de ses environnements les plus célèbres.

Les limites de Pascal et ses héritiers

Cette recherche de simplicité présente toutefois certaines limites. Dans le Pascal d’origine, les chaînes de caractères, comme le nom d’un élève ou le titre d’un livre, sont représentées par des tableaux dont la taille doit être fixée à l’avance. Si l’on réserve 20 caractères pour un nom, il faut gérer les emplacements inutilisés lorsque celui-ci est plus court, et prévoir une solution s’il dépasse cette limite. Contrairement aux chaînes de caractères des langages modernes, leur longueur ne s’adapte pas automatiquement au texte contenu.

Une autre difficulté apparaît lorsque les programmes grandissent. Pour développer un logiciel de plusieurs milliers de lignes, il est utile de le diviser en plusieurs parties que l’on peut compiler séparément. Or, le Pascal initial ne prévoit pas de mécanisme standard complet pour organiser ce travail.

Ces contraintes n’empêchent pas de créer des logiciels importants avec Pascal, mais elles compliquent certains développements. Les versions ultérieures du langage, notamment Turbo Pascal, apporteront progressivement des solutions à ces problèmes.

En 1981, Brian Kernighan, coauteur avec Dennis Ritchie du célèbre ouvrage The C Programming Language (1978), publie Why Pascal Is Not My Favorite Programming Language. Il y critique plusieurs limites du Pascal original, notamment pour développer des logiciels complexes. Son analyse ne remet pas en cause les qualités pédagogiques du langage, mais souligne la différence entre un langage particulièrement adapté à l’enseignement et les exigences de certains développements professionnels.

Wirth poursuit lui-même sa recherche avec Modula-2, qui accorde une place centrale aux modules : chaque partie du programme peut mieux définir ce qu’elle met à disposition des autres. Il conçoit ensuite Oberon (1988), pour simplifier certains choix et prendre en charge des mécanismes orientés objet. Une autre branche mène à Delphi (1995), environnement de développement fondé sur Object Pascal. Ces évolutions ne doivent pas être confondues avec le Pascal original : elles répondent à des besoins et à des machines apparus par la suite.

Ce que Pascal a laissé à la programmation

Pascal n’a inventé ni les procédures, ni les enregistrements, ni la programmation structurée. Sa contribution est d’avoir réuni ces idées dans un langage cohérent, propice à l’apprentissage mais aussi à la création de logiciels réels. Grâce à l’enseignement, à UCSD Pascal et à Turbo Pascal, plusieurs générations ont appris à définir leurs données, découper leurs traitements et rendre leurs programmes lisibles. Le langage a changé de rôle au fil des décennies, mais ces principes ont conservé leur utilité.

Son héritage reste actuel : bien programmer, ce n’est pas seulement obtenir un résultat, c’est aussi produire une solution que d’autres pourront comprendre et faire évoluer.

---

Sources historiques principales

• Niklaus Wirth, The Programming Language Pascal, ETH Zurich, 1970.
• Niklaus Wirth, 50 Years of Pascal, 2021.
• ETH Zurich, Research highlights — repères sur les travaux de Wirth.
• Computer History Museum, chronologie de 1970.
• UC San Diego, hommage à Kenneth Bowles et histoire d’UCSD Pascal.
• Brian Kernighan, Why Pascal Is Not My Favorite Programming Language, 1981.
• ISO 7185:1983, Pascal.
• eWeek, 30 Years Ago: Turbo Pascal, 2013.
• Embarcadero, histoire de Turbo Pascal et Delphi.