Algol (langage) — Wikipédia

Wiki Loves Monuments : photographiez un monument historique, aidez Wikipédia et gagnez !

# Algol (langage)

Un article de Wikipédia, l'encyclopédie libre.
Pour les articles homonymes, voir Algol.

Algol
Apparu en | 1958
Auteur | John Backus et Peter Naur
Paradigme | procédural, impératif
Typage | statique, sûr, nominatif
Dialectes | Algol 58, Algol 60 et Algol 68
Influencé par | Fortran
A influencé | Simula, PL/M, Pascal
Implémentations | Burroughs Algol sur B5000, Case-ALGOL sur Univac 1107, PDP-1 (1961), Algol 60 AFNOR sur CAE 510 (1964), ALGOL W sur IBM System/370 (1966), S-ALGOL sur PDP-11 (1979)

Algol est un langage de programmation. Il a été créé à la fin des années 1950. Dérivé d'un projet de l'UNESCO d'abord appelé IAL (International Algebraic Language), son nom est l'acronyme d'algorithmic oriented language (avec un clin d'œil à l'étoile β Persei)[réf. nécessaire]. Son objectif était de décrire algorithmiquement des problèmes de programmation. Les principales différences au niveau de la conception par rapport à Fortran furent l'utilisation de blocs marqués par BEGIN END, permettant variables locales et tableaux dynamiques, et surtout la récursivité, concepts qui seront largement repris par ses successeurs.

Le langage existe en trois versions : Algol 58, Algol 60 et Algol 68.

## Historique[ modifier | modifier le code]

Le premier rapport décrivant le langage date de 1958 et a donc donné lieu à Algol 58. Présentant des ambiguïtés sévères, il fut stabilisé sous le nom d'Algol 60, langage largement adopté dans les Universités, et qui fit faire des progrès importants à la compilation.

Algol 60 a été publié en 1960. John Backus et Peter Naur faisaient partie du comité qui l'a créé. Algol 60 a inspiré beaucoup de langages. C. A. R. Hoare a déclaré à son sujet : « Voici un langage très en avance de son temps, il n'a pas seulement été une amélioration de ses prédécesseurs mais aussi une amélioration de presque tous ses successeurs ». Ce commentaire est parfois attribué faussement à Edsger Dijkstra, célèbre aussi pour ses commentaires humoristiques.

Hormis un succès universitaire certain, Algol 60 sera peu utilisé dans des programmes commerciaux. Cela est dû au manque de fonctions standards d'entrée-sortie (corrigé en 1965 et surcorrigé dans Algol 68), et à une mauvaise adaptation aux programmes de gestion. Au plan scientifique, il était moins efficace que Fortran, tout en permettant des traitements a priori impossibles dans ce langage.

Ses trois principaux descendants sont :

- Algol 68, conçu au Centre de Mathématiques Appliquées d'Amsterdam, et défini en décembre 1968 ; langage universel basé sur un système de 2 grammaires orthogonales (engendrant une grammaire potentiellement infinie) il permet de construire nouveaux types et nouveaux opérateurs, facilitant une approche très algébrique des applications ; jouant sur la puissance des mécanismes plutôt que sur leur nombre, il a été souvent perçu comme l'antithèse de PL/I ;
- Algol W, créé peu après selon les propositions plus statiques de Niklaus Wirth, membre du groupe de travail sur Algol 68 dont les propositions avaient été refusées. Wirth s'inspirera d'Algol W pour créer le langage Pascal, puis Modula 2 ;
- Simula (1967), conçu à Oslo, sur-ensemble d'Algol 60, ancêtre des langages objet (comme C++, Modula 3, Oberon) permettant de définir des classes et des processus facilitant la simulation à événements discrets.

La suite de cet article est principalement consacrée au langage Algol 60. En effet, sans mention de millésime, le terme Algol désigne le langage Algol 60, tandis que les Algols désigne l'ensemble de la famille.

## Caractéristiques[ modifier | modifier le code]

Algol 60 est un langage typé, procédural récursif et à structure de blocs. Il permet un emploi dynamique des types mais ne permet pas à l'utilisateur d'en définir de nouveaux. Algol 60 a été défini sans instructions d'entrées/sorties ; une implémentation sur une machine donnée en comportait nécessairement, mais elles variaient de l'une à l'autre. En réaction à cette situation, Algol 68 les a sur-spécifiées.

Algol 60 permet deux types de passage de paramètres lors de l'appel de procédure : passage par valeur et le « passage par nom », proche de la macro-substitution. Le passage par nom possède des propriétés, mal comprises du fait d'une confusion avec le passage par référence, plus répandu ; aussi a-t-il été abandonné dans les successeurs d'Algol 60. Par exemple, on a reproché à ce mode Algol 60 l'impossibilité d'écrire une procédure échangeant deux valeurs si un des paramètres est un entier et l'autre un tableau indexé par ce même entier.

En réaction contre le manque de formalisme dans le projet Fortran, John Backus a conçu la BNF pour Backus Normal Form permettant la spécification de Algol 58. Cette méthode de description d'un langage a été révisée et étendue par Peter Naur sous le nom Backus Naur Form avec le même acronyme pour spécifier Algol 60, ainsi muni d'une grammaire indépendante du contexte.

