Modernizar o código herdado com o GitHub Copilot

O Copilot Chat ajuda a modernizar o código herdado, sugerindo refatorações e criando testes para detectar possíveis problemas.

Neste artigo

Note

As respostas mostradas neste artigo são exemplos. Respostas do Copilot Chat são não determinísticas, portanto, você pode obter respostas diferentes das mostradas aqui.

Código herdado é um código antigo, desatualizado ou que não tem mais suporte dos desenvolvedores originais. Pode ser difícil manter e estender porque talvez não siga práticas recomendadas modernas, como o uso de convenções de nomenclatura consistentes ou não tenha uma documentação clara escrita.

Modernizar o código herdado pode ajudar você a:

  • Aprimorar o desempenho e escalabilidade.
  • Facilitar a manutenção e a extensão do código.
  • Reduziz o risco de introduzir bugs ao fazer alterações.
  • Tornar o código mais fácil de testar.

O Copilot pode ajudar você a modernizar o código herdado:

  • Fornecendo sugestões para refatorar o código e seguir práticas recomendadas modernas.
  • Gerando documentação para ajudar você a entender como o código funciona.
  • Gerar testes para ajudar você a verificar se as alterações não introduziram bugs.

Cenário de exemplo

Neste exemplo, examinaremos um sistema de gerenciamento de contas escrito em COBOL e o modernizaremos para Node.js. Você pode encontrar o código COBOL no repositório modernize-legacy-cobol-app.

O sistema de gerenciamento de contas consiste em três arquivos principais:

  • main.cob: o programa principal que lê a entrada do usuário e chama o subprograma apropriado.
  • operations.cob: um subprograma que executa operações nos dados da conta, como crédito, débito e exibir o saldo.
  • data.cob: um subprograma que gerencia o armazenamento do saldo da conta.

Etapa 1: Obter uma cópia local do repositório

Antes de compilar e executar o programa, você precisa ter o código localmente. Se você ainda não clonou o repositório, navegue até o diretório em que deseja armazenar o projeto e execute o seguinte comando:

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

Etapa 2: Compilar e executar o programa

Você pode instalar um compilador de COBOL em seu ambiente de desenvolvimento preferencial (por exemplo, o compilador GnuCOBOL de código aberto) ou usar o Copilot Chat no GitHub Codespaces.

Se você usar o MacOS, poderá instalar o GnuCOBOL usando o Homebrew:

Shell
brew install gnu-cobol

Se você usar o Codespaces ou um sistema Ubuntu Linux, poderá instalar o GnuCOBOL usando apt:

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

Para compilar o código, vincule os arquivos e crie um executável, execute o seguinte comando na raiz do repositório:

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

Para executar o programa, use o seguinte comando:

Shell
./accountsystem

Etapa 3: Explicar os arquivos e o código

A primeira etapa para modernizar o código é entender como ele funciona. Você pode solicitar ao Copilot Chat para explicar o código em cada arquivo.

Abra o repositório em seu IDE e, no painel do Copilot Chat, insira o prompt a seguir.

Exemplo de prompt 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.

Exemplo de resposta 1

Este é um trecho da resposta ao prompt acima:

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

Etapa 4: Mapear o fluxo de dados entre os arquivos

A próxima etapa é entender como os arquivos são vinculados entre si. Você pode usar @workspace para criar um diagrama de fluxo de dados para o aplicativo.

Note

O participante do chat @workspace no VS Code e Visual Studio fornece ao Copilot contexto sobre todo o código em seu workspace. Você pode usar o @workspace quando quer que o Copilot considere a estrutura do projeto e como diferentes partes do código interagem. Se você está usando um IDE do JetBrains, use @project em vez de @workspace.

Exemplo de prompt 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.

O Copilot gera o markup Mermaid para um diagrama de sequência completo que mostra como o aplicativo funciona. Você pode copiar e colar esse markup em um aplicativo Mermaid para gerar o diagrama.

Etapa 5: Gerar um plano de teste

Crie um plano de teste para garantir que o aplicativo funcione conforme o esperado depois que você fizer alterações. Você pode usar @workspace para gerar um plano de teste que abranja todos os arquivos no projeto.

Exemplo 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 gera um plano de teste no formato Markdown que você pode usar para validar o aplicativo. Para usar esse plano posteriormente no processo, crie um arquivo chamado TESTPLAN.md e copie o plano sugerido nele. Isso permitirá que você faça referência ao plano de teste ao gerar casos de teste nas próximas etapas.

Etapa 6: Converter os arquivos do COBOL em Node.js

A próxima etapa é converter os arquivos COBOL em Node.js. É importante ter em mente as seguintes práticas de prompt:

  • Fornecer contexto
  • Dar instruções claras
  • Ser específico sobre o resultado que você deseja alcançar

Comece criando um diretório temporário no projeto para salvar os arquivos JavaScript que você criará.

Shell
mkdir temp-JS-project-directory

