🟦 COBOL 4 vs COBOL 5 no IBM Mainframe

O compilador conservador vs o compilador sem piedade

“COBOL 4 aceita seu passado.
COBOL 5 exige que você pague por ele.”
— Bellacosa, 02:17 da manhã, após um RC=12

---

🧬 Visão geral rápida

Aspecto	COBOL 4.x	COBOL 5.x
Filosofia	Evolução segura	Modernização radical
Base técnica	Mista (transição)	LE-only
Compatibilidade	Altíssima	Quebra compatibilidade
Performance	Boa	Excelente
Tolerância a “jeitinhos”	Alta	Zero
Indicado para	Sistemas legados	Sistemas modernos
Dor na migração	Baixa	Alta (mas honesta)

---

🕰️ História resumida (contexto importa)

COBOL 4.x

• Ponte entre o COBOL clássico e o moderno

• Mantém compatibilidade

• Ideal para recompilar sem reescrever

• Estratégia: ganhar performance sem trauma

COBOL 5.x

• Reescrito do zero

• Totalmente 64 bits

• Totalmente Language Environment (LE)

• Estratégia: chega de passado mal resolvido

🥚 Easter-egg:

COBOL 5 não “evolui” o COBOL 4.
Ele substitui.

---

⚙️ Arquitetura interna (onde mora a diferença real)

COBOL 4

• Compilador moderno, mas ainda tolerante

• Suporta comportamentos históricos

• Código objeto previsível

• Ideal para ambientes mistos

COBOL 5

• Backend totalmente novo

• Otimização agressiva

• Explora z13+

• Assume que você escreve COBOL correto

💣 Tradução Bellacosa:

Se o código está errado, o COBOL 5 não vai fingir que está certo.

---

💥 Compatibilidade (a grande ferida)

COBOL 4

✔ Aceita código antigo
✔ Perdoa ambiguidade
✔ Mantém comportamento histórico

COBOL 5

❌ Quebra código legado
❌ Muda comportamento implícito
❌ Não aceita mais “funcionava assim”

Exemplos clássicos que quebram:

• Dados mal alinhados

• DEPEND ON inconsistente

• MOVE implícito perigoso

• Uso errado de REDEFINES

🥚 Easter-egg de guerra:

O mesmo código que roda há 30 anos pode ABENDAR no COBOL 5 sem mudar uma linha.

---

🚀 Performance

Situação	COBOL 4	COBOL 5
Batch pesado	Boa	🔥 Excelente
Loops intensivos	Ok	🚀 Muito melhor
CPU usage	Menor que 3	Menor que 4
Escala	Limitada	Pensada para escala

👉 Se o objetivo é economizar MIPS, o COBOL 5 vence.

---

🧪 Exemplo conceitual

Código que “passa” no COBOL 4:

01 WS-NUM PIC 9(4).
01 WS-CHAR REDEFINES WS-NUM PIC X(4).

MOVE 'ABCD' TO WS-CHAR.
ADD 1 TO WS-NUM.

✔ COBOL 4: pode até rodar
❌ COBOL 5: comportamento indefinido → risco real

💡 COBOL 5 exige que você seja explícito.

---

🛠️ Parâmetros de compilação

COBOL 4

• Mais permissivo

• Ideal para legado

• Bom para transição

COBOL 5

• ARCH(n) obrigatório

• OPTIMIZE agressivo

• Sem modo “compatível”

🥚 Easter-egg técnico:

COBOL 5 não tem “modo COBOL 4”.
A IBM foi clara: corrija o código.

---

🧭 Quando usar cada um?

✔ Use COBOL 4 se:

• Sistema é crítico

• Código antigo e estável

• Pouco budget para refatoração

• Objetivo é ganho rápido e seguro

✔ Use COBOL 5 se:

• Projeto novo

• Modernização planejada

• Uso de APIs, serviços, CI/CD

• Quer performance máxima

• Quer futuro

---

🧘 Estratégia Bellacosa recomendada

🥋 Caminho do Jedi Mainframe:

1️⃣ Recompile tudo em COBOL 4
2️⃣ Ative parâmetros rigorosos
3️⃣ Corrija warnings e comportamentos estranhos
4️⃣ Crie suíte de testes
5️⃣ Só então migre para COBOL 5

“Pular do 3 para o 5 é possível.
Mas você vai sangrar.”

---

🧠 Verdade final (sem marketing)

• COBOL 4 é o porto seguro

• COBOL 5 é o futuro inevitável

• A dor do COBOL 5 vale a pena

• Mas só para quem está preparado

---

🟦 Conclusão Bellacosa™

