🔥🧠 COBOL no z/OS — COMO O PROGRAMA “EXISTE” NA MEMÓRIA (DO SUBMIT AO FREEMAIN) 🧠🔥

 

Bellacosa Mainframe explica uso de storage de um programa Cobol Batch do sub até o Freemain

🔥🧠 COBOL no z/OS — COMO O PROGRAMA “EXISTE” NA MEMÓRIA (DO SUBMIT AO FREEMAIN) 🧠🔥

Uma visão completa — arquitetura + runtime + storage + troubleshooting — exatamente como um Dev Mainframe precisa entender 😎

Baseado na arquitetura de memória virtual do z/OS (VSM/RSM/ASM, áreas common/private, DAT, etc.) .

---

🚀 VISÃO GERAL — A JORNADA DO PROGRAMA COBOL

👉 Um programa COBOL no mainframe não é carregado “na RAM” diretamente como em PCs.

Ele passa por:

JCL → JES → Initiator → Address Space → Loader → LE → Execução → Término → Liberação

Programa Cobol uso de storage 

---

🧭 PASSO 1 — SUBMIT DO JCL

Quando você faz:

//STEP1 EXEC PGM=MEUPROG

O que acontece:

1️⃣ JES2/JES3 recebe o job
2️⃣ JCL é interpretado
3️⃣ Recursos são reservados
4️⃣ Job entra na fila

👉 Nenhuma memória do programa ainda foi alocada.

---

🏗️ PASSO 2 — CRIAÇÃO DO ADDRESS SPACE

Quando o job inicia:

👉 O z/OS cria um Address Space dedicado

Esse espaço virtual contém:

• Áreas privadas do job

• Áreas comuns compartilhadas

• Estruturas do sistema

---

🧠 Estrutura simplificada

COMMON STORAGE (global)
-----------------------
PRIVATE STORAGE (do job)

---

📏 PASSO 3 — POSIÇÃO NA MEMÓRIA (LINE / BAR)

🔻 Below the Line (24-bit)

0 → 16 MB
👉 Legacy (raramente usado por COBOL moderno)

---

🔸 Above the Line (31-bit)

16 MB → 2 GB
👉 Onde vive a maioria dos programas COBOL batch

---

🔺 Above the Bar (64-bit)

2 GB
👉 Dados grandes, LE heaps modernos, Java, DB2 buffers etc.

---

🧠 Onde um COBOL típico roda?

👉 Código geralmente em 31-bit
👉 Dados podem estar 31-bit ou 64-bit

---

🧩 PASSO 4 — QUEM CARREGA O PROGRAMA?

🏆 Loader do z/OS (Program Fetch)

Fluxo:

1️⃣ Initiator chama o programa
2️⃣ Loader procura módulo em:

• STEPLIB

• JOBLIB

• LNKLST

• LPA (se residente)

3️⃣ Módulo é carregado na memória virtual

---

📦 Onde o código fica?

Normalmente:

👉 Private storage do address space
👉 Ou LPA se compartilhado (read-only)

---

🧠 PASSO 5 — LINGUAGE ENVIRONMENT (LE)

Programas COBOL modernos executam sob LE.

O LE cria:

• Stack

• Heap

• Control blocks

• Runtime services

• Condition handlers

---

🧱 Heaps do LE

Podem ficar:

• Below the bar

• Above the bar (HEAP64)

• Mixed

---

⚙️ PASSO 6 — EXECUÇÃO

Durante a execução o programa usa:

🔹 Código (reentrante)

Read-only, pode ser compartilhado

🔹 WORKING-STORAGE

Dados globais do programa

🔹 LOCAL-STORAGE

Dados por chamada

🔹 FILE BUFFERS

Buffers de I/O

🔹 LE heaps

Alocações dinâmicas

---

🧠 Quem gerencia a memória?

🔷 VSM — Virtual Storage Manager

👉 Alocação virtual (GETMAIN/STORAGE)

🔶 RSM — Real Storage Manager

👉 Mapeamento para memória física

🔷 ASM — Auxiliary Storage Manager

👉 Paging se necessário

---

📊 VISÃO INTERNA SIMPLIFICADA

Address Space do Job
│
├─ User Region
│   ├─ Código COBOL
│   ├─ WORKING-STORAGE
│   ├─ LE Heap/Stack
│   └─ Buffers
│
├─ LSQA
│   └─ Control blocks locais
│
└─ COMMON (CSA/SQA/LPA)
    └─ Componentes globais

---

