Modernisation du code hérité avec GitHub Copilot

Le code hérité est un code ancien, obsolète ou qui n’est plus pris en charge par les développeurs d’origine. Il peut être difficile à maintenir et à étendre, car il peut ne pas suivre les meilleures pratiques modernes, telles que l’utilisation de conventions de nommage cohérentes ou la rédaction d’une documentation claire.

La modernisation du code hérité peut vous aider à :

• Améliorer l’analyse des performances et la scalabilité.
• Faciliter la maintenance et l’extension du code.
• Réduire le risque d’introduire des bogues lors des modifications.
• Faciliter les tests du code.

Copilot peut vous aider à moderniser votre code hérité en :

• Fournissant des suggestions pour refactoriser le code afin de suivre les meilleures pratiques modernes.
• **Générant de la documentation ** pour vous aider à comprendre comment le code fonctionne.
• **Générant des tests ** pour vous aider à vérifier que vos modifications n’ont pas introduit de bogues.

Exemple de scénario

Dans cet exemple, nous allons examiner un système de gestion de comptes écrit en COBOL et le moderniser en Node.js. Vous trouverez le code COBOL dans le référentiel modernize-legacy-cobol-app.

Le système de gestion des comptes comprend trois fichiers clés :

• main.cob : le programme principal qui lit les entrées de l’utilisateur et appelle le sous-programme approprié.
• operations.cob : un sous-programme qui effectue des opérations sur les données du compte, telles que le crédit, le débit et la consultation du solde.
• data.cob : un sous-programme qui gère le stockage du solde du compte.

Étape 1 : obtenir une copie locale du référentiel

Avant de compiler et d’exécuter le programme, vous devez disposer du code localement. Si vous n’avez pas encore cloné le référentiel, naviguez jusqu’au répertoire dans lequel vous souhaitez stocker le projet et exécutez la commande suivante :

git clone https://github.com/continuous-copilot/modernize-legacy-cobol-app.git

git clone https://github.com/continuous-copilot/modernize-legacy-cobol-app.git

Étape 2 : compiler et exécuter le programme

Vous pouvez soit installer un compilateur COBOL dans votre environnement de développement préféré (par exemple, le compilateur open source GnuCOBOL), soit utiliser Copilot Chat dans GitHub Codespaces.

Si vous utilisez MacOS, vous pouvez installer GnuCOBOL à l’aide de Homebrew :

brew install gnu-cobol

brew install gnu-cobol

Si vous utilisez Codespaces ou un système Ubuntu Linux, vous pouvez installer GnuCOBOL à l’aide de apt :

sudo apt-get update && \
sudo apt-get install gnucobol

sudo apt-get update && \
sudo apt-get install gnucobol

Pour compiler le code, liez les fichiers et créez un exécutable, exécutez la commande suivante à partir de la racine du référentiel :

cobc -x main.cob operations.cob data.cob -o accountsystem

cobc -x main.cob operations.cob data.cob -o accountsystem

Pour exécuter le programme, utilisez la commande suivante :

./accountsystem

./accountsystem

Étape 3 : expliquer les fichiers et le code

La première étape de la modernisation du code consiste à comprendre son fonctionnement. Vous pouvez demander à Copilot Chat d'expliquer le code dans chaque fichier.

Ouvrez le référentiel dans votre IDE, puis, dans le panneau Copilot Chat, entrez l'invite suivante.

Exemples d’invite 1

/explain #file:main.cob #file:operations.cob #file:data.cob Can you please create a high level overview of the app. It will be great if you can explain each file in detail and how they are linked.

Exemples de réponse 1

Voici un extrait de la réponse au prompt ci-dessus :

Sure! Here's a high-level overview of the COBOL application, along with detailed explanations of each file and how they are linked together.

High-Level Overview

This COBOL application simulates an account management system. It allows users to view the current balance, credit the account, debit the account, and exit the application. The application is divided into three main COBOL source files: main.cob, operations.cob, and data.cob. ...

Étape 4 : tracer le flux de données entre les fichiers

