Modernisieren von Legacycode mit GitHub Copilot

Copilot Chat unterstützt die Modernisierung von Legacycode durch Vorschläge zur Umgestaltung und das Erstellen von Tests, um potenzielle Probleme abzufangen.

In diesem Artikel

Note

Bei den in diesem Artikel veranschaulichten Antworten handelt es sich um Beispiele. Da die Copilot Chat-Antworten nicht deterministisch sind, erhältst du möglicherweise andere Antworten als die hier dargestellten.

Legacycode ist alter, veralteter oder nicht mehr von den ursprünglichen Entwickelnden unterstützter Code. Eine Verwaltung oder Erweiterung kann sich als schwierig erweisen, da er möglicherweise keine modernen Best Practices wie die Verwendung konsistenter Namenskonventionen oder das Verfassen einer klaren Dokumentation befolgt.

Die Modernisierung von Legacycode kann Folgendes unterstützen:

  • Verbessern der Leistung und Skalierbarkeit
  • Einfacheres Verwalten und Erweitern von Code
  • Verringern des Risikos für die Einzuführung von Fehlern bei Änderungen
  • Einfacheres Testen von Code

Copilot kann dich durch Folgendes bei der Modernisierung von Legacycode unterstützen:

  • Bereitstellen von Vorschlägen zum Umgestalten des Codes, um moderne Best Practices zu befolgen
  • Generieren der Dokumentation zum Nachvollziehen der Funktionsweise des Codes
  • Generieren von Tests zum Sicherstellen, dass durch Änderungen keine Fehler eingeführt wurden

Beispielszenario

In diesem Beispiel wird ein Kontoverwaltungssystem veranschaulicht, das in COBOL geschrieben wurde und in Node.js modernisiert wird. Der COBOL-Code befindet sich im Repository modernize-legacy-cobol-app.

Das Kontoverwaltungssystem besteht aus drei wichtigen Dateien:

  • main.cob: Das Hauptprogramm, das Benutzereingaben liest und das entsprechende Unterprogramm aufruft
  • operations.cob: Ein Unterprogramm, das Vorgänge für die Kontodaten ausführt, z. B. das Anzeigen von Kredit, Debit und Saldo
  • data.cob: Ein Unterprogramm, das den Speicher des Kontosaldos verwaltet

Schritt 1: Abrufen einer lokalen Kopie des Repositorys

Bevor du das Programm kompilierst und ausführst, musst du lokal über den Code verfügen. Wenn du das Repository noch nicht geklont hast, navigiere zu dem Verzeichnis, in dem du das Projekt speichern möchtest, und führe den folgenden Befehl aus:

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

Schritt 2: Kompilieren und Ausführen des Programms

Du kannst den COBOL-Compiler in deiner bevorzugten Entwicklungsumgebung installieren (z. B. den Open-Source-GnuCOBOL-Compiler) oder Copilot Chat in GitHub Codespaces verwenden.

Auf MacOS kannst du GnuCOBOL mithilfe von Homebrew installieren:

Shell
brew install gnu-cobol

Wenn du Codespaces oder ein Ubuntu Linux-System verwendest, kannst du GnuCOBOL mithilfe von apt installieren:

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

Um den Code zu kompilieren, die Dateien zu verknüpfen und eine ausführbare Datei zu erstellen, führe den folgenden Befehl aus dem Stammverzeichnis des Repositorys aus:

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

Verwende zum Ausführen des Programms den folgenden Befehl:

Shell
./accountsystem

Schritt 3: Erläutern von Dateien und Code

Der erste Schritt bei der Modernisierung des Codes besteht darin, seine Funktionsweise nachzuvollziehen. Du kannst Copilot Chat darum bitten, den Code in den einzelnen Dateien zu erläutern.

Öffne das Repository in deiner IDE, und gib anschließend im Copilot Chat-Panel den folgenden Prompt ein.

Beispielprompt 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.

Beispielantwort 1

Dieser Auszug stammt aus der Antwort auf den obigen Prompt:

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. ...

Schritt 4: Erstellen eines Diagramms für den Datenfluss zwischen den Dateien

Der nächste Schritt besteht darin, die Verknüpfung der Dateien nachzuvollziehen. Du kannst @workspace verwenden, um ein Datenflussdiagramm für die Anwendung zu erstellen.

Note

