Réflexions par Thomas Derflinger
Comment convertir automatiquement COBOL en Go
Bien que COBOL puisse être considéré comme un langage hérité, il existe encore des milliards de lignes de COBOL en production. La modernisation de ces systèmes, dont l'exploitation et la maintenance sont coûteuses, est un véritable défi. Une solution à ce problème est un transpileur COBOL vers Go que je souhaite présenter dans cet article.
COBOL
COBOL est apparu pour la première fois en 1959 et est un langage compilé conçu pour un usage professionnel. Aujourd'hui, ce sont surtout les grandes institutions financières et les agences gouvernementales qui ont des systèmes utilisant COBOL en production. Il est souvent déployé sur des ordinateurs centraux, par exemple l'ordinateur central Z fonctionnant sous z/OS d'IBM. Il s'agit d'un marché important, car environ 10 000 ordinateurs centraux fonctionnent dans le monde. Bien que des fonctionnalités orientées objet soient désormais disponibles, le COBOL est principalement un langage procédural et impératif. Voici un simple programme de mots d'accueil en COBOL :
hello.cob
* Sample COBOL program
IDENTIFICATION DIVISION.
PROGRAM-ID. hello.
PROCEDURE DIVISION.
DISPLAY "Hello, world!".
STOP RUN.
Vous pouvez l'essayer sur votre propre ordinateur, par exemple avec GnuCOBOL en exécutant la commande de compilation suivante :
$ cobc -x hello.cob
$ ./hello
Go
Go est un langage de programmation de haut niveau compilé et typé statiquement, conçu chez Google par Robert Griesemer, Rob Pike et Ken Thompson. Ses avantages sont la faible barrière d'entrée pour les nouveaux développeurs et le fait qu'il s'agisse d'un langage compilé à exécution rapide. C'est donc un bon choix pour moderniser des applications COBOL héritées du passé.
Le code source de Go est facile à comprendre, même pour les nouveaux programmeurs. C'est un avantage car le marché des développeurs de logiciels COBOL est difficile, comme je le décris dans la section suivante.
Marché des programmeurs COBOL
De nombreuses grandes entreprises qui ont des systèmes fonctionnant en COBOL ont du mal à attirer des programmeurs capables de maintenir ces systèmes. L'âge moyen des développeurs de logiciels COBOL est élevé et peu de jeunes développeurs souhaitent apprendre le COBOL, ce qui représente un risque pour les entreprises qui ont plusieurs milliards de lignes de COBOL en production. C'est pourquoi une solution de migration telle que COBOL-to-Go d'Enno Richter s'avère utile.
COBOL-to-Go Converter
Le programmeur COBOL senior Enno Richter, fort de plusieurs décennies (50 ans) d'expérience dans la programmation COBOL, a mis au point un transpileur COBOL vers Go appelé COBOL-to-Go. Ce transpileur est issu d'un ancien projet RPG-to-COBOL. Il prend en charge la norme COBOL-85, mais des fonctionnalités des normes COBOL plus récentes peuvent être ajoutées à la demande. L'un de ses avantages est que le code Go résultant est facile à lire et clairement structuré.
Aucun système d'exécution n'est nécessaire et le code Go résultant reste donc indépendant du système COBOL-to-Go. Go se compile sur de nombreux systèmes d'exploitation et le programme COBOL peut donc s'exécuter sur un grand nombre de systèmes d'exploitation. Tous les droits du code Go résultant restent la propriété des détenteurs du code COBOL.
Il existe d'autres transpileurs COBOL, comme un transpileur COBOL vers Java sur le marché, mais Enno Richter affirme que les résultats de son transpileur Go sont plus faciles à comprendre et à maintenir.
Exemple de code
L'extrait suivant montre le code COBOL sur la gauche et le code Go transpilé résultant sur la droite. Il se peut que vous deviez faire défiler l'écran horizontalement pour voir le code Go résultant :
* :00190: // 00190: *
*----------------------------------------------------------------* :00191: // 00191: *----------------------------------------------------------------
**------* *-----------------------------------------------------** :00192: // 00192: **------* *-----------------------------------------------------*
** 30 * * P R O G R A M M A B L A U F ** :00193: // 00193: ** 30 * * P R O G R A M M A B L A U F *
**------* *-----------------------------------------------------** :00194: // 00194: **------* *-----------------------------------------------------*
PROCEDURE DIVISION. :00195:
**---------------------------------------------------------------* :00196: // 00196: **---------------------------------------------------------------
** V e r a r b e i t u n g * :00197: // 00197: ** V e r a r b e i t u n g
**---------------------------------------------------------------* :00198: // 00198: **---------------------------------------------------------------
DISPLAY "Test_02400_START --------". :00199: erse.DISlx(&DIS, "Test_02400_START --------") // COBZEI:00199
ersestr1 = erse.DISout(fDISPLAY, &DIS, " ") // COBZEI:00199
* :00200: // 00200: *
* :00201: // 00201: *
**-----------------------------------------------------------* :00202: // 00202: **-----------------------------------------------------------*
** IF LITERAL --- NUMERISCH (Struktur) * :00203: // 00203: ** IF LITERAL --- NUMERISCH (Struktur) *
**-----------------------------------------------------------* :00204: // 00204: **-----------------------------------------------------------*
* IF 12 > BBB-8 :00205: // 00205: * IF 12 > BBB-8
* MOVE SPACE TO BBB-1 :00206: // 00206: * MOVE SPACE TO BBB-1
* END-IF. :00207: // 00207: * END-IF.
* :00208: // 00208: *
* :00209: // 00209: *
**-----------------------------------------------------------* :00210: // 00210: **-----------------------------------------------------------*
** IF NUMERISCH (Struktur) --- LITERAL * :00211: // 00211: ** IF NUMERISCH (Struktur) --- LITERAL *
**-----------------------------------------------------------* :00212: // 00212: **-----------------------------------------------------------*
* IF BBB-8 > 12 :00213: // 00213: * IF BBB-8 > 12
* MOVE SPACE TO BBB-1 :00214: // 00214: * MOVE SPACE TO BBB-1
* END-IF. :00215: // 00215: * END-IF.
* :00216: // 00216: *
* :00217: // 00217: *
**-----------------------------------------------------------* :00218: // 00218: **-----------------------------------------------------------*
** IF LITERAL --- NUMERISCH (Nativ) * :00219: // 00219: ** IF LITERAL --- NUMERISCH (Nativ) *
**-----------------------------------------------------------* :00220: // 00220: **-----------------------------------------------------------*
* IF 12 > Z3 :00221: // 00221: * IF 12 > Z3
* MOVE SPACE TO BBB-1 :00222: // 00222: * MOVE SPACE TO BBB-1
* END-IF. :00223: // 00223: * END-IF.
* :00224: // 00224: *
* :00225: // 00225: *
**-----------------------------------------------------------* :00226: // 00226: **-----------------------------------------------------------*
** IF NUMERISCH (Nativ) --- LITERAL * :00227: // 00227: ** IF NUMERISCH (Nativ) --- LITERAL *
**-----------------------------------------------------------* :00228: // 00228: **-----------------------------------------------------------*
* IF Z3 > 12 :00229: // 00229: * IF Z3 > 12
* MOVE SPACE TO BBB-1 :00230: // 00230: * MOVE SPACE TO BBB-1
* END-IF. :00231: // 00231: * END-IF.
* :00232: // 00232: *
* :00233: // 00233: *
**-----------------------------------------------------------* :00234: // 00234: **-----------------------------------------------------------*
** IF NUMERISCH (Struktur) ---- NUMERISCH (Struktur) * :00235: // 00235: ** IF NUMERISCH (Struktur) ---- NUMERISCH (Struktur) *
**-----------------------------------------------------------* :00236: // 00236: **-----------------------------------------------------------*
IF BBB_8 > HHH :00237: if erse.IFNCVCV(&BBB_8_cv, ">", &HHH_cv) {
MOVE SPACE TO BBB_1 :00238: erse.MVACVLI(&BBB_1_cv,"SPACE") // COBZEI:00238
END-IF. :00239: } // ENDIF
* :00240: // 00240: *
* :00241: // 00241: *
**-----------------------------------------------------------* :00242: // 00242: **-----------------------------------------------------------*
** P R O G R A M M - E N D E * :00243: // 00243: ** P R O G R A M M - E N D E *
**-----------------------------------------------------------* :00244: // 00244: **-----------------------------------------------------------*
DISPLAY "Test_02400 ENDE -------------". :00245: erse.DISlx(&DIS, "Test_02400 ENDE -------------") // COBZEI:00245
ersestr1 = erse.DISout(fDISPLAY, &DIS, " ") // COBZEI:00245
STOP RUN. :00246: //---------------------------------------------------------------
// STOP-RUN (Ende der Programmlogik)
//---------------------------------------------------------------
os.Exit(0)
**--------------------------------------------------------------** :00247: // 00247: **--------------------------------------------------------------*
** Ende : ** :00248: // 00248: ** Ende : *
** ~~Projekt~111COBOL~Sourcen~Test_02400.cbl (2023-04-20 ** :00249: // 00249: ** //Projekt/111COBOL/Sourcen/Test_02400.cbl (2023-04-20 *
* ** :00250: // 00250: * *
**--------------------------------------------------------------** :00251: // 00251: **--------------------------------------------------------------*
Comme vous pouvez le voir, le code Go résultant est facile à comprendre et à maintenir. Enno Richter est à la recherche de sociétés de collaboration qui peuvent distribuer son précieux projet. Si vous êtes intéressé, écrivez-moi un message ou contactez directement Enno Richter .
Conclusion
Avec cet article, j'espère que vous avez pu voir qu'il existe des solutions au problème du manque de programmeurs COBOL sur le marché. L'une de ces solutions est le transpileur COBOL-to-Go qui pourrait être la pièce manquante de votre migration COBOL.
Références
- Enno Richter Software : https://www.richter-software.de
- COBOL-to-Go : https://www.richter-software.de/fileadmin/pdf/COBOL-to-Go_Marketing_Folien_Web_Deutsch.pdf
- GnuCOBOL : https://gnucobol.sourceforge.io
- COBOL Programming Course : https://openmainframeproject.org/projects/cobol-programming-course
Photo de couverture par Pete Linforth de Pixabay
Publié le
25 juil. 2024
Écrit par Thomas Derflinger
Je suis un entrepreneur visionnaire et un développeur de logiciels. Dans ce blog, j'écris principalement sur la programmation web et des sujets connexes comme l'IdO.