🔄 PASSO 7 — CHAMADAS ENTRE PROGRAMAS

Quando um COBOL faz:

CALL 'OUTROPGM'

Pode ocorrer:

🔹 Static call

Módulo já carregado

🔹 Dynamic call

Loader traz novo módulo

👉 Pode alocar mais storage.

---

🧵 PASSO 8 — PAGING (SE NECESSÁRIO)

Se memória física faltar:

👉 Páginas podem ir para auxiliary storage

Transparente para o programa.

---

🏁 PASSO 9 — TÉRMINO DO PROGRAMA

Quando termina:

1️⃣ LE executa rotinas de cleanup
2️⃣ Arquivos são fechados
3️⃣ Storage privado é liberado
4️⃣ Control blocks são removidos

---

🧹 PASSO 10 — LIBERAÇÃO DO ADDRESS SPACE

👉 O sistema destrói o espaço virtual do job.

Tudo que não é comum desaparece.

---

📊 WORKFLOW COMPLETO

SUBMIT
  ↓
JES Queue
  ↓
Initiator seleciona job
  ↓
Criação do Address Space
  ↓
Loader carrega programa
  ↓
LE inicializa runtime
  ↓
Execução COBOL
  ↓
I/O e alocações dinâmicas
  ↓
Finalização
  ↓
Liberação de storage
  ↓
Address Space destruído


Como funciona um Cobol Batch no Mainframe

---

💣 TROUBLESHOOTING — VISÃO DO DEV COBOL

🔥 S878 — falta de storage

Causas típicas:

• Loop de alocação

• Heaps grandes

• REGION pequeno

• Vazamento via LE

---

🔥 0C4 — proteção

• Ponteiro inválido

• Overlay

• Uso após FREEMAIN

• Dados corrompidos

---

🔥 S40D — region pequena

• Muitos buffers

• Tabelas grandes

• Recursão

• LE heap insuficiente

---

🧠 DICAS DE OURO PARA DEV MAINFRAME

✔ Código reentrante economiza memória

Pode ser compartilhado entre jobs.

---

✔ Usar LOCAL-STORAGE reduz interferência

Cada invocação tem sua cópia.

---

✔ Dados gigantes → considerar ABOVE THE BAR

Via LE e opções de compilação.

---

✔ Evitar loops de alocação dinâmica

---

🏆 RESUMO FINAL — QUEM FAZ O QUÊ?

Componente	Função
JES	Gerencia job
Initiator	Executa
Loader	Carrega programa
LE	Runtime COBOL
VSM	Memória virtual
RSM	Memória real
ASM	Paging
z/OS	Orquestra tudo

---

🎯 CONCLUSÃO

👉 Um programa COBOL não “fica na memória” —
ele vive dentro de um ecossistema sofisticado de virtualização.

Entender isso permite:

💎 Diagnosticar ABENDs difíceis
💎 Otimizar performance
💎 Dimensionar REGION corretamente
💎 Conversar de igual para igual com SysProg
💎 Evoluir para arquiteto de plataforma

https://www.linkedin.com/pulse/cobol-zos-como-o-programa-existe-na-mem%25C3%25B3ria-do-submit-bellacosa-xliaf

 

Bellacosa Mainframe e o comando CALL e subprogramas em COBOL

Chamando Subprogramas em COBOL – Tipos de comandos CALL

Um dos recursos mais importantes do COBOL é a capacidade de dividir uma aplicação em vários módulos menores chamados:

Subprogramas

Isso permite reutilização de código, manutenção mais simples e melhor organização das aplicações Mainframe.

---

O que é um Subprograma?

É um programa COBOL que é chamado por outro programa.

---

Estrutura

Programa Principal
        ↓
     CALL
        ↓
   Subprograma
        ↓
     GOBACK
        ↓
Programa Principal

---

Exemplo Simples

Programa Principal:

CALL 'CALCULA'.

---

Subprograma:

IDENTIFICATION DIVISION.
PROGRAM-ID. CALCULA.

PROCEDURE DIVISION.

DISPLAY 'ENTREI NO SUBPROGRAMA'.

GOBACK.

---

Resultado:

ENTREI NO SUBPROGRAMA

---

Tipos de CALL

Existem vários tipos de chamada.

---

1. CALL Estático

O nome do programa é conhecido durante a compilação.

CALL 'CALCULA'

---

Características:

✅ Mais rápido

✅ Verificação na Linkedição

✅ Muito usado em Batch

---

Fluxo:

MAIN
 ↓
CALL 'CALCULA'
 ↓
