# Explicando código herdado

Copilot Chat pode ajudar a explicar código desconhecido.

Um dos maiores desafios com o código herdado é ajudar desenvolvedores que não estão familiarizados com as linguagens ou estruturas a entendê-lo. Com Copilot Chat, você pode explicar a tela de fundo que você tem e pedir uma explicação.

## Cenário de exemplo

Considere o código COBOL a seguir. Se você for um desenvolvedor Python (por exemplo), talvez não esteja familiarizado com o COBOL, portanto, pode pedir Copilot Chat para explicar o código para você.

```text id=cobol-insert-record
IDENTIFICATION DIVISION.
PROGRAM-ID. INSERT-RECORD.

ENVIRONMENT DIVISION.

DATA DIVISION.
WORKING-STORAGE SECTION.
01  WS-STATUS-FLAGS.
    05 WS-DB-STATUS     PIC X(2).
       88 WS-SUCCESS    VALUE "00".
    05 WS-SQLCODE       PIC S9(9) COMP.
    05 WS-ERROR-MSG     PIC X(50).

LINKAGE SECTION.
01  LS-PARAMETERS.
    05 LS-PERSON-RECORD.
       10 PERSON-ID     PIC 9(6).
       10 PERSON-NAME   PIC X(50).
       10 PERSON-AGE    PIC 9(3).
    05 LS-RESULT        PIC X.
       88 SUCCESS       VALUE 'T'.
       88 FAILED        VALUE 'F'.

PROCEDURE DIVISION USING LS-PARAMETERS.
    PERFORM INSERT-AND-VALIDATE
    GOBACK
    .

INSERT-AND-VALIDATE.
    EXEC SQL
        INSERT INTO persons (id, name, age)
        VALUES (:PERSON-ID, :PERSON-NAME, :PERSON-AGE)
    END-EXEC

    IF SQLCODE = 0
        EXEC SQL COMMIT END-EXEC
        SET SUCCESS TO TRUE
    ELSE
        EXEC SQL ROLLBACK END-EXEC
        SET FAILED TO TRUE
        STRING "DB Error: " SQLCODE
            DELIMITED BY SIZE
            INTO WS-ERROR-MSG
        DISPLAY WS-ERROR-MSG
    END-IF
    .
```

## Prompt de exemplo

Você pode pedir uma explicação do código COBOL do ponto de vista de um desenvolvedor de Python.

```copilot copy prompt ref=cobol-insert-record
I'm a Python developer. Help me better understand this code. Please provide analogies.
```

## Resposta de exemplo

> \[!NOTE] A resposta a seguir é um exemplo. Respostas do Copilot Chat são não determinísticas, portanto, você pode obter uma resposta diferente da mostrada aqui.

Copilot fornece uma visão geral de alto nível do código, antes de percorrer as várias operações e explicá-las de uma maneira que Python desenvolvedores possam entender. Ele usa analogias para tornar a explicação mais acessível. A resposta pode começar com o seguinte:

```text
Let me explain this COBOL code using Python analogies:

High-Level Overview
This is similar to a Python function that inserts a person's record into a database with error handling.
```

```python
# In Python, the COBOL divisions would be like:

# IDENTIFICATION DIVISION = module/file name
# PROGRAM-ID = function name
def insert_record():
    pass

# DATA DIVISION would be like declaring these variables:
class WorkingStorage:
    db_status = ""  # WS-DB-STATUS
    sqlcode = 0     # WS-SQLCODE
    error_msg = ""  # WS-ERROR-MSG

# LINKAGE SECTION is like function parameters
class PersonRecord:
    def __init__(self, person_id: int, person_name: str, person_age: int):
        self.person_id = person_id    # PERSON-ID
        self.person_name = person_name # PERSON-NAME
        self.person_age = person_age   # PERSON-AGE
        self.success = False          # LS-RESULT
```

## Leitura adicional

* [Engenharia de prompts para o GitHub Copilot Chat](/pt/copilot/concepts/prompting/prompt-engineering)
* [Práticas recomendadas para usar GitHub Copilot](/pt/copilot/get-started/best-practices)