Der @workspace-Chatteilnehmer in VS Code und Visual Studio stellt Copilot Kontext für den gesamten Code in deinem Arbeitsbereich bereit. Du kannst @workspace verwenden, wenn Copilot die Struktur deines Projekts und die Art berücksichtigen soll, wie verschiedene Teile deines Codes interagieren. Wenn du eine JetBrains-IDE nutzt, solltest du @project anstelle von @workspace verwenden.

Beispielprompt 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 gibt das Mermaid-Markup für ein vollständiges Sequenzdiagramm aus, die Funktionsweise der Anwendung darstellt. Du kannst dieses Markup kopieren und in eine Mermaid-Anwendung einfügen, um das Diagramm zu generieren.

Schritt 5: Generieren eines Testplans

Erstelle einen Testplan, um eine erwartungsgemäße Funktionsweise der Anwendung nach dem Vornehmen von Änderungen sicherzustellen. Du kannst @workspace verwenden, um einen Testplan für alle Dateien im Projekt zu generieren.

Beispielprompt 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 gibt einen Testplan im Markdown-Format aus, das du zur Überprüfung der Anwendung verwenden kannst. Um diesen Plan später im Prozess zu verwenden, erstelle eine Datei namens TESTPLAN.md, und füge den vorgeschlagenen Plan in der Datei ein. Auf diese Weise kannst du in den nächsten Schritten beim Generieren von Testfällen auf den Testplan verweisen.

Schritt 6: Konvertieren der Dateien von COBOL in Node.js

Der nächste Schritt besteht darin, die COBOL-Dateien in Node.js zu konvertieren. Dabei sollte die folgende Vorgehensweise für Prompts berücksichtigt werden:

  • Bereitstellen von Kontext
  • Erteilen klarer Anweisungen
  • Angeben einer Definition des gewünschten Ergebnisses

Erstelle in deinem Projekt zunächst ein temporäres Verzeichnis, in dem die zu erstellenden JavaScript-Dateien gespeichert werden.

Shell
mkdir temp-JS-project-directory

Konvertiere anschließend die COBOL-Dateien iterativ in Node.js.

Beispielprompt 4

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

Beispielantwort 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.

Du solltest den vorgeschlagenen Code sorgfältig überprüfen, bevor du ihn verwenden. Wenn du mit dem generierten Code zufrieden bist, führe die folgenden Schritte aus, um ihn lokal zu speichern und die Konvertierung abzuschließen:

  1. Erstelle im zuvor erstellten temporären Verzeichnis eine neue Datei namens main.js.
  2. Kopiere den generierten Code aus dem Copilot Chat-Panel, und füge ihn in die Datei main.js ein.
  3. Speichern Sie die Datei.
  4. Verwende ähnliche Prompts, um operations.cob und data.cob in Node.js zu konvertieren.
  5. Erstelle im selben temporären Verzeichnis die entsprechenden JavaScript-Dateien operations.js und data.js.
  6. Kopiere den generierten Code, und füge ihn in jede Datei ein. Speichere die Dateien anschließend.

Nachdem du alle Dateien in Node.js konvertiert hast, musst du sie miteinander verknüpfen und ein funktionierendes Node.js-Projekt einrichten.

  1. Navigiere im Terminal zum temporären Verzeichnis.

  2. Führe den folgenden Befehl aus, um eine package.json-Datei zu erstellen:

    Shell
    npm init -y

  3. Wenn deine Anwendung externe Pakete benötigt, installiere diese, indem du den folgenden Befehl ausführst:

    Shell
    npm install

  4. Führen Sie den folgenden Befehl aus, um die App zu starten:

    Shell
    npm start

Zu diesem Zeitpunkt kann die Node.js-Anwendung die Funktionalität des ursprünglichen COBOL-Programms nicht vollständig replizieren. Beispielsweise wird das Saldo möglicherweise nicht ordnungsgemäß aktualisiert, oder die Berechnungen stimmen möglicherweise nicht mit der COBOL-Logik überein.

Zum Optimieren der Anwendung sind folgende Schritte erforderlich:

  • Identifizieren falschen Verhaltens durch das Ausführen des Programms und einen Vergleich mit der COBOL-Version

  • Iteratives Arbeiten mit Copilot zum Anpassen der Logik, bis sich das Node.js-Programm erwartungsgemäß verhält

  • Verwenden gezielter Prompts zum Debuggen und Verbessern bestimmter Teile des Codes, z. B.:

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