CALCULA

---

2. CALL Dinâmico

O nome do programa está em uma variável.

01 WS-PGM PIC X(8).

MOVE 'CALCULA' TO WS-PGM.

CALL WS-PGM.

---

Características:

✅ Flexibilidade

✅ Escolha em tempo de execução

✅ Muito usado em frameworks

---

Fluxo:

WS-PGM
   ↓
CALCULA
VALIDA
CONSULTA

---

Exemplo

IF TIPO = 'A'

   MOVE 'CALCA' TO WS-PGM

ELSE

   MOVE 'CALCB' TO WS-PGM

END-IF

CALL WS-PGM

---

3. Nested Program Call

Programa interno chamando outro.

IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.

PROCEDURE DIVISION.

CALL 'SUB1'.

---

PROGRAM-ID. SUB1.

CALL 'SUB2'.

---

Fluxo:

MAIN
 ↓
SUB1
 ↓
SUB2

---

4. CALL Recursivo

Um programa chama ele próprio.

Necessário:

RECURSIVE PROGRAM

---

Exemplo:

IDENTIFICATION DIVISION.
PROGRAM-ID. FATORIAL
RECURSIVE.

---

Fluxo:

FATORIAL
    ↓
FATORIAL
    ↓
FATORIAL

---

5. CALL para Módulos LE

Chamada de rotinas do Language Environment.

Exemplo:

CALL 'CEE3ABD'

---

Usado para:

• ABEND controlado

• Datas

• Hora

• Serviços LE

---

6. CALL para Rotinas Assembler

Muito comum em Mainframe.

CALL 'ROTASM01'

---

Fluxo:

COBOL
 ↓
ASSEMBLER
 ↓
COBOL

---

7. CALL para CICS

Em CICS normalmente usamos:

EXEC CICS LINK
     PROGRAM('PROG2')
END-EXEC.

---

Ou

EXEC CICS XCTL
     PROGRAM('PROG2')
END-EXEC.

---

LINK x XCTL

LINK

Retorna ao chamador.

PROG1
 ↓
LINK
 ↓
PROG2
 ↓
Retorna

---

XCTL

Não retorna.

PROG1
 ↓
XCTL
 ↓
PROG2

---

Passagem de Parâmetros

O mais comum.

---

Programa Principal

CALL 'CALCULA'
USING WS-VALOR.

---

Subprograma

LINKAGE SECTION.

01 LK-VALOR PIC 9(5).

PROCEDURE DIVISION USING LK-VALOR.

---

Fluxo

MAIN
 ↓
USING
 ↓
LINKAGE

---

Múltiplos Parâmetros

Programa Principal:

CALL 'CALCULA'

USING

   WS-NOME
   WS-SALDO
   WS-DATA.

---

Subprograma:

PROCEDURE DIVISION USING

   LK-NOME
   LK-SALDO
   LK-DATA.

---

BY REFERENCE

Padrão do COBOL.

Passa endereço.

CALL 'PROG1'

USING BY REFERENCE WS-NOME.

---

Pode alterar o valor original.

---

BY CONTENT

Passa cópia.

CALL 'PROG1'

USING BY CONTENT WS-NOME.

---

Não altera a variável original.

---

BY VALUE

Passa valor diretamente.

Muito usado em integração com C.

CALL 'PROG1'

USING BY VALUE WS-CODIGO.

---

Exemplo

MOVE 100 TO WS-VALOR

CALL 'TESTE'

USING BY CONTENT WS-VALOR

---

Subprograma altera:

MOVE 500 TO LK-VALOR

---

Resultado:

WS-VALOR = 100

---

CANCEL

Remove programa da memória.

CANCEL 'CALCULA'

---

Muito usado após CALL dinâmico.

---

Fluxo

CALL
 ↓
Executa
 ↓
CANCEL
 ↓
Memória liberada

---

CALL e Load Modules

O programa chamado precisa estar:

STEPLIB
JOBLIB
LINKLIST
LPA

---

Erros Comuns

S806

Programa não encontrado.

S806

---

U4038

Erro interno.

---

S0C4

Parâmetro incorreto.

---

Boas Práticas

✅ Usar GOBACK nos subprogramas

✅ Validar parâmetros recebidos

✅ Documentar USING

✅ Evitar excesso de níveis CALL

✅ Utilizar COPYBOOK para parâmetros

---

Exemplo Corporativo

MAIN
 │
 ├── VALIDA
 │
 ├── CONSULTA-DB2
 │
 ├── CALCULA-JUROS
 │
 ├── GERA-ARQUIVO
 │
 └── LOG-ERRO