Em seguida, converta iterativamente os arquivos COBOL em Node.js.

Exemplo de prompt 4

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

Exemplo de resposta 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.

Examine atentamente o código sugerido antes de usá-lo. Se estiver satisfeito com o código gerado, siga estas etapas para salvá-lo localmente e concluir a conversão:

  1. No diretório temporário criado anteriormente, crie um arquivo chamado main.js.
  2. Copie o código gerado do painel do Copilot Chat e cole-o em main.js.
  3. Salve o arquivo.
  4. Use prompts semelhantes para converter operations.cob e data.cob em Node.js.
  5. Crie arquivos JavaScript correspondentes operations.js e data.js, no mesmo diretório temporário.
  6. Copie e cole o código gerado em cada arquivo e salve-os.

Depois de converter todos os arquivos em Node.js, você precisará vinculá-los e configurar um projeto de Node.js funcional.

  1. Navegue até o diretório temporário em seu terminal.

  2. Execute o seguinte comando para criar um arquivo package.json:

    Shell
    npm init -y

  3. Se o aplicativo exigir pacotes externos, instale-os executando:

    Shell
    npm install

  4. Inicie o aplicativo executando:

    Shell
    npm start

Talvez o aplicativo Node.js ainda não replique totalmente a funcionalidade do programa COBOL original. Por exemplo, os saldos podem não ser atualizados corretamente ou os cálculos podem não corresponder à lógica do COBOL.

Para refinar o aplicativo, você precisará:

  • Identificar o comportamento incorreto executando o programa e comparando-o com a versão do COBOL.

  • Trabalhar iterativamente com o Copilot para ajustar a lógica até que o programa Node.js se comporte conforme o esperado.

  • Usar prompts direcionados para depurar e melhorar partes específicas do código, como:

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

Refatorar o código herdado nem sempre é um processo de uma etapa; o Copilot pode ajudar na depuração e no aprimoramento da funcionalidade à medida que você refina a nova implementação do Node.js.

Etapa 8: Gerar testes de unidade e integração

A próxima etapa é gerar testes de unidade e integração para garantir que o aplicativo funcione conforme o esperado. Você pode usar @workspace para gerar um plano de teste que abranja todos os arquivos no projeto.

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

Exemplo de resposta 5

O Copilot gera uma série de testes no Jest, uma estrutura de teste em JavaScript, com um guia completo passo a passo sobre como implementá-los e executá-los.

Este é um trecho da resposta ao prompt acima:

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

Etapa 9: Executar testes e refinar o código

Depois de gerar o plano de teste e escrever os testes, você precisará executá-los e corrigir os testes com falha. O teste é um processo iterativo, talvez seja necessário modificar o código para resolver problemas e executar novamente os testes até que tudo seja aprovado.

Se um teste falhar, use o Copilot para ajudar a depurar e refinar a implementação.

Exemplo de prompt 6

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

Mesmo que todos os testes sejam aprovados, o programa ainda poderá ter problemas. Testes automatizados nem sempre capturam funcionalidades ausentes ou erros lógicos, portanto, o teste manual é necessário para garantir que o aplicativo se comporte conforme o esperado.

Etapa 10: Mover o projeto JavaScript para um novo local

Depois que o aplicativo estiver funcionando conforme o esperado, mova o novo projeto JavaScript para fora do diretório do COBOL para mantê-lo separado.

  1. Navegue até o diretório pai do projeto COBOL.

  2. Mova o projeto JavaScript para um novo local:

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

  3. Navegue até o novo diretório do projeto e confirme se tudo é executado corretamente:

    Shell
    cd new-js-project
npm start

Agora, o aplicativo Node.js refatorado está em sua própria pasta de projeto, separada dos arquivos COBOL originais.

Conclusão

Neste exemplo, examinamos um sistema de gerenciamento de contas escrito em COBOL e o modernizamos em Node.js. Usamos o Copilot Chat para explicar o código, mapear o fluxo de dados, gerar um plano de teste e converter o código em Node.js. Seguindo estas etapas, você pode modernizar código herdado e facilitar a manutenção e a extensão. Aqui estão algumas dicas adicionais para modernizar o código herdado:

  • As práticas recomendadas de prompts são fundamentais: a qualidade dos prompts determina a qualidade das sugestões do Copilot. Forneça um contexto claro, divida tarefas complexas em etapas menores, forneça exemplos e forneça metas específicas ao Copilot para trabalhar. Isso torna o fluxo de trabalho mais suave e seus resultados mais precisos
  • Examine o código antes de usá-lo: entenda o código que o Copilot fornece antes de usá-lo em seu aplicativo. Isso ajudará você a detectar possíveis problemas e garantir que o código atenda aos seus requisitos.
  • Valide suas alterações: depois de fazer alterações no código, é importante validar se o aplicativo ainda funciona conforme o esperado. Você pode usar o plano de teste gerado pelo Copilot para criar testes de unidade e integração para o aplicativo.

Leitura adicional