## Algol 68[ modifier | modifier le code]

Algol 68 a été défini comme langage universel basé sur des types et des opérateurs prédéfinis, des procédés de construction de nouveaux types, et de nouveaux opérateurs avec possibilité de surcharge et d'extension des opérateurs prédéfinis, le tout permettant d'adapter le langage à chaque famille d'applications.

Comme une grammaire indépendante du contexte, telle que l'on peut définir avec BNF, s'avère une grammaire simple, que la rigueur demande de compléter par des restrictions sémantiques en langue naturelle, trop souvent ambiguës, l'équipe de Adriaan van Wijngaarden a retenu un système grammatical, dit grammaire de van Wijngaarden (en) (seconde forme) couvrant la syntaxe en rapport avec la sémantique. S'appuyant sur une hyper-grammaire (donnant des schémas de règles ou hyper-règles) interagissant avec une méta-grammaire (reflétant la théorie des types constructibles), le système grammatical produit une infinité de contraintes de BNF sémantiquement adéquates. Le Rapport Révisé a parfaitement illustré l'adéquation de ce dispositif, qui définit une syntaxe sémantiquement correcte. Cette approche totale facilite une compilation « carrée ».

## Architectures supportant Algol[ modifier | modifier le code]

Le B5000 de Burroughs Corporation et ses successeurs étaient des machines à pile conçues pour être programmées avec un Algol étendu ; leur systèmes d'exploitation est écrit dans cet Algol depuis 1961, ouvrant la voie à l'écriture des systèmes d'exploitation en langage symbolique, reprise par Multics puis Unix. Unisys Corporation continue de commercialiser des machines descendant du B5000 supportant plusieurs compilateurs Algol étendus.

Le CAE 510 comportait un compilateur Algol conforme au niveau II de la norme AFNOR FZ 65-010[1], incluant de plus la récursivité[2].

## Exemple de code (Algol 60)[ modifier | modifier le code]

Les programmes Algol 60 sont à format libre, avec le point-virgule comme séparateur principal. Les termes en caractère gras (procedure…) sont des mots réservés du langage. Chaque implémentation du langage peut utiliser sa propre convention lexicale (par exemple 'PROCEDURE').

    procedure Absmax(a) Taille:(n, m) Resultat:(y) Indices:(i, k);
        value n, m; array a; integer n, m, i, k; real y;
    comment  Dans la procédure Absmax (a, n, m, y, i, k)
             le plus grand élément en valeur absolue de la matrice a de taille
             n par m est transféré à y et les indices de cet élément à i et k ;
    begin integer p, q;
        y := 0; i := k := 1;
        for p:=1 step 1 until n do
            for q:=1 step 1 until m do
                if abs(a[p, q]) > y then
                    begin
                        y := abs(a[p, q]);
                        i := p; k := q
                    end
    end Absmax

## Notes[ modifier | modifier le code]

1. ↑ Sur la normalisation d'Algol et FORTRAN par l’AFNOR, cf. le texte de l'allocution d’André Masson, « État présent de la normalisation française et internationale intéressant la documentation et les bibliothèques » [archive], Tunis,‎ jiun 1968
2. ↑ D'après M. Rabechault, « L'informatique au Laboratoire Central des Ponts et Chaussées », Bull. des LPC,‎ avril 1972, p. 136.

## Voir aussi[ modifier | modifier le code]

### Liens externes[ modifier | modifier le code]

- (en) Revised Report on the Algorithmic Language Algol 60 et d'autres documents
- (en) Algol 60 en BNF
- (en) rapport Algol 60
- (fr) « Etude et réalisation d'un compilateur Algol 60 sur calculateur électronique du type IBM 7090/94 et 7040/44 / thèse de J.-C. Boussard, sur la base TEL-CNRS ».
- (en) History of ALGOL

[masquer] v · m Langages de programmation
Orientés objet | ActionScript · AppleScript · C++ · C# · CoffeeScript · D · Delphi · Eiffel · Groovy · Java · JavaScript · Lisaac · Logo · Objective-C · PHP · Python · Ruby · Scala · Simula · Smalltalk · Visual Basic
Impératifs | Algol · APL · ASP · Assembleur · BASIC · BCPL · Shell Unix · C · COBOL · Natural · Forth · Fortran · Go · Limbo · Lua · Modula-2 · NQC · NXC · OPL · Pascal · Perl · PHP · Rust · PL/I · Tcl · Windows PowerShell · WLangage
Fonctionnels | Haskell · Lisp · Common Lisp · ML · OCaml · Gallina · F# · Standard ML · Opa · Scheme · XSLT
Déclaratifs | Clips · Prolog · ASP
Concurrents | Ada · Erlang
Conception · Codage · Tests · Optimisations

- Portail de la programmation informatique

Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Algol_(langage)&oldid=116506825 ».
Catégorie :

- Langage de programmation

| [+]
Catégories cachées :

- Article à référence nécessaire
- Article contenant un appel à traduction en anglais
- Portail:Programmation informatique/Articles liés
- Portail:Informatique/Articles liés