Der Prozess zum Umgestalten von Legacycode besteht häufig aus mehr als einem Schritt: Copilot kann dich beim Debuggen und Verbessern der Funktionalität unterstützen, während du deine neue Node.js-Implementierung optimierst.

Schritt 8: Generieren von Komponenten- und Integrationstests

Der nächste Schritt besteht darin, Komponenten- und Integrationstests zu generieren, um eine erwartungsgemäße Funktionsweise der Anwendung sicherzustellen. Du kannst @workspace verwenden, um einen Testplan für alle Dateien im Projekt zu generieren.

Beispielprompt 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.

Beispielantwort 5

Copilot generiert im JavaScript-Testframework Jest eine Reihe von Tests mit einer vollumfänglichen Anleitung zum Implementieren und Ausführen dieser Tests.

Dieser Auszug stammt aus der Antwort auf den obigen Prompt:

“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.”

Schritt 9: Ausführen von Tests und Optimieren des Codes

Nachdem du den Testplan generiert und die Tests geschrieben hast, musst du sie ausführen und alle Fehler beheben, die beim Ausführen der Tests auftreten. Das Testen ist ein iterativer Prozess. Möglicherweise musst du den Code ändern, um Probleme zu beheben, und die Tests anschließend erneut ausführen, bis alle Tests bestanden werden.

Wenn ein Test fehlschlägt, verwende Copilot zum Debuggen und Optimieren der Implementierung.

Beispielprompt 6

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

Selbst wenn alle Tests bestanden werden, kann das Programm weiterhin Probleme aufweisen. Automatisierte Tests erfassen nicht immer fehlende Funktionalität oder Logikfehler, wodurch manuelle Tests erforderlich sind, um eine erwartungsgemäße Funktionsweise der Anwendung sicherzustellen.

Schritt 10: Verschieben des JavaScript-Projekts an einen neuen Speicherort

Sobald die Anwendung erwartungsgemäß funktioniert, verschiebe das neue JavaScript-Projekt aus dem COBOL-Verzeichnis, um es vom COBOL-Projekt zu trennen.

  1. Navigiere zum übergeordneten Verzeichnis des COBOL-Projekts.

  2. Verschiebe das JavaScript-Projekt an einen neuen Speicherort:

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

  3. Navigiere zum neuen Projektverzeichnis, und überprüfe, ob alles ordnungsgemäß ausgeführt wird:

    Shell
    cd new-js-project
npm start

Die umgestaltete Node.js-Anwendung befindet sich nun in einem eigenen eigenständigen Projektordner und ist von den ursprünglichen COBOL-Dateien getrennt.

Zusammenfassung

In diesem Beispiel wurde ein Kontoverwaltungssystem veranschaulicht, das in COBOL geschrieben und in Node.js modernisiert wurde. Copilot Chat wurde verwendet, um den Code zu erläutern, ein Diagramm für den Datenfluss zu erstellen, einen Testplan zu generieren und den Code in Node.js zu konvertieren. Durch das Ausführen dieser Schritte kannst du Legacycode modernisieren, damit dieser einfacher verwaltet und erweitert werden kann. Hier findest du einige zusätzliche Tipps zum Modernisieren von Legacycode:

  • Best Practices für Prompts sind wichtige: Die Qualität deiner Prompts bestimmt die Qualität der Vorschläge von Copilot. Stelle klare Kontext bereit, unterteile komplexe Aufgaben in kleinere Schritte, stelle Beispiele bereit, und gib Copilot spezifische Ziele vor. Das führt zu einem optimierten Workflow und zu präziseren Ergebnissen.
  • Überprüfe den Code vor der Verwendung: Stelle sicher, dass du den Code verstehst, den Copilot bereitstellt, bevor du ihn in deiner Anwendung verwendest. Dadurch kannst du potenzielle Probleme abfangen und sicherstellen, dass der Code deine Anforderungen erfüllt.
  • Überprüfe deine Änderungen: Nachdem du Änderungen am Code vorgenommen hast, ist es wichtig zu überprüfen, ob die Anwendung weiterhin erwartungsgemäß funktioniert. Du kannst den von Copilot generierten Testplan verwenden, um Komponenten- und Integrationstests für die Anwendung zu erstellen.

Weiterführende Themen