COBOL 4 mantém o legado vivo.
COBOL 5 prepara o legado para sobreviver.

Não existe “melhor versão”.
Existe a versão certa para o momento certo.

 

🧾 COBOL 4.00 no IBM Mainframe

Guia para Iniciantes: Código Limpo, Seguro e Econômico

“COBOL 4 não perdoa código ruim.
Ele executa… e te cobra por isso.”

---

🕰️ Um Pouco de Contexto (Por que COBOL 4 importa)

O Enterprise COBOL 4.00 marcou uma virada de chave no mainframe:

• Introduziu um novo compilador

• Passou a gerar código mais próximo da arquitetura moderna

• Começou a penalizar código antigo e relaxado

👉 Muitos programas antigos funcionam, mas:

• Gastam mais CPU

• Usam mais memória

• Sofrem em batch pesado

---

🧱 Estrutura Básica de um Programa COBOL (Visão Rápida)

IDENTIFICATION DIVISION.
ENVIRONMENT DIVISION.
DATA DIVISION.
PROCEDURE DIVISION.

Para iniciantes:

• DATA DIVISION mal feita = desastre

• PROCEDURE DIVISION confusa = CPU jogada fora

---

⚠️ Grandes Perigos para Iniciantes no COBOL 4

☠️ 1. Código que “funciona” mas custa caro

Exemplo perigoso:

PERFORM UNTIL EOF
   READ ARQ
   MOVE CAMPO-A TO CAMPO-B
END-PERFORM

❌ MOVE desnecessário dentro do loop
❌ Loop sem controle de volume

✅ Melhor prática:

READ ARQ AT END
   SET EOF TO TRUE
END-READ

E só mover o que for necessário.

---

☠️ 2. PERFORM Excessivo (Modular demais mata CPU)

Iniciantes adoram:

PERFORM TRATA-REGISTRO

dentro de loop com milhões de registros.

⚠️ Cada PERFORM é custo.

✔️ Dica:

• Inline lógica crítica

• Use PERFORM para controle, não para micro-rotinas

---

☠️ 3. Variáveis mal definidas (memória desperdiçada)

Erro clássico:

01 WS-VALOR     PIC X(1000).

Quando só precisa de 10 bytes 😱

✔️ Regra de ouro:

• PIC do tamanho exato

• Evite campos genéricos “pra garantir”

📉 Menos memória = menos cache miss = menos CPU.

---

☠️ 4. Repetir cálculos desnecessários

Erro comum:

COMPUTE WS-TOTAL = WS-QTD * WS-VALOR

feito várias vezes no loop com os mesmos valores.

✔️ Dica:

• Calcule uma vez

• Armazene

• Reutilize

---

🧼 Como Escrever Código Mais Limpo no COBOL 4

✅ Use nomes claros

WS-VALOR-TOTAL
WS-FIM-ARQUIVO

❌ Evite:

WS-A
WS-X1

---

✅ Evite lógica escondida

Código perigoso:

IF A = B
   MOVE X TO Y
ELSE
   IF C = D
      MOVE Z TO Y
   END-IF
END-IF

✔️ Melhor:

• Clareza > esperteza

• COBOL foi feito para ser legível

---

🚀 Performance no COBOL 4: Dicas Práticas

⚙️ 1. Tire código de dentro de loops

Cada instrução dentro de loop custa N vezes.

---

⚙️ 2. Use corretamente os níveis da DATA DIVISION

• Campos agrupados bem definidos

• Evite REDEFINES desnecessário

REDEFINES mal usado = bugs silenciosos.

---

⚙️ 3. Cuidado com STRING e UNSTRING

Eles são poderosos… e caros.

✔️ Use apenas quando necessário
✔️ Evite em loops grandes

---

⚙️ 4. Arquivos: leia com cuidado

• READ sequencial é barato

• READ aleatório é caro

• Releitura custa CPU e I/O

---

🧠 Pontos de Atenção que Geram Bugs em Produção

Armadilha	Problema
Campo não inicializado	Resultado imprevisível
EOF mal tratado	Loop infinito
IF aninhado demais	Erro lógico
REDEFINES confuso	Dados corrompidos
Índices fora do limite	ABEND

---

🧙 Curiosidades & Easter Eggs COBOL 4

• COBOL 4 foi o primeiro passo real rumo ao COBOL 5

• Programas antigos compilam, mas podem custar o dobro de CPU

• O compilador já “entende” melhor a arquitetura do zSeries

---

🧭 Primeiros Passos Recomendados para Padawans

1. Aprenda estrutura limpa

2. Evite copiar código velho sem entender

3. Sempre pense:

   “Isso vai rodar quantas vezes?”