Cada módulo é um subprograma especializado.

---

Resumo Rápido

Tipo	Característica
CALL Estático	Nome fixo
CALL Dinâmico	Nome variável
Nested	Programa dentro de programa
Recursivo	Chama a si próprio
LINK CICS	Retorna
XCTL CICS	Não retorna
BY REFERENCE	Passa endereço
BY CONTENT	Passa cópia
BY VALUE	Passa valor
CANCEL	Remove da memória

---

Conclusão

O comando CALL é o mecanismo que permite a modularização das aplicações COBOL. Através dele, programas podem compartilhar regras de negócio, reutilizar código e organizar grandes sistemas corporativos em componentes menores. Dominar CALL estático, dinâmico, parâmetros USING, BY REFERENCE, BY CONTENT, BY VALUE, LINK, XCTL e CANCEL é essencial para qualquer programador COBOL que deseje atuar em ambientes Mainframe modernos.

 

Bellacosa Mainframe e o comando Goback em Cobol

O que é o comando GOBACK em COBOL?

O comando GOBACK é utilizado para encerrar a execução de um programa ou retornar o controle para o programa chamador.

Ele é considerado uma das instruções mais importantes do COBOL moderno e, em muitos ambientes, substitui o uso de STOP RUN.

---

Definição Simples

O GOBACK significa:

Volte para quem me chamou

ou, se não existir programa chamador:

Termine a execução

---

Sintaxe

GOBACK.

---

Exemplo Simples

IDENTIFICATION DIVISION.
PROGRAM-ID. TESTE.

PROCEDURE DIVISION.

DISPLAY 'OLA MUNDO'.

GOBACK.

Resultado:

OLA MUNDO

Programa finalizado.

---

Como Funciona?

O comportamento depende da forma como o programa foi executado.

---

Programa Principal

Executado por JCL:

//STEP1 EXEC PGM=PROG1

Fluxo:

JCL
 ↓
PROG1
 ↓
GOBACK
 ↓
Fim da execução

---

Subprograma

Programa principal:

CALL 'SUBROT1'.

Subprograma:

DISPLAY 'ENTREI'.

GOBACK.

Fluxo:

MAIN
 ↓
CALL SUBROT1
 ↓
GOBACK
 ↓
MAIN continua

---

Exemplo Completo

Programa Principal:

IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.

PROCEDURE DIVISION.

DISPLAY 'ANTES'.

CALL 'SUB1'.

DISPLAY 'DEPOIS'.

GOBACK.

---

Subprograma:

IDENTIFICATION DIVISION.
PROGRAM-ID. SUB1.

PROCEDURE DIVISION.

DISPLAY 'SUBPROGRAMA'.

GOBACK.

---

Saída:

ANTES
SUBPROGRAMA
DEPOIS

---

GOBACK x STOP RUN

Essa é a comparação mais importante.

GOBACK	STOP RUN
Retorna ao chamador	Finaliza tudo
Seguro para subprogramas	Perigoso em subprogramas
Recomendado atualmente	Uso tradicional
Funciona em programas chamados	Encerra toda aplicação

---

Exemplo Visual

GOBACK

MAIN
 ↓
SUB1
 ↓
GOBACK
 ↓
MAIN continua

---

STOP RUN

MAIN
 ↓
SUB1
 ↓
STOP RUN
 ↓
Tudo termina

---

Uso em Batch

Muito comum.

OPEN INPUT ARQCLI

PERFORM PROCESSA

CLOSE ARQCLI

GOBACK.

---

Uso em Subprogramas

É a principal recomendação.

CALL 'CALCULO'

CALL 'VALIDA'

GOBACK.

---

Uso em Programas DB2

Também é amplamente utilizado.

IF SQLCODE NOT = 0

   DISPLAY SQLCODE

   GOBACK

END-IF.

---

GOBACK e Return Code

Pode ser combinado com:

MOVE 8 TO RETURN-CODE.

GOBACK.

Resultado:

CC=0008

---

GOBACK e Language Environment

No ambiente LE (Language Environment), o GOBACK é tratado de forma inteligente.

Se existir chamador:

Retorna ao chamador

Se não existir:

Finaliza execução

---

EXIT PROGRAM x GOBACK

Outro comando relacionado.

---

EXIT PROGRAM

EXIT PROGRAM.

Retorna apenas ao chamador.

---

GOBACK

GOBACK.

Retorna ao chamador ou termina a aplicação.