L’étape suivante consiste à comprendre comment les fichiers sont liés. Vous pouvez utiliser @workspace pour créer un diagramme de flux de données pour l’application.

Exemple d'invite 2

@workspace can you create a sequence diagram of the app showing the data flow of the app. Please create this in mermaid format so that I can render this in a markdown file.

Copilot génère le balisage Mermaid pour un diagramme de séquence complet qui montre comment l’application fonctionne. Vous pouvez copier et coller ce balisage dans une application Mermaid pour générer le diagramme.

Étape 5 : générer un plan de test

Créez un plan de test pour vous assurer que l’application fonctionne comme prévu après avoir apporté des modifications. Vous pouvez utiliser @workspace pour générer un plan de test qui couvre tous les fichiers du projet.

Exemple de prompt 3

@workspace The current Cobol app has no tests. Can you please create a test plan of current business logic that I can use to validate with business stakeholders about the current implementation.

Later I would like to use this test plan to create unit and integration tests in a node.js app. I am in the middle of transforming the current Cobol app to a node.js app.

The test plan should include the following:

1. Test Case ID
2. Test Case Description
3. Pre-conditions
4. Test Steps
5. Expected Result
6. Actual Result
7. Status (Pass/Fail)
8. Comments

Please create the test plan in a markdown table format. The test plan should cover all the business logic in the current Cobol app.

Convert this to markdown syntax to insert as a new file

Copilot génère un plan de test au format Markdown que vous pouvez utiliser pour valider l’application. Pour utiliser ce plan plus tard dans le processus, créez un fichier appelé TESTPLAN.md et copiez-y le plan suggéré. Vous pourrez ainsi référencer le plan de test lors de la génération des cas de test dans les étapes suivantes.

Étape 6 : convertir les fichiers de COBOL en Node.js

L’étape suivante consiste à convertir les fichiers COBOL en Node.js. Il est important de garder à l’esprit les pratiques suivantes concernant les prompts :

• Fournir un contexte
• Donner des instructions claires
• Être précis sur le résultat que vous souhaitez obtenir

Commencez par créer un répertoire temporaire au sein de votre projet, dans lequel vous enregistrerez les fichiers JavaScript que vous allez créer.

mkdir temp-JS-project-directory

mkdir temp-JS-project-directory

Ensuite, convertissez de manière itérative les fichiers COBOL en Node.js.

Exemple de prompt 4

Can you convert code in #file:main.cob to node.js?

Exemples de réponse 4

Sure! Here is the equivalent Node.js code for the main.cob file. This code will simulate the same account management system functionality.

### COBOL Code:

main.cob

```COBOL
IDENTIFICATION DIVISION.
       PROGRAM-ID. MainProgram.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  CONTINUE-FLAG      PIC X VALUE 'Y'.
       01  USER-CHOICE        PIC 9.
       01  FINAL-BALANCE      PIC 9(6)V99 VALUE 1000.00.

       PROCEDURE DIVISION.
           PERFORM UNTIL CONTINUE-FLAG = 'N'
               DISPLAY "1. View Balance"
               DISPLAY "2. Credit Account"
               DISPLAY "3. Debit Account"
               DISPLAY "4. Exit"
               ACCEPT USER-CHOICE

               EVALUATE USER-CHOICE
                   WHEN 1
                       CALL 'Operations' USING 'TOTAL'
                   WHEN 2
                       CALL 'Operations' USING 'CREDIT'
                   WHEN 3
                       CALL 'Operations' USING 'DEBIT'
                   WHEN 4
                       MOVE 'N' TO CONTINUE-FLAG
                       DISPLAY "Exiting the program. Goodbye!"
                   WHEN OTHER
                       DISPLAY "Invalid choice. Please try again."
               END-EVALUATE
           END-PERFORM
           STOP RUN.

### Node.js Code: `main.js`
```javascript
const readline = require('readline');

let continueFlag = 'Y';
let finalBalance = 1000.00;

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

function displayMenu() {
    console.log("1. View Balance");
    console.log("2. Credit Account");
    console.log("3. Debit Account");
    console.log("4. Exit");
}