4. Meça CPU quando possível

5. Menos código = menos custo

---

🏁 Conclusão

COBOL 4.00 é:

• Estável

• Poderoso

• Implacável com código mal escrito

“No mainframe, não existe código inocente.
Só código caro ou econômico.”

 

📉 COBOL 3.xx vs COBOL 4.00 Clássico maduro vs clássico turbinado

 

📉 COBOL 3.xx vs COBOL 4.00

Clássico maduro vs clássico turbinado

---

🕰️ Linha do tempo rápida

Versão	Ano	Contexto
COBOL 3.xx	~2001	Consolidação do LE
COBOL 4.00	~2009	Performance, Unicode, modernização

📌 COBOL 4 não foi ruptura — foi evolução com faca nos dentes.

---

🧠 Filosofia de cada versão

🧓 COBOL 3.xx

“Se está rodando, não mexe.”

• Estável

• Conservador

• Performance previsível

• Muito usado em batch crítico

🧑‍🚀 COBOL 4.00

“Roda igual, mas gasta menos MIPS.”

• Otimizações agressivas

• Melhor uso de hardware

• Preparação para mundo moderno

• Base para COBOL 5

---

⚙️ Runtime e arquitetura

Item	COBOL 3.xx	COBOL 4.00
Language Environment	Sim	Sim (mais maduro)
31 bits	Dominante	Ainda forte
64 bits	Não	Preparado
Unicode	Limitado	Nativo (USAGE DISPLAY-1)
XML	Básico	Muito melhor

🥚 Easter egg:

COBOL 4 já pensa em 64 bits mesmo rodando em 31.

---

🚀 Performance e MIPS

📉 Onde o COBOL 4 ganha

• Loop intensivo

• Cálculos COMP/COMP-3

• Manipulação de strings

• I/O sequencial

📊 Média de ganho real:

5% a 25% menos MIPS
(depende do código e dos PARMs)

⚠ Onde não muda quase nada

• Código ruim continua ruim

• Lógica desorganizada

• SORT mal usado

---

🧪 Parâmetros de compilação

COBOL 3.xx (clássico seguro)

DATA(31)
OPTIMIZE(2)
TRUNC(BIN)
ARITH(EXTEND)
MAP
LIST

COBOL 4.00 (modo adulto)

DATA(31)
OPTIMIZE(2)
TRUNC(BIN)
ARCH(8)
ARITH(EXTEND)
MAP
LIST

🥚 Fofoquinha:

ARCH(8) é onde começa a economia de MIPS sem reescrever código.

---

🧟 Abends e problemas comuns

Tipo	COBOL 3.xx	COBOL 4.00
S0C7	Muito comum	Menos frequente
S0C4	Clássico	Igual
S878	Configuração LE	Configuração LE
Performance ruim	Código	Código 😈

💬 Spoiler:

Migrar para COBOL 4 não corrige lógica ruim.

---

🧠 Diagnóstico e debug

Item	COBOL 3	COBOL 4
LIST/MAP	Sim	Sim
Debug LE	Básico	Melhor
Ferramentas	Limitadas	Mais integração
Rastreamento	Manual	Mais amigável

---

🖥️ Hardware indicado

Versão	Mainframes típicos
COBOL 3	z900, z990
COBOL 4	z9, z10, z196

📌 COBOL 4 começa a explorar melhor o silício.

---

🧬 Curiosidades Bellacosa™

• COBOL 4 foi ignorado por anos por medo de mudança

• Quem migrou cedo economizou MIPS silenciosamente

• Muitos shops pularam direto do 3 para o 5 (e sofreram)

🥚 Easter egg clássico:

COBOL 4 é o “melhor custo-benefício” da história do COBOL.

---

🧑‍🎓 Padawan: quando migrar?

Migre para COBOL 4 se:

✔ Está em 3.xx
✔ Quer reduzir MIPS
✔ Não quer risco alto
✔ Quer preparar o terreno

Não espere milagres se:

❌ Código é caótico
❌ JCL é desleixado
❌ LE é default

---

🧠 Resumo executivo (para levar ao chefe)

Critério	Vencedor
Estabilidade	Empate
Performance	COBOL 4
Modernização	COBOL 4
Risco	Empate
Base para futuro	COBOL 4

---

🏁 Conclusão Bellacosa™

“COBOL 3 é confiável.
COBOL 4 é confiável e mais barato.”

 

 

📊 Tabela de Erros Comuns no COBOL 4.x

(O museu do código que sobreviveu por sorte)

“COBOL 4 não perdoa erros…
ele apenas adia a cobrança.”
— Bellacosa

---