---

Comparação

Comando	Função
EXIT PROGRAM	Retorna ao chamador
GOBACK	Retorna ou termina
STOP RUN	Finaliza tudo

---

Exemplo com EXIT PROGRAM

IDENTIFICATION DIVISION.
PROGRAM-ID. SUB1.

PROCEDURE DIVISION.

DISPLAY 'SUB'.

EXIT PROGRAM.

---

Boas Práticas

✅ Utilize GOBACK em subprogramas

✅ Utilize GOBACK em programas novos

✅ Defina RETURN-CODE quando necessário

✅ Evite STOP RUN em módulos chamados

✅ Padronize o encerramento dos programas

---

Erros Comuns

STOP RUN em subprograma

CALL 'SUB1'

SUB1:

STOP RUN.

Resultado:

Aplicação inteira termina

---

Não retornar código

GOBACK.

Sem:

MOVE 8 TO RETURN-CODE

Pode dificultar automação.

---

Curiosidades

1. O GOBACK foi introduzido para simplificar o retorno de programas chamados

2. É amplamente recomendado pela IBM para novos desenvolvimentos

3. Funciona perfeitamente com Language Environment (LE)

4. É um dos comandos mais encontrados em aplicações COBOL modernas

5. Em muitos padrões corporativos, STOP RUN é proibido em subprogramas

---

Resumo Rápido

Conceito	Função
GOBACK	Retorna ao chamador ou termina
STOP RUN	Finaliza toda aplicação
EXIT PROGRAM	Retorna ao chamador
CALL	Chama subprograma
RETURN-CODE	Código retorno
LE	Language Environment
Batch	Uso comum
Subprograma	Comando recomendado

---

Conclusão

O GOBACK é o comando de encerramento mais flexível do COBOL moderno. Ele permite que um subprograma retorne ao programa chamador sem interromper toda a aplicação e, quando executado em um programa principal, encerra normalmente a execução. Por isso, é considerado a melhor prática para o desenvolvimento COBOL em ambientes z/OS, CICS, IMS e DB2.

 

Bellacosa Mainframe e o paradigma de programação procedural

O que é Paradigma de Programação Procedural?

Quando estudamos:

• COBOL;

• C;

• PL/I;

• Assembler;

• programação no mainframe;

um dos conceitos mais importantes é o:

paradigma procedural.

Ele dominou o desenvolvimento corporativo durante décadas e ainda hoje é extremamente utilizado no ambiente:

z/OS IBM Z.

---

Primeiro: o que é paradigma?

Paradigma é:

um modelo ou estilo de programação.

Ele define:

• como o programa será organizado;

• como a lógica será construída;

• como o fluxo será executado.

---

O que significa “procedural”?

Procedural vem de:

procedimentos.

Ou seja:
o programa é dividido em:

• rotinas;

• módulos;

• procedimentos;

• etapas organizadas.

---

Definição simples

Programação procedural é:

um paradigma baseado em procedimentos que executam tarefas passo a passo.

O programa normalmente:

• segue sequência;

• manipula variáveis;

• altera estados;

• executa rotinas.

---

Analogia simples

Imagine uma empresa.

Cada setor possui um procedimento:

• financeiro;

• RH;

• cobrança;

• estoque.

Cada procedimento executa:

uma tarefa específica.

O paradigma procedural funciona assim.

---

Relação com paradigma imperativo

O procedural é:

um tipo de programação imperativa.

Porque ele também diz:

como fazer as tarefas.

---

O que muda?

No procedural:

o código é organizado em procedimentos.

---

Exemplo simples

INICIO
   VALIDAR CLIENTE
   CALCULAR SALDO
   GERAR RELATORIO
FIM

Cada etapa é um:

procedimento.

---

Como isso aparece no COBOL?

Muito fortemente.

---

Exemplo COBOL procedural

PROCEDURE DIVISION.

MAIN-PROCESS.
    PERFORM VALIDAR-CLIENTE
    PERFORM CALCULAR-SALDO
    PERFORM GERAR-RELATORIO
    STOP RUN.

---

O que é PERFORM?

Comando COBOL usado para:

executar procedimentos.

---

Exemplo dos procedimentos

VALIDAR-CLIENTE.
    DISPLAY 'VALIDANDO'.

CALCULAR-SALDO.
    DISPLAY 'CALCULANDO'.

GERAR-RELATORIO.
    DISPLAY 'GERANDO'.

---

Isso é programação procedural

O sistema:

• chama procedimentos;

• executa etapas;