function handleUserChoice(choice) {
    switch (choice) {
        case '1':
            viewBalance();
            break;
        case '2':
            creditAccount();
            break;
        case '3':
            debitAccount();
            break;
        case '4':
            continueFlag = 'N';
            console.log("Exiting the program. Goodbye!");
            rl.close();
            break;
        default:
            console.log("Invalid choice. Please try again.");
            promptUser();
            break;
    }
}

function viewBalance() {
    console.log(`Current balance: ${finalBalance.toFixed(2)}`);
    promptUser();
}

function creditAccount() {
    rl.question("Enter credit amount: ", (amount) => {
        amount = parseFloat(amount);
        if (!isNaN(amount) && amount > 0) {
            finalBalance += amount;
            console.log(`Amount credited. New balance: ${finalBalance.toFixed(2)}`);
        } else {
            console.log("Invalid amount. Please try again.");
        }
        promptUser();
    });
}

function debitAccount() {
    rl.question("Enter debit amount: ", (amount) => {
        amount = parseFloat(amount);
        if (!isNaN(amount) && amount > 0) {
            if (finalBalance >= amount) {
                finalBalance -= amount;
                console.log(`Amount debited. New balance: ${finalBalance.toFixed(2)}`);
            } else {
                console.log("Insufficient funds for this debit.");
            }
        } else {
            console.log("Invalid amount. Please try again.");
        }
        promptUser();
    });
}

function promptUser() {
    if (continueFlag === 'Y') {
        displayMenu();
        rl.question("Select an option: ", handleUserChoice);
    }
}

promptUser();

This Node.js code replicates the functionality of the COBOL main.cob file, providing a simple command-line interface for viewing the balance, crediting the account, debiting the account, and exiting the application.

Vous devez examiner attentivement le code suggéré avant de l’utiliser. Une fois que vous êtes satisfait du code généré, suivez ces étapes pour l’enregistrer localement et terminer la conversion :

1. Dans le répertoire temporaire que vous avez créé précédemment, créez un fichier appelé main.js.
2. Copiez le code généré dans le panneau Copilot Chat et collez-le dans main.js.
3. Enregistrez le fichier.
4. Utilisez des prompts similaires pour convertir operations.cob et data.cob en Node.js.
5. Créez des fichiers JavaScript correspondants, operations.js et data.js, dans le même répertoire temporaire.
6. Copiez et collez le code généré dans chaque fichier, puis enregistrez-les.

Étape 7 : relier les fichiers et configurer un projet Node.js fonctionnel

Une fois que vous avez converti tous les fichiers en Node.js, vous devez les relier et configurer un projet Node.js fonctionnel.

1. Accédez au répertoire temporaire dans votre terminal.

2. Exécutez la commande suivante pour créer un fichier package.json :

   Shell

   npm init -y
   

3. Si votre application nécessite des packages externes, installez-les en exécutant :

   Shell

   npm install
   

4. Démarrez l’application en exécutant :

   Shell

   npm start
   

À ce stade, l’application Node.js peut ne pas répliquer entièrement les fonctionnalités du programme COBOL d’origine. Par exemple, les soldes peuvent ne pas se mettre à jour correctement ou les calculs peuvent ne pas correspondre à la logique COBOL.

Pour perfectionner l’application, vous devrez :

• Identifier les comportements incorrects en exécutant le programme et en le comparant à la version COBOL.

• Travailler de manière itérative avec Copilot pour ajuster la logique jusqu’à ce que le programme Node.js se comporte comme prévu.

• Utiliser des prompts ciblés pour déboguer et améliorer des parties spécifiques du code, telles que :

  @workspace - analyze main.js and ensure account balance updates correctly when crediting an account.

La refactorisation du code hérité n’est pas toujours un processus en une seule étape. Copilot peut vous aider à déboguer et à améliorer les fonctionnalités à mesure que vous perfectionnez votre nouvelle implémentation Node.js.

Étape 8 : générer des tests unitaires et d’intégration

L’étape suivante consiste à générer des tests unitaires et d’intégration pour s’assurer que l’application fonctionne comme prévu. Vous pouvez utiliser @workspace pour générer un plan de test qui couvre tous les fichiers du projet.