🟥 ERROS DE DADOS E NUMÉRICOS (os mais perigosos)

Erro comum	Por que acontece no COBOL 4	Sintoma clássico	Risco real
MOVE alfanumérico → numérico sem validação	COBOL 4 é permissivo	Resultado “estranho”	Dados corrompidos
Campo COMP com lixo	Falta de NUMCHECK	Valor inválido silencioso	ABEND S0C7
Campo não inicializado	WORKING-STORAGE “herdada”	Resultado imprevisível	Erro intermitente
Truncamento implícito	Falta de TRUNC	Perda de centavos	Erro contábil
Uso errado de PIC	PIC não condiz com o dado	MOVE aceita	Cálculo errado

🥚 Easter-egg:

“Nunca deu problema” é o sintoma mais comum.

---

🟧 ERROS DE CONTROLE DE FLUXO

Erro comum	Por que passa no COBOL 4	Sintoma	Consequência
PERFORM sem END-PERFORM	Sintaxe antiga aceita	Loop infinito	CPU 100%
GO TO cruzando lógica	Permitido	Fluxo ilegível	Bug fantasma
PERFORM THRU mal definido	Dependência de labels	Execução indevida	Lógica quebrada
IF sem END-IF	Ambiguidade	Decisão errada	Regra violada

Bellacosa rule:

Se tem GO TO, alguém já chorou por isso.

---

🟨 ERROS DE ARQUIVOS (Batch Killers)

Erro comum	Causa típica	Sintoma	Impacto
FILE STATUS ignorado	“Sempre abre”	JOB termina normal	Dados errados
READ sem AT END	Pressuposto errado	Loop infinito	Batch travado
WRITE sem verificação	Falta de validação	Arquivo inconsistente	Reprocessamento
OPEN errado	Copybook confuso	Abend S013/S213	Job abortado

🥚 Easter-egg de produção:

O JOB “rodou verde”, mas gerou arquivo vazio.

---

🟦 ERROS DE MEMÓRIA E STORAGE

Erro comum	Por que ocorre	Sintoma	Resultado
REDEFINES mal alinhado	Estrutura errada	Dado incoerente	Corrupção
OCCURS sem limites	Falta de índice	Leitura fora	S0C4
INDEX mal usado	Mistura de tipos	Loop errado	Dados perdidos
DEPENDING ON inválido	Valor sujo	OCCURS errado	Overrun

---

🟪 ERROS DE PERFORMANCES (invisíveis)

Erro comum	Por que é ignorado	Sintoma	Custo
MOVE desnecessário	Código antigo	CPU alta	MIPS caro
Loop mal definido	Falta de controle	Batch lento	SLA estourado
Uso excessivo de DISPLAY	Debug legado	Lentidão	I/O inútil
Falta de OPTIMIZE	Padrão conservador	Código ineficiente	Mais CPU

Bellacosa truth:

Performance ruim é bug financeiro.

---

🟫 ERROS DE COMPILAÇÃO (clássicos)

Erro comum	COBOL 4 permite	Resultado	Perigo
Compilar sem SSRANGE	Default antigo	Overflow invisível	Crash futuro
Compilar sem NUMCHECK	Tolerância excessiva	Dado inválido	S0C7
Ignorar warnings	“Não quebra”	Bug latente	Produção
TRUNC errado	Default histórico	Truncamento	Erro monetário

---

☠️ ABENDS mais ligados a COBOL 4

ABEND	Causa típica
S0C7	Campo numérico inválido
S0C4	Endereço inválido
S013	Arquivo mal definido
S222	Loop infinito
S0CB	Violação de storage

---

🎓 Resumo para Padawans

✔ COBOL 4 funciona por tolerância
✔ Erros ficam escondidos
✔ Bugs surgem anos depois
✔ Migração para COBOL 5 revela tudo

---

🧠 Frase final Bellacosa™

“COBOL 4 não valida.
Ele confia.
E confiança sem validação é bug.”

 

 

🟦 IBM Mainframe & COBOL 4.00

O elo entre o COBOL clássico e o mundo moderno

“COBOL 4 não é ruptura.
É a IBM dizendo: ‘vamos modernizar… sem quebrar nada’.”
— Bellacosa, depois de recompilar 3 milhões de linhas

---

🧬 Contexto histórico: onde o COBOL 4.00 se encaixa

O Enterprise COBOL for z/OS 4.0 faz parte da família COBOL 4.x, que surgiu no início da década de 2010, num momento crítico:

• Mainframes mais poderosos (z10, z196)

• Arquitetura 64 bits amadurecendo

• Pressão por performance, modernização e integração

• COBOL 3 ainda dominante… mas envelhecendo