• controla fluxo.

---

Estrutura clássica procedural

ENTRADA
 ↓
VALIDAÇÃO
 ↓
PROCESSAMENTO
 ↓
ATUALIZAÇÃO
 ↓
RELATÓRIO
 ↓
FIM

---

Características do paradigma procedural

---

Código dividido em procedimentos

---

Fluxo sequencial

---

Uso intenso de variáveis

---

Alteração de estado

---

Reutilização de rotinas

---

Forte controle do fluxo

---

Como procedural aparece no mainframe?

Praticamente em tudo:

• COBOL batch;

• utilitários;

• JCL procedural;

• automações;

• sistemas financeiros.

---

O COBOL é procedural?

Tradicionalmente:

sim.

Especialmente:

• COBOL batch clássico;

• sistemas legados.

---

Por que procedural fez tanto sucesso no mainframe?

Porque funciona muito bem para:

• processamento batch;

• regras de negócio;

• arquivos sequenciais;

• grandes volumes de dados.

---

Exemplo real batch procedural

LER ARQUIVO
 ↓
VALIDAR REGISTRO
 ↓
CALCULAR VALOR
 ↓
ATUALIZAR DB2
 ↓
GERAR RELATÓRIO

---

O que é modularização?

Dividir programa em partes menores.

---

Exemplo

ROTINA-LEITURA
ROTINA-CALCULO
ROTINA-IMPRESSAO

---

Isso facilita:

• manutenção;

• testes;

• reutilização;

• organização.

---

O que é subprograma?

Programa chamado por outro programa.

Muito comum em COBOL.

---

Exemplo

CALL 'CALCSAL'

---

O que é parâmetro?

Informação enviada para procedimento/subprograma.

---

Exemplo

CALL 'CALCSAL' USING SALARIO

---

Procedural vs Orientado a Objetos

---

Procedural

Organiza:

procedimentos.

---

Orientado a Objetos

Organiza:

objetos/classes.

---

Procedural vs Declarativo

---

Procedural

Diz:

como executar.

---

Declarativo

Diz:

o que deseja obter.

---

Exemplo SQL

SELECT NOME
FROM CLIENTES

Mais declarativo.

---

Exemplo procedural equivalente

LER CLIENTE
SE NOME EXISTE
   MOSTRAR

---

Vantagens do paradigma procedural

---

Fácil entender fluxo

---

Excelente para batch

---

Ótimo desempenho

---

Muito eficiente em mainframe

---

Bom para regras de negócio

---

Muito estável

---

Desvantagens

---

Sistemas grandes ficam complexos

---

Muito acoplamento

---

Código repetitivo

---

Difícil manutenção em programas enormes

---

GO TO excessivo gera spaghetti code

---

O que é spaghetti code?

Código confuso cheio de desvios.

Muito famoso em sistemas antigos COBOL.

---

Curiosidades incríveis

1. Grande parte do sistema bancário mundial ainda usa lógica procedural

---

2. Muitos programas COBOL possuem décadas de evolução procedural

---

3. Procedural dominou a computação corporativa por muitos anos

---

4. O COBOL procedural continua extremamente relevante

---

Erros comuns de iniciantes

---

1. Criar procedimentos gigantes

---

2. Não modularizar

---

3. Usar GO TO demais

---

4. Misturar lógica demais em uma única rotina

---

Dicas importantes

Divida programas em pequenas rotinas

---

Use PERFORM corretamente

---

Nomeie procedimentos claramente

---

Organize fluxo do programa

---

Como isso aparece no dia a dia?

Praticamente em:

• COBOL;

• batch;

• DB2 procedural;

• processamento financeiro;

• faturamento;

• folha salarial.

---

Exemplo simplificado completo

MAIN
 ↓
LER CLIENTES
 ↓
VALIDAR DADOS
 ↓
CALCULAR JUROS
 ↓
ATUALIZAR DB2
 ↓
GERAR RELATÓRIO
 ↓
FIM

---

Resumo rápido

Conceito	Significado
Procedural	Baseado em procedimentos
PERFORM	Executa rotina COBOL
CALL	Chama subprograma
Modularização	Dividir programa
Fluxo	Ordem execução
COBOL	Principal exemplo procedural

---

Conclusão

O paradigma procedural é um dos modelos mais importantes da programação tradicional no ambiente mainframe IBM Z.

Ele organiza programas em procedimentos e rotinas reutilizáveis, permitindo criar sistemas batch eficientes, estáveis e capazes de processar enormes volumes de dados no z/OS.