Ceci est une ancienne révision du document !
Programming in COBOL Ubuntu users are a modern people. We use tablets and smartphones that didn't exist ten years back. We wait impatiently for each succeeding version of Ubuntu to be more revolutionary than the last version, a mere six months back. Is this not progress? Is this not what the fast-paced twenty-first century is all about? Writing about a programming language such as COBOL may come out as a bit odd. After all, the Common Business-Oriented Language was born in the year 1959, sometime during those Dark Ages when programming did not mean running a JavaScript in a Web browser, and computing was not all about conning your touch-screen phone to the latest high-speed mobile network. In those days, even seeing a computer blink its lights at you must have been quite an experience. To measure the distance covered by informatics in the intervening 56 years, let us just say I would much prefer to drive every day an automobile built in 1959 (a Land Rover Series II would do very nicely, thank you) than a computer and compiler combination of the same vintage.
Programmer en COBOL
Les utilisateurs d'Ubuntu sommes des gens modernes. Nous utilisons des tablettes and des smartphones qui n'existaient même pas il y a dix ans. Nous attendons impatiemment que chaque version successive d'Ubuntu soit plus révolutionnaire que la dernière, parue il y a seulement six mois. N'est-ce pas le progrès ? N'est-ce pas bien là le siècle 21 avec sa vitesse de l'éclair ?
Il peut donc sembler assez particulier d'écrire à propos d'un langage de programmation tel que COBOL. Après tout, le Common Business-Oriented Language est apparu en l'an 1959, dans une époque où la programmation ne consistait pas à exécuter un JavaScript dans un navigateur d'Internet, et que le mot informatique ne se centrait pas encore dans la connexion de téléphones à écran tactile, au dernier réseau mobile à haut débit. Dans ce temps-là, même regarder l'ordinateur vous faire des clignotements de lumière devait être toute une expérience. Pour mesurer la distance couverte par l'informatique pendant ces 56 années, disons seulement que je préférerais conduire tous les jours un véhicule construit en 1959 (un Land Rover Series II fera très bien l'affaire, merci) que la combinaison d'ordinateur et d'un compilateur de cette année.
Just before year 2000 and the infamous “year-2k bug” that was supposed to bite us all in the nose (but never quite did – because we were prepared for it!) it came to the attention of many IT department heads that a sizable portion of computer programs used had been originally written COBOL. This was mainly true in the finance industry. Having been passed from one generation of hardware to another and recompiled several times in the process, the programs handled most core processes and were well placed to last longer than the human programmers that had created them in the first place – and who were at that time heading towards retirement, if not already there. A scarcity of programmers of the younger generations able to comprehend, let alone maintain, code written in COBOL seemed to be in the cards. Fifteen years on, this still seems to be a bit of a concern even in year 2015, at least according to some. However, a large part of the programs must have needed to be re-written at some point if only to adapt to the needs of e-banking and e-business, and writing newer programs from scratch in COBOL is less often seen these days. However, the COBOL language still seems to have been maintained, with even an object-oriented version being announced in 2002 and a more advanced standard published in 2014. IBM seems to be a major player on the field, although it also gives active support to other offerings (such as Java) for programming mainframes. On the GNU/Linux side, OpenCOBOL (http://www.opencobol.org/) appeared to give us the possibility of compiling working programs on the most recent Ubuntu systems, which has then been re-branded (superseded) by GNU Cobol since version 1.1. It was mainly from a standpoint of historical interest that I installed this compiler, and managed to get an Euclidian Algorithm program up and running quite easily, with procedure calls and even some invocation of routines written in the C language by the side.
Juste avant l'année 2000 et le fameux « bogue de l'année 2000 » qui devait nous mordre tous (mais qui ne l'a jamais fait – puisque nous nous sommes préparés à temps!) il est arrivé à l'attention de beaucoup de directeurs d'informatique que une proportion non négligeable des logiciels en fonctionnement avaient été écrits originalement en COBOL. Ce fut vrai surtout dans le secteur des finances. Ces programmes avaient été passés d'une génération de matériel à la prochaine et re-compilés plusieurs fois pendant ce temps, mais traitaient la plupart des processus centraux et étaient bien partis pour survivre plus longtemps que les programmeurs que les avaient conçus dans un premier temps – et qui étaient sur le bord de la retraite ou déjà là. Il se produisit donc une manque de programmeurs parmi les nouvelles générations qui soient capables de comprendre, voire de maintenir, du code écrit en COBOL. Quinze ans plus tard, cela est toujours un facteur de préoccupation, au moins pour certains. Par contre, une grand proportion des programmes a du être re-écrit à un certain moment, si seulement pour s'adapter aux besoins de la banque et du commerce électroniques, et on voit moins souvent aujourd'hui des logiciels développés depuis le début en COBOL.
Ceci dit, le langage COBOL paraît avoir été développé toujours, avec même la parution d'une version orientée-objets en 2002 et un standard plus avancé publié en 2014. IBM sembla être toujours un participant important, bien qu'il donne un support aussi à d'autres options (telles que le Java) pour ce qui est de la programmation d'ordinateurs centraux. Du côté GNU/Linux, OpenCOBOL (http://www.opencobol.org/) est apparu pour nous donner la possibilité de compiler des programmes utiles sur les systèmes Ubuntu les plus récents, et puis a été re-batisé (remplacé par) GNU Cobol depuis la version 1.1.
J'ai installé ce compilateur surtout pour son intérêt historique, et suis arrivé à construire assez facilement un programme de Division Euclidienne, avec des appels à procédures et même l'invocation de routines écrits dans le langage C.
Installation Installation is the usual procedure on *buntu systems, since OpenCOBOL is available directly from the repositories. Simply use your favorite software package manager to install package open-cobol:
Installation
Son installation suit le procédure habituel sur des systèmes *Ubuntu, puisque OpenCOBOL est disponible directement depuis les répositoires. Utilisez simplement votre gestionnaire de logiciels favori pour installer le paquet open-cobol:
# aptitude install open-cobol
When this is installed, we can directly fire up the COBOL compiler in a terminal and investigate which version we are using:
Une fois installé, nous pouvons exécuter le compilateur COBOL directement dans un terminal, et découvrir quelle version nous avons installée :
$ cobc --version cobc (OpenCOBOL) 1.1.0 Copyright (C) 2001-2009 Keisuke Nishida / Roger While Built Nov 02 2013 00:16:01 Packaged Feb 06 2009 10:30:55 CET
As can be seen from the dates quoted, development of this compiler is not going along at the supersonic speeds seen in some open-source projects. However, this suits quite well the COBOL mindset that goes more for “steady does it” and “piano, piano si va lontano” than seeking out instant results. The compiler documentation gives us some insight into which COBOL dialects are supported. The ground-breaking 2002 version is there, though the 2014 update is not (yet) there:
Les dates nous montrent que le développement de ce compilateur n'avance pas aux vitesses supersoniques que l'on voit chez certains projets de code ouvert. Mais cela concorde assez bien avec la mentalité de COBOL qui préfère cheminer doucement selon le principe de “piano, piano si va lontano” plutôt que de chercher à obtenir des résultats immédiats.
La documentation du compilateur nous informe sur les dialectes de COBOL qui sont supportés. La version séminale de 2002 y est, mais non (ou pas encore) celle de la mise-à-jour du 2014 :
- std=<dialect> Compile for a specific dialect :
cobol2002 Cobol 2002
cobol85 Cobol 85
ibm IBM Compatible
mvs MVS Compatible
bs2000 BS2000 Compatible
mf Micro Focus Compatible
default When not specified
Compiling “Hello, world!” A very basic program in traditional, old-style fixed-format COBOL runs like this:
Compiling “Hello, world!”
Voici un exemple de programme très basique, dans un COBOL traditionnel à format d'entrée fixe :
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
DISPLAY 'Hello, world'.
STOP RUN.
Note that this syntax -originally thought out for punched cards- is all about spacing. The first six characters on each line (columns 1 to 6) are reserved to identify each program line with a number – though nowadays numbers are no longer mandatory. Column 7 is an indicator area that can be used to mark a line as a commentary by inserting an asterisk “*” character in this space. Finally, only a maximum of 72 characters may be used in each line, thus leaving just 72 - 7 = 65 characters to write actual code in. Fire up your favorite text editing program, and type or paste in this text. Save the file as “hello.cob” or “hello.cbl” – COBOL source code file extensions vary a bit. Unfortunately, there are not many text editors in Ubuntu that can handle COBOL syntax highlighting. However, the jedit program is available, easily installable from the repositories, and does just that quite well: Once saved, let us compile our first program. We will need to use option “-x” to request the compiler to perform linkage as well as compilation proper, and produce an executable file:
Notez que ce syntaxe -conçu originalement pour les cartes perforées- est basé sur le compte de caractères. Les premiers six caractères de chaque line (les colonnes 1 à 6) sont réservés pour la numérotation de chaque ligne du programme – bien que les numéros de ligne ne soient plus obligatoires aujourd'hui. La colonne numéro 7 est utilisé pour indiquer que la ligne est un commentaire, à travers du caractère « * ». Finalement, seulement 72 caractères peuvent être utilisés en tout pour chaque ligne, laissant that this syntax -originally thought out for punched cards- is all about spacing. The first six characters on each line (columns 1 to 6) are reserved to identify each program line with a number – though nowadays numbers are no longer mandatory. Column 7 is an indicator area that can be used to mark a line as a commentary by inserting an asterisk “*” character in this space. Finally, only a maximum of 72 characters may be used in each line, thus leaving just 72 - 7 = 65 characters to write actual code in.
Mettez en route votre éditeur de textes favori, et copiez ou collez-y ce texte. Enregistrez le fichier comme « hello.cob »ou « hello.cbl »“ – les extensions de fichiers source COBOL varient un peu. Malheureusement, il n'existe guère d'éditeurs sous Ubuntu qui sachent gérer le coloriage de syntaxe COBOL. Mais le logiciel jedit est disponible, facile à installer depuis les répositoires, et le réussit assez bien :
Une fois le fichier créé, compilons notre premier programme. Nous indiquerons l'option « -x » pour demander au compilateur de faire le linking en plus de la compilation en soi, produisant ainsi un fichier exécutable :
$ cobc hello.cob -x
Here we have our source code, and the executable program, which can then be executed:
Nous avons ainsi le fichier code source, et le programme exécutable qui peut alors être exécuté :
$ ls hello hello.cob $ ./hello Hello, world
It is noteworthy that, since I was doing this on a 64-bit version of Linux Mint, what the compiler produced is in fact a 64-bit executable file! I wonder what the original creators of the language would have thought of that:
Il est intéressant de noter que, puisque je faisais cette compilation sous une version de 64 bits de Linux Mint, le compilateur vient en fait de produire un fichier exécutable en code 64-bits ! Je me demande ce que les concepteurs originels du langage n'auraient pensé.
$ ldd hello [...] /lib64/ld-linux-x86-64.so.2 (0x00007f277d149000)
Free-form and procedures The programing world has gone forward a tad since the original specification for COBOL was published. Among other things, writing programs in ALL CAPITAL LETTERS is no longer considered the only true way of getting things done, and modern script-kiddies would have difficulties abiding with the very strict column syntax of earlier versions. This why later COBOL dialects have progressively reduced the constraints on formal program presentation, giving up free-form syntax. Some of the parts, such as the identification division, no longer need to be specified. The same HelloWorld program may be written in free form in the following manner:
La forme libre et les procédures.
Le monde de la programmation a avancé un peu depuis que la spécification originelle de COBOL fut publiée. Parmi d'autres points, il ne considère plus que le fait d'écrire des programmes COMPLETEMENT EN MAJUSCULES soient l'unique manière de procéder, et les jeunes concepteurs de scripts aujourd'hui auraient quelques difficultés à suivre le syntaxe en colonnes très stricte des versions antérieures. C'est pourquoi les dialectes de COBOL plus récents ont progressivement réduit les contraintes formelles de présentation, allant vers le syntaxe de forme libre. Certaines parties du programme, comme la Identification division, ne doivent plus être incluses obligatoirement. Le même programme Hello World peut être écrit en forme libre de la manière suivante :
program-id. HelloWorld. procedure division. display "Hello, world". stop run. end program HelloWorld.
From the compiler's point of view, all we need to do is specify that we are going to use free-form, and the very same executable file may be produced:
Du point de vue du compilateur, tout ce que nous devons indiquer est que nous allons utiliser la forme libre, et un fichier exécutable identique sera produit :
$ cobc hello.cob -x -free
Let us now complicate things. We are now going to split the program up into two parts: a main procedure that will be invoked on program execution, and a sub-program (procedure) that actually does the dirty work when required by the main procedure. To go a step further, we will declare a variable and initialize it with the text to be displayed. The main program goes as follows:
Compliquons maintenant un peu les choses. Nous allons séparer le programme en deux parties : une procédure principale qui sera invoquée au moment de la mise en route du programme, et une sous-procédure qui sera en fait chargée d'accomplir les bases besognes dès son invocation depuis la principale. Pour aller encore plus loin, nous allons déclarer une variable et l'initialiser avec le texte à afficher. Le programme principal est comme suit :
program-id. HelloWorld. data division. working-storage section. 01 Greeting PIC X(15) value "Hello, world!". procedure division. call "TestSub" using Greeting. stop run. end program HelloWorld.
A new data division has appeared before the procedure division. This contains a working-storage section, which is where local variables are declared using the PIC syntax. Variables may be immediately initialized using the value keyword. Now, for the procedure TestSub. This must be written in a new program-id section, that may be inserted within the same file as the main program. For example:
Une nouvelle Data division est apparue devant le Procedure division. Elle contient une section Working-storage, où les variables locales sont déclarées avec le syntaxe PIC. Les variables peuvent être initialisées immédiatement avec le mot clé value.
Ecrivons maintenant le procédure TestSub. Il doit être déclaré dans une nouvelle section program-id, mais qui peut se trouver dans le même fichier que le programme principal. Par exemple :
program-id. TestSub. data division. linkage section. 01 Grt PIC X(15). procedure division using Grt. display "This is TestSub". display "Grt = " Grt. exit program. end program TestSub.
In this case, procedure TestSub will be invoked by the main program using one parameter, the text to be displayed. We have also inserted a data division within the sub-program, declaring this parameter within the linkage section. For clarity, the parameter name is “Grt” within the sub-program, and “Greeting” in the main. Just a word of warning: parameters are called by reference, so if changes were eventually to be made to “Grt” within the sub-program, these changes would then be maintained in Greeting when returning to the main procedure. Programmers should exercise caution, specially if accustomed to C's way of passing parameters (call by value). However, it should also be said that this feature facilitates returning values from a sub-program to the routine that invokes it.
Dans ce cas, TestSub sera invoqué par le programme principal à l'aide d'un paramètre, le texte à afficher. Nous avons aussi inséré une Data division dans le sous-programme, déclarant ce paramètre dans la Linkage section.
Pour être plus clairs, nous avons donné à ce paramètre le nom « Grt » dans le sous-programme, et « Greeting » dans le programme principal. Mais attention : les paramètres seront passés par référence, donc si Grt recoit des modifications dans le sous-programme, ces modifications seront rapportées sur Greeting dans le programme principal au retour de l'invocation. Les programmeurs doivent être spécialement vigilants sur ce point, surtout s'ils sont habitués à coder suivant les conventions du langage C (passage par valeur). Bien qu'il soit aussi vrai que cette caractéristique facilite le retour de valeurs depuis le sous-programme vers le programme principal.