PL/I

PL/I ou PL/1 (Programming Language number 1, littéralement « Langage de programmation numéro 1 ») est un langage de programmation développé par IBM au début des années 1960.

PL/I
Date de première version
Influencé par Fortran
Cobol
Algol
Site web www.ibm.com/products/pli-compiler-zos

Son objectif était d'être universel et de pouvoir remplacer indifféremment les langages à destination scientifique, tels que FORTRAN et ALGOL, et le langage COBOL, plus adapté aux problèmes de comptabilité et de gestion. Il permettait même l'accès à des fonctions autrefois réservées à la programmation système, comme la gestion de zones dynamiques de mémoire allouées à la demande (et non simplement à l'entrée dans un bloc), de pointeurs, et le travail par programme directement dans les tampons d'entrée-sortie. Ses capacités de points d'entrée génériques dans les procédures offraient une possibilité qui se retrouvera avec C++. Il avait pour objectif de devenir le langage privilégié de programmation des ordinateurs universels IBM 360 et 370.

Ce langage est défini par les normes ECMA-50 (1976), ANSI X3.53-1976, AFNOR NF Z 65-500 et ISO 6160:1979. Il fut utilisé comme langage de programmation système dans le projet Multics.

Sa syntaxe ajoutait aux idées de FORTRAN certaines idées de COBOL (structures, calcul en mode décimal), et d'ALGOL (structure de blocs imbriqués). Toutefois, les programmeurs de ces deux langages ne communiquaient guère entre eux à l'époque, et chacun jugeait inutile et encombrant ce qui avait été inclus pour l'autre. Son compilateur nécessitait également des machines importantes pour l'époque, et ne comportait au départ ni optimiseur, ni compilateur incrémental (le PL/I Optimizing compiler et le PL/I Checkout compiler ne viendront que plus tard).

Ce langage avait beaucoup des caractéristiques de ce qui sera plus tard le C, et même déjà certaines du C++. IBM déposa les noms de PL/1 à PL/100 pour éviter de perdre le contrôle des spécifications du langage. Un effet non prévu de cette décision fut de dissuader la concurrence de nommer « PL/I » ses propres implémentations, qui prirent des noms voisins : « SL/1 », « CPL/1 », « PL/M », « PL/C », etc. Devant la multitude de ces appellations, la crainte d'une balkanisation du langage (et des frais de migration associés en cas de changement de constructeur) dissuada les équipes informatiques d'y migrer.[non pertinent] Le lancement du langage, malgré des qualités (gestion simple du multitâche[1], récursivité, structures de blocs, facilités de débogage et de profilage, allocation dynamique dans des pools de mémoire eux-mêmes dynamiques (AREA), ordre LOCATE permettant de travailler à même les tampons du système pour éviter les recopies inutiles, procédures génériques analogues aux templates de C++) et des défauts (universalité illusoire, typage dynamique imprévisible, complexité intrinsèque) ne rencontra donc pas le succès espéré. Ses puissantes possibilités de débogage, en particulier (CHECK): et ON CHECK(…), furent néanmoins remarquées.

Caractéristiques

Généralités
  • Un objectif du langage est que chacun puisse l'utiliser sans avoir à en connaître la totalité. Il n'y a en conséquence pas de mots réservés dans PL/I. (PL/I comporte bien des mots-clés, mais ils ne sont reconnus que dans le contexte précis où ils auraient un sens. En d'autres termes, on peut appeler une variable DO, FORMAT ou POINTER si on le désire, et le langage a été conçu pour le permettre sans le moindre effet secondaire indésirable[2].). Cela permettait d'écrire sans risque des programmes PL/I qui se compilaient et s'exécutaient, sans pour cela avoir à connaître tout PL/I. Un exemple extrême et caricatural, mais pédagogique, donné dans les centres d'instruction IBM était : IF ELSE = THEN THEN ELSE = IF; ELSE THEN = IF;, expression parfaitement valide où des variables se nommaient ELSE, THEN et IF.
  • Un programmeur doit pouvoir utiliser un nom défini de façon externe — par exemple TIME — sans avoir à se demander si c'est une variable ou une fonction sans argument.
  • Les instructions d’entrée/sortie font partie du langage et ne sont pas des fonctions de bibliothèques externes. Un avantage immédiat est que les ordres d'entrée comme de sortie ont accès à la table des symboles au moment de la compilation, ce qui simplifie souvent leur écriture (GET DATA, PUT DATA).
  • Le compilateur est tolérant : en cas d'écart à la syntaxe, il essaiera de déterminer ce que le développeur souhaite selon lui le plus probablement, et agira en conséquence en émettant un simple message d'avertissement (« warning »).

Les objectifs complets de PL/I sont détaillés dans la préface de la brochure de référence du langage établie par IBM[3].

Aides au débogage

Elles étaient d'autant plus nécessaires que les tolérances du compilateur masquaient des erreurs variées :

  • déclarations facultatives, règles d'établissement d'attributs par défaut en fonction des attributs déclarés. Une variable en I,.., N non déclarée recevait d'emblée 5 ou 6 attributs ; d'où une certaine insensibilité aux fautes de frappe entrainant des dédoublements de variables, et la nécessité pour le programmeur de vérifier dans la table des symboles pour vérifier que le compilateur l'avait compris ;
  • des règles de conversion en cascade laissant affecter presque n'importe quelle valeur à n'importe quelle variable ;
  • d'où des compilations réussies suivies d'exécutions problématiques.

Gestion des exceptions

La déclaration ON représentait déjà un système de gestion d'exceptions.

  • ON CHECK(variable) : bloc; exécutait les instructions du bloc chaque fois que la variable précisée changeait de valeur, où que ce soit dans le programme sauf là où on l'inhibait par (NOCHECK).
  • CHECK(variable) imprimait à chaque changement, par défaut, le nom de la variable et sa nouvelle valeur.
  • ON RANGE(tableau) exécutait le code correspondant lorsque l'indice de tableau sortait de ses bornes autorisées, etc.

Dump « évolué »

L'instruction PUT DATA(liste de variables); imprimait ces variables dans le format approprié à leur déclaration. PUT DATA; sans liste imprimait toutes les variables du programme; ON ERROR PUT DATA; garantissait en cas d'erreur détectée à l'exécution un dump post-mortem très lisible.

Aspects précurseurs

PL/I, inspiré pour sa syntaxe par l’ALGOL 60, mais également pour ses fonctionnalités par le FORTRAN et le COBOL, comportait dès sa première version de 1966  :

  • les appels génériques, qui n'apparaîtront avec C++ qu'en 1998 ;
  • le multitâche intégré au langage (et non par sous-programmes) qui se généralisera avec Go en 2003 : pour appeler le programme X en tâche asynchrone, il suffisait d'écrire CALL X TASK;. Pour se synchroniser un WAIT(X); suffisait; cette possibilité ne fut cependant implantée que sous OS/360 et ses dérivés. Elle n'était accessible ni sous VM/CMS ni sous DOS/360, les 2 autres systèmes d'exploitation d'IBM ;
  • les constantes littérales binaires, comme '01'B[4] qui ne seront intégrées qu'avec C++14 en 2014
  • le préprocesseur du PL/I était très novateur. Il permettait la copie de bout de souces externes (%INCLUDE), la spécification de constantes (%DECLARE, %assignation), et comme pour le préprocesseur du C des instructions conditionnels (%IF %THEN %ELSE). En fait, c'était un véritable langage de programmation avec ses boucles (%DO var=expression TO expression BY expression %END) et ses procédures propres (%PROCEDURE, %RETURN).

Défauts

La recherche d'universalité du langage, sans théorie sous-jacente, lui a donné une apparence complexe qui a joué contre lui, empêchant notamment sa normalisation. Au sujet du PL/I, on parle aussi de « syndrome du couteau suisse » pour désigner sa définition comme une recherche de polyvalence excessive.

Deux grands autres principes du PL/I se sont révélés contreproductif. Le premier est l’orthogonalité, c’est à tout attribut ou toute utilisation peut se combiner avec tout autre. On peut par exemple appeler une procédure et passer par référence tableau de structures allouées dynamiquement. Le deuxième principe est la permissivité, le programmeur a toujours raison, tout ce qui syntaxiquement correct a un sens et le compilateur doit le traduire. Une expression numérique peut accepter tous les types existants : binaire (FIXED BINARY), virgule flottante (FLOAT DECIMAL), décimal à virgule fixe (FIXED DECIMAL), format d’édition (PICTURE), une expression simple comme A*B+C/D donne la plupart du temps un code généré mathématiquement faux si l’on utilise la combinaison de tous les types existants. Et ce n’est pas un bug du compilateur, car il suit scrupuleusement le tableau officiel des très complexes règles de conversion. Une trop grande permissivité amène à générer des effets de bord incompréhensibles pour le programmeur non confirmé.

Les programmeurs Fortran n'avaient guère l'usage des « structures » ni du format décimal inspirés du COBOL et ceux de Cobol ne voyaient pas l'intérêt des formats d'édition inspiré du FORTRAN (instructions GET EDIT et PUT EDIT).

Les instructions FORMAT et le GOTO calculé du FORTRAN combinées aux curiosités du COBOL avec ses PICTURE et son tri de fichier intégré ont fait du PL/I un langage certes complet mais plus complexe à apprendre[5] et à maîtriser.

Puissant en lui-même, ses tolérances en matière d'usage de mots-clés (non réservés), de déclarations et de concordances de type [6] ne lui permettait pas de garantir la fiabilité des applications acceptées.

Richard Holt, de l'université de Toronto, dressa dès 1972 un inventaire de défauts de PL/I, Teaching the Fatal Disease (or) Introductory Computer Programming Using PL/I[7] qui circula beaucoup et qu'il réédita en 1999. On le trouve encore à disposition de nos jours (2015).

Quelques caractéristiques de PL/I déroutèrent et conduisirent la Revue de l'AFCET à publier un article : Je ne suis pas curieux, mais je voudrais savoir. Le directeur du développement scientifique d'IBM France, Jean-Jacques Duby, répondit en personne dans le numéro suivant par un article, Réponse aux questions d'un curieux expliquant la raison de ces étrangetés. Quelques caractéristiques de PL/I furent néanmoins supprimées en 1970, comme la classe de variables CONTROLLED(POINTER) jugée inopportune en raison de sa confusion possible avec la classe BASED(POINTER).

Héritiers
  • Les langages de programmation systèmes XPL, PL-16 (pour le Télémécanique T1600 et le Solar-16), PL/S (en) (langage d'IBM d'écriture système) et PL/M sont dérivés de PL/I.
  • Les langages d'enseignement CUPL et PL/C développés à Cornell sont basés sur PL/I.
  • Le langage procédural REXX.

Aujourd'hui

En 2015, PL/I ne fait plus partie des 30 principaux langages de développement, selon IEEE Spectrum[8].

Le projet PL/I pour gcc a cessé tout nouveau développement en 2007[9].

En revanche, la société Iron Spring Software propose en 2015 un compilateur disponible sous différents systèmes dont Linux (distribution-agnostic)[10].

Par ailleurs, l'éditeur Blu Age Software propose un outil et une méthode permettant d'automatiser la transformation de patrimoines PL/I vers JavaEE et/ou .Net.

IBM continue de supporter et de développer le PL/I sur ses 2 systèmes d'exploitation principaux : z/OS et AIX. En 2019 sur z/OS, la dernière version du compilateur s'appelle "Enterprise PL/I for z/OS", le code généré est optimisé pour les architecture 64 bits : "z/Architecture" et pour les processeurs: z13, z14, z15. Entre autres le PL/I supporte l'arithmétique flottante décimale (IEEE) et les chaines de caractères codées en UTF-8 et UTF-16 [11].

Conclusion

PL/I permettait de confiner à des zones prédéfinies et allouées à la demande (AREA) la manipulation des pointeurs et des adresses, faisant ainsi bénéficier le programmeur de la protection mémoire matérielle du système. Il disposait de puissantes possibilités intégrées de débogage. Ces possibilités natives du langage sont assurées dans d'autres aujourd'hui par des bibliothèques (Electric Fence, etc.), des aides au débogage comme Valgrind ou des frameworks. Ses autres innovations se retrouvent aujourd'hui, parfois dans le corps des langages et compilateurs (appels génériques de procédure, conversions automatiques de type, profilage, structures chaînées), plus souvent dans des bibliothèques optionnelles.

Légère et symbolique consolation posthume : le multitasking qui constituait l'un des points forts de PL/I est également celui d'un langage fortement promu en interne comme en externe par Google : le langage Go.

Références
  • Sammet, Jean E., Programming Languages: History and Fundamentals, Prentice-Hall, 1969
  • Richard L. Wexelblat (ed.): History of Programming Languages, Academic Press 1981.
  • Thomas J. Bergin and Richard G. Gibson (eds.): History of Programming Languages, Addison Wesley, 1996.
  • PL/I
  • XPL un langage dérivé de PL/I

Bibliographie

Liens externes

Notes et références
  1. D'autant plus remarquable que la multi-programmation se fit attendre au niveau système.
  2. (en) IBM Operating System/360 Operating System PL/I Language Specifications [PDF].
  3. (en) IBM System/360 Operating System | PL/I (F) | Language Reference Manual [PDF].
  4. http://rosettacode.org/wiki/Boolean_values#PL.2FI.
  5. Une description complète du PL/1 fut cependant publiée chez Masson par Marc Thorin, assistant à l'École Centrale de Paris. Le nom initialement proposé par l'auteur, « Traité de PL/I », fut refusé parce que l'ouvrage était court.
  6. le programmeur étant supposé avoir raison, et l'indication de nombreuses possibilités restant facultative car déductible, des variables se trouvaient mal typées ou dédoublées ; et de nombreuses conversions implicites donnaient un sens aux constructions les plus suspectes.
  7. http://plg.uwaterloo.ca/~holt/papers/fatal_disease.html.
  8. http://spectrum.ieee.org/computing/software/top-10-programming-languages.
  9. http://pl1gcc.sourceforge.net/.
  10. Le compilateur PL/I d'Iron Spring Software.
  11. .
  • Portail de la programmation informatique
Cet article est issu de Wikipedia. Le texte est sous licence Creative Commons - Attribution - Partage dans les Mêmes. Des conditions supplémentaires peuvent s'appliquer aux fichiers multimédias.