Exemple de prompt 5

@workspace I would like to create unit and integration tests cases from the test plan mentioned in #file:TESTPLAN.md file The node.js code is in node-accounting-app folder and I am looking to generate tests for #file:operations.js file. Use a popular testing framework and also provide all the dependencies required to run the tests.

Exemples de réponse 5

Copilot génère un certain nombre de tests dans Jest, une infrastructure de test JavaScript, avec un guide complet, étape par étape, sur la façon de les implémenter et de les exécuter.

Voici un extrait de la réponse au prompt ci-dessus :

“This test plan covers the main functionalities of the COBOL application, including viewing the balance, crediting the account, debiting the account, and exiting the application. The test cases are implemented using Jest, a popular testing framework for Node.js. Validate this test plan with the business stakeholders to ensure it meets the business requirements. Once validated, you can use this plan to create corresponding unit tests and integration tests for the Node.js application.”

Étape 9 : exécuter des tests et perfectionner le code

Après avoir généré le plan de test et rédigé les tests, vous devrez les exécuter et corriger les tests échoués. Les tests sont un processus itératif, vous devrez peut-être modifier le code pour résoudre les problèmes, puis relancer les tests jusqu’à ce que tout soit validé.

Si un test échoue, utilisez Copilot pour faciliter le débogage et perfectionner l’implémentation.

Exemple de prompt 6

@workspace - analyze test failures in operations.test.js and suggest fixes to match the expected behavior.

Même si tous les tests sont réussis, le programme peut toujours présenter des problèmes. Les tests automatisés ne détectent pas toujours les fonctionnalités manquantes ou les erreurs logiques. Des tests manuels sont donc nécessaires pour s’assurer que l’application fonctionne comme prévu.

Étape 10 : déplacer le projet JavaScript vers un nouvel emplacement

Une fois que l’application fonctionne comme prévu, déplacez le nouveau projet JavaScript hors du répertoire COBOL pour le garder séparé.

1. Accédez au répertoire parent du projet COBOL.

2. Déplacez le projet JavaScript vers un nouvel emplacement :

   Shell

   mv modernize-legacy-cobol-app new-js-project
   

3. Accédez au nouveau répertoire du projet et vérifiez que tout s’exécute correctement :

   Shell

   cd new-js-project
   npm start
   

Désormais, l’application Node.js restructurée se trouve dans son propre dossier de projet autonome, séparé des fichiers COBOL d’origine.

Conclusion

Dans cet exemple, nous avons examiné un système de gestion de comptes écrit en COBOL et l’avons modernisé en Node.js. Nous avons utilisé Copilot Chat pour expliquer le code, schématiser le flux de données, générer un plan de test et convertir le code en Node.js. En suivant ces étapes, vous pouvez moderniser votre code existant et faciliter sa maintenance et son extension. Voici quelques astuces supplémentaires pour moderniser le code hérité :

• Les meilleures pratiques en matière de prompts sont essentielles : la qualité de vos prompts détermine la qualité des suggestions de Copilot. Fournissez un contexte clair, décomposez les tâches complexes en étapes plus petites, donnez des exemples et fixez des objectifs spécifiques à atteindre pour Copilot. Cela rend votre flux de travail plus fluide et vos résultats plus précis
• Passez en revue le code avant de l’utiliser : assurez-vous de bien comprendre le code fourni par Copilot avant de l’utiliser dans votre application. Cela vous aidera à détecter les éventuels problèmes et à vous assurer que le code répond à vos besoins.
• Validez vos modifications : après avoir apporté des modifications au code, il est important de vérifier que l’application fonctionne toujours comme prévu. Vous pouvez utiliser le plan de test généré par Copilot pour créer des tests unitaires et d’intégration pour l’application.

Travaux pratiques

Essayez l'exercice Moderniser votre code existant avec GitHub Copilot Exercice de compétences pour une expérience pratique de la mise à jour d'un code existant avec GitHub Copilot.

Pour aller plus loin

• Documenter le code existant
• Modernisation du code hérité avec GitHub Copilot : astuces et exemples sur le blog GitHub