👉 O COBOL 4 não veio para “mudar a linguagem”.
Veio para mudar o compilador.

---

📅 Data de lançamento (contexto realista)

• Enterprise COBOL for z/OS 4.0: final de 2007 e primordios da primeira década de 2010.

• Consolidação real aconteceu nas versões 4.1 / 4.2

• Foi o degrau obrigatório antes do COBOL 5.x

💡 Tradução Bellacosa:

Se você saiu do COBOL 3 direto para o 5, o 4 foi o “meio do caminho” que você pulou… e pagou depois.

---

🖥️ Equipamentos mainframe indicados

COBOL 4 foi feito para explorar hardware moderno da IBM:

Mainframes ideais:

• IBM z10

• IBM z196

• IBM zEC12

• Totalmente compatível com zEnterprise

Por quê?

Porque o COBOL 4:

• Gera código mais otimizado

• Explora melhor o pipeline do processador

• Se beneficia de novas instruções de CPU

🥚 Easter-egg:

Recompilar COBOL antigo em COBOL 4 sem mudar uma linha já dava ganho de performance.

---

🔄 O que muda em relação ao COBOL 3.x?

🧠 1️⃣ Compilador totalmente redesenhado

• Novo backend

• Melhor otimização de código

• Melhor uso de registradores

👉 O código fonte parece igual.
👉 O código objeto não é.

---

⚙️ 2️⃣ Melhor suporte a arquitetura moderna

• Preparação para 64 bits

• Melhor alinhamento de dados

• Base para o futuro COBOL 5 (LE-only)

---

📊 3️⃣ Performance real

• Redução de CPU em batch

• Melhor performance em loops

• Melhor otimização de PERFORM

🥚 Easter-egg:

Muitos shops recompilaram só para economizar MIPS.

---

🧨 4️⃣ Mais rigor (menos permissividade)

Alguns “pecados antigos” começaram a ser cobrados:

• Dados mal definidos

• Uso implícito perigoso

• Código que “sempre funcionou” 😅

👉 COBOL 4 começa a expor bugs escondidos há 20 anos.

---

🧪 Exemplo simples (nada muda… mas muda tudo)

IDENTIFICATION DIVISION.
PROGRAM-ID. EXEMPLO4.

DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TOTAL PIC 9(9) VALUE 0.

PROCEDURE DIVISION.
    PERFORM 10 TIMES
        ADD 1 TO WS-TOTAL
    END-PERFORM
    DISPLAY WS-TOTAL
    STOP RUN.

➡ Em COBOL 3: funciona
➡ Em COBOL 4: funciona mais rápido

💡 O ganho está no objeto gerado, não no código.

---

🛠️ Dicas técnicas Bellacosa Approved™

✔ Recompile, mesmo sem modernizar

• COBOL 4 já entrega valor só na recompilação

✔ Use parâmetros certos:

• OPTIMIZE

• ARCH

• SSRANGE (para pegar erro escondido)

✔ Teste batch crítico

• Principalmente cálculos

• Principalmente datas

• Principalmente arredondamentos

✔ Compare CPU antes/depois

• Você vai se surpreender

---

⚠️ Armadilhas clássicas

🚨 Código que dependia de comportamento indefinido
🚨 Campos mal alinhados
🚨 MOVE CORRESPONDING em estruturas duvidosas
🚨 Arredondamento implícito não documentado

🥚 Easter-egg cruel:

COBOL 4 não cria bug.
Ele revela.

---

🧠 Curiosidades de bastidor

• COBOL 4 foi o primeiro passo sério rumo ao LE-only

• Muitas empresas ficaram “presas” no 4 por anos

• Ele é visto como a versão mais estável da transição

• Serviu de base para o radical COBOL 5

---

🧘 Primeiros passos para o Padawan

Se você está começando agora:

1️⃣ Entenda COBOL clássico primeiro
2️⃣ Saiba compilar e linkar
3️⃣ Entenda parâmetros de compilação
4️⃣ Recompile código antigo e observe
5️⃣ Leia o listing — ele ensina mais que o código

“Quem lê o listing, domina o mainframe.”

---

🧠 Visão Bellacosa Final™

O COBOL 4.00 não é famoso.
Não é revolucionário.
Não é hype.

Mas ele é:

• Estável

• Inteligente

• O verdadeiro ponto de virada técnico do COBOL moderno

Se o COBOL fosse uma saga:

• COBOL 3 = trilogia clássica

• COBOL 4 = o episódio de transição

• COBOL 5 = o reboot corajoso

E lembre-se, Padawan:

“Modernizar não é reescrever.
É entender o que funciona… e deixar melhor.”