☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta arquitetura de software. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta arquitetura de software. Mostrar todas as mensagens

domingo, 26 de julho de 2026

Lógica de Validação : Quando um Programador COBOL Descobre que o Campo Obrigatório Não Foi Criado para Irritar Usuários... Mas para Evitar que um Banco Inteiro Exploda às 23h59

 

Bellacosa Mainframe e a logica de validação

☕ Um Café no Bellacosa Mainframe

Lógica de Validação sem Mistérios para Programadores COBOL

Quando um Programador COBOL Descobre que o Campo Obrigatório Não Foi Criado para Irritar Usuários... Mas para Evitar que um Banco Inteiro Exploda às 23h59

"Meu nome é COBOL. Enterprise COBOL."

Imagine a cena clássica de um filme de James Bond.

Em algum lugar de Londres, M entrega uma missão.

— Bond, encontramos um programa escrito em RPG III em 1989. Um desenvolvedor júnior pretende remover algumas validações porque "atrapalham a experiência do usuário". Se ele conseguir... centenas de sistemas financeiros poderão produzir dados incorretos durante meses sem que ninguém perceba.

Bond responde calmamente.

— Então o problema não é o código.

— Exatamente. O problema é que ninguém sabe por que aquele código existe.

...

Bem-vindo ao mundo dos sistemas corporativos.

E curiosamente...

Essa história acontece praticamente todos os dias: validações aparentemente simples escondem regras de negócio extremamente sofisticadas.

Para um programador COBOL iniciante, isso representa uma das maiores mudanças de mentalidade da carreira.


O grande erro dos iniciantes

Todo iniciante pensa parecido.

Ele abre um programa COBOL.

Encontra:

IF CLIENTE = SPACES
    DISPLAY "CLIENTE OBRIGATORIO"
    GO TO TELA
END-IF

Primeira reação:

"Isso é simples."

Segunda reação:

"Posso melhorar."

Terceira reação:

"Nem precisa existir."

...

E é exatamente aí que começam os problemas.

Porque talvez esse IF esteja protegendo:

  • faturamento

  • integração

  • impostos

  • compliance

  • auditoria

  • relatórios

  • processamento batch

  • fechamento mensal

Ou seja...

o verdadeiro trabalho nunca foi impedir campo vazio.

O verdadeiro trabalho era proteger todo o restante do sistema.


O efeito James Bond

Nos filmes do 007 existe um detalhe interessante.

Quase nunca o vilão destrói Londres usando uma bomba gigante.

Ele altera uma pequena peça.

Troca um satélite.

Muda um código.

Rouba uma chave.

Troca uma senha.

Depois observa o caos acontecer sozinho.

Nos sistemas corporativos acontece exatamente igual.

Você altera uma validação aparentemente insignificante.

Nada acontece.

Durante dias.

Durante semanas.

Depois...

o fechamento financeiro falha.


O usuário vê uma mensagem.

O sistema vê um contrato.

O artigo explica algo extremamente importante.

Para o usuário existe apenas isto:

Campo obrigatório.

Fim.

Mas internamente aquela mensagem significa:

"Não permita que este registro siga adiante porque cinquenta processos dependem dele."

Essa diferença de perspectiva muda completamente a forma como analisamos software legado.


O iceberg das validações

A tela é apenas a ponta.

Debaixo dela existem dezenas de dependências.

Imagine:

Tela

↓

Programa COBOL

↓

VSAM

↓

DB2

↓

MQ

↓

Interface REST

↓

Batch Noturno

↓

Relatórios

↓

BI

↓

Auditoria

↓

Banco Central

O usuário enxerga:

Campo obrigatório.

O arquiteto enxerga:

Uma cadeia inteira de dependências.

Por que sistemas antigos fazem tantas validações?

Porque durante décadas não existiam:

  • APIs

  • Microservices

  • Gateway

  • Event Broker

  • Kafka

  • Camadas REST

Tudo acontecia dentro do programa.

Logo...

a validação morava exatamente onde os dados entravam.

Na tela.

Esse padrão tornou-se extremamente comum em RPG, COBOL, Natural e PL/I.


O verdadeiro inimigo chama-se "dados ruins"

Programadores novos costumam pensar:

"Erro de compilação é ruim."

Não.

Muito pior é dado errado.

Porque código errado normalmente explode imediatamente.

Dado errado...

pode sobreviver anos.


Imagine:

Cliente cadastrado sem CPF.

Hoje nada acontece.

Amanhã:

batch ignora.

Depois:

faturamento não encontra cliente.

Depois:

impostos errados.

Depois:

auditoria encontra inconsistência.

Depois:

advogados entram.

Tudo começou porque alguém retirou um IF.


O paradoxo da modernização

Outro ponto excelente discutido no artigo.

Modernizar NÃO significa preservar tudo.

Nem apagar tudo.

Modernizar significa entender primeiro.

Depois decidir.

A sequência correta é:

  1. Descobrir a regra.

  2. Entender a regra.

  3. Descobrir quem usa.

  4. Descobrir quem depende.

  5. Só então alterar.

Jamais o contrário.


Um dos maiores perigos: o efeito dominó

Imagine uma peça de dominó.

Você derruba apenas uma.

As outras caem sozinhas.

Validações funcionam exatamente assim.

Uma alteração pequena pode atingir:

  • relatórios

  • integração SAP

  • emissão fiscal

  • XML

  • APIs

  • Data Warehouse

  • Analytics

Nenhuma dessas equipes estava olhando aquela tela.

Mas todas dependiam dela.


James Bond e o Mainframe

Se James Bond trabalhasse num banco...

Q provavelmente lhe entregaria um gadget chamado:

Validator Scanner 9000

Funções:

✓ localizar IF esquecidos

✓ encontrar PERFORM misteriosos

✓ rastrear GO TO perigosos

✓ identificar programas batch impactados

Infelizmente...

na vida real esse gadget chama-se:

Conhecimento.

A IA entra em cena

O artigo mostra um uso extremamente inteligente da IA.

Não para substituir o desenvolvedor.

Mas para acelerar investigação.

Por exemplo.

A IA pode responder rapidamente:

  • Qual campo é validado?

  • Qual mensagem aparece?

  • Qual arquivo recebe update?

  • Qual status muda?

  • Quais programas são chamados?

  • Quais SQL executam?

  • Quais interfaces dependem?

Ela reduz dias de investigação para minutos em muitos casos.


Mas cuidado...

A IA enxerga código.

Ela não enxerga história.

Ela pode dizer:

"Campo obrigatório."

Mas não sabe que:

Em 1997 um cliente perdeu milhões porque esse campo ficou vazio.

Quem sabe isso?

O analista veterano.


O método Bellacosa de investigação

Sempre ensine seu cérebro a pensar nesta sequência:

Etapa 1

Onde está a validação?


Etapa 2

Quem chama?


Etapa 3

Quem grava?


Etapa 4

Quem lê?


Etapa 5

Quem depende?


Etapa 6

O que quebra?


Etapa 7

Ainda faz sentido?


Só depois:

Modificar.


A importância da documentação

Outro excelente ponto.

Quando finalmente descobrimos o motivo daquela validação...

não podemos guardar isso apenas na cabeça.

Transforme em:

  • Wiki

  • Confluence

  • Markdown

  • Obsidian

  • Teste

  • Caso de Uso

Conhecimento que permanece apenas em pessoas desaparece quando elas mudam de projeto ou se aposentam.


O prompt apresentado

O artigo também fornece um excelente modelo para IA.

Ele pede análise sobre:

  • campo

  • condição

  • mensagem

  • regra

  • arquivos

  • programas

  • SQL

  • interfaces

  • batch

  • riscos

  • QA

  • suporte

  • testes

Na prática é quase um checklist de engenharia reversa moderna.


Os cinco agentes secretos da modernização

Desenvolvedor

Descobre como funciona.


Analista

Descobre por quê.


QA

Prova que continua funcionando.


Suporte

Conta todas as tragédias já ocorridas.


Arquiteto

Decide onde essa regra deverá viver daqui para frente.

Cada um possui uma parte da missão.


Curiosidade histórica

Nos anos 1970 e 1980 era comum concentrar praticamente toda a inteligência do negócio dentro do programa COBOL ou RPG.

Não porque fosse "bonito".

Mas porque era o local natural onde os dados entravam.

Décadas depois, APIs, microsserviços e arquiteturas em camadas redistribuíram muitas dessas responsabilidades, mas inúmeras regras continuam preservadas no legado por razões históricas e operacionais.


Easter Egg 007

Existe um paralelo curioso.

Nos filmes do James Bond, M frequentemente diz:

"Confie em seus instintos."

No mainframe existe uma versão melhor:

"Nunca remova um IF antes de descobrir quem escreveu aquele IF."

Porque talvez quem escreveu já tenha resolvido um desastre que nunca foi documentado.


Licença para Refatorar

Bond tinha licença para matar.

O programador moderno deveria possuir outra licença:

Licença para perguntar.

Antes de remover qualquer validação:

  • Quem pediu?

  • Quando surgiu?

  • Qual incidente originou?

  • Existe documento?

  • Existe chamado?

  • Existe histórico?

  • Existe auditoria?

Se ninguém souber responder...

o IF merece respeito.


Conclusão — O verdadeiro agente secreto é a regra de negócio

Todo iniciante imagina que programas COBOL são grandes coleções de IFs antigos, mensagens em maiúsculas e GO TO espalhados pelo código.

Com o tempo, porém, descobre uma verdade muito mais fascinante: cada validação é um pequeno agente secreto infiltrado no sistema. Ela trabalha silenciosamente, impedindo que dados inconsistentes atravessem fronteiras invisíveis e provoquem efeitos em cadeia em faturamento, relatórios, integrações, processamento batch e auditorias.

Modernizar não é eliminar essas sentinelas indiscriminadamente. É investigar sua missão, entender o contexto histórico, confirmar se ainda fazem sentido e decidir o melhor lugar para que continuem protegendo o negócio. A inteligência artificial pode acelerar essa investigação, resumir código e sugerir perguntas relevantes, mas ela ainda depende da experiência humana para interpretar o significado de cada regra e validar seu impacto no mundo real.

No universo Bellacosa Mainframe, a maior lição é simples: um IF aparentemente banal pode valer mais do que milhares de linhas de código moderno, porque ele representa conhecimento acumulado ao longo de décadas. Assim como James Bond salva o mundo antes que a maioria perceba que havia perigo, uma boa validação impede desastres que nunca aparecerão nos relatórios de incidentes justamente porque jamais chegaram a acontecer.

Da próxima vez que encontrar um antigo IF CAMPO = SPACES, não pense apenas em removê-lo. Pense que talvez ele seja o 007 do seu sistema: discreto, elegante, quase invisível... e responsável por impedir que uma catástrofe silenciosa aconteça todos os dias.

quinta-feira, 9 de julho de 2026

O Guia Definitivo para um Programador COBOL Padawan Entender por que a Nova Revolução da Inteligência Artificial Parece Muito Mais um Sistema Bancário do IBM Z do que um Chatbot

 

Bellacosa Mainframe ai agents sem misterios

☕ Um Café no Bellacosa Mainframe

AI Agents sem Mistérios

O Guia Definitivo para um Programador COBOL Padawan Entender por que a Nova Revolução da Inteligência Artificial Parece Muito Mais um Sistema Bancário do IBM Z do que um Chatbot

"No Mainframe aprendemos uma lição que o mercado de IA está redescobrindo apenas agora: inteligência nunca esteve em uma única aplicação. Ela sempre surgiu da integração disciplinada entre diversos componentes especializados."


Durante os últimos anos, muito se falou sobre GPT, Llama, Claude, Gemini, DeepSeek e inúmeros outros modelos de linguagem. Para quem observa de fora, parece que a evolução da Inteligência Artificial consiste simplesmente em criar modelos cada vez maiores.

Mas existe uma mudança silenciosa acontecendo.

A próxima revolução não é sobre modelos.

É sobre arquitetura.

E essa talvez seja a melhor notícia que um programador COBOL pode receber.

Enquanto boa parte da indústria acredita que a IA nasceu em 2022, profissionais de Mainframe podem olhar para praticamente qualquer diagrama moderno de AI Agents e dizer:

"Curioso... já vi algo muito parecido funcionando em bancos há décadas."

Obviamente, as tecnologias são diferentes.

Os problemas também.

Mas os princípios da engenharia permanecem surpreendentemente familiares.


A maior ilusão sobre IA

Quando alguém pensa em Inteligência Artificial normalmente imagina algo assim:

Usuário
     │
     ▼
   ChatGPT
     │
     ▼
 Resposta

Isso funciona.

Mas isso não é um agente.

É apenas uma conversa.

Um verdadeiro AI Agent parece muito mais com isto:

Objetivo

↓

Planejamento

↓

Memória

↓

Recuperação de Conhecimento

↓

Raciocínio

↓

Ferramentas

↓

Execução

↓

Avaliação

↓

Nova decisão

Perceba um detalhe extremamente importante.

O modelo de linguagem aparece apenas como um componente.

Ele deixou de ser o protagonista.

Passou a ser apenas uma peça do sistema.

Isso muda completamente a forma de pensar.


Curiosidade nº 1

Os primeiros grandes sistemas corporativos já funcionavam como "agentes", embora ninguém utilizasse esse nome.

Pense em um processamento bancário.

O cliente solicita uma transferência.

O programa COBOL não resolve tudo sozinho.

Ele:

  • consulta o Db2;

  • verifica limites;

  • conversa com CICS;

  • envia mensagens MQ;

  • registra auditoria;

  • grava logs;

  • dispara novos processos.

No final, dezenas de componentes participaram daquela simples operação.

A IA Agêntica está redescobrindo exatamente esse conceito.


O verdadeiro cérebro do agente

Existe uma frase interessante na Engenharia de Software:

"Software complexo não é construído escrevendo funções enormes.

É construído coordenando pequenas funções muito bem organizadas."

Com agentes acontece exatamente isso.

O LLM não controla tudo.

Quem controla é a arquitetura.

Imagine um maestro.

O maestro não toca violino.

Não toca piano.

Não toca trompete.

Mas coordena todos.

O Agent Runtime faz exatamente isso.


Easter Egg nº 1

Se você já escreveu um PERFORM UNTIL em COBOL, já entende melhor um AI Agent do que imagina.

Veja:

PERFORM UNTIL PROCESSO-CONCLUIDO

    LER-DADOS

    VALIDAR

    PROCESSAR

    EXECUTAR

    VERIFICAR-RESULTADO

END-PERFORM

Agora compare com um agente moderno:

Observe

↓

Think

↓

Evaluate

↓

Execute

↓

Observe novamente

São praticamente o mesmo padrão arquitetural.

A única diferença é que agora algumas decisões são tomadas por modelos estatísticos.


Memória não significa banco de dados

Outro erro muito comum.

Quando falamos em memória, muita gente pensa imediatamente em um banco de dados.

Não é isso.

Os agentes modernos possuem diversos tipos de memória.

Isso lembra bastante a organização interna de um programa COBOL.


Working Memory

Equivale às variáveis da Working-Storage.

01 WS-NOME.

01 WS-SALDO.

01 WS-CPF.

Essas informações existem apenas durante o processamento.

Quando o programa termina...

Desaparecem.


Episodic Memory

Guarda experiências anteriores.

Imagine um operador que lembra:

"Ontem essa API ficou indisponível."

Ou:

"O cliente sempre prefere receber PDF."

Essa memória melhora decisões futuras.


Procedural Memory

Talvez seja a mais interessante.

Ela não guarda conhecimento.

Guarda procedimentos.

Exatamente como um programador COBOL.

Você talvez não memorize todos os comandos do SORT.

Mas sabe quando utilizá-los.

Esse conhecimento é procedural.


Easter Egg nº 2

Uma PROCEDURE DIVISION inteira pode ser vista como uma forma primitiva de memória procedural.

Isso mostra que COBOL sempre foi muito mais sofisticado do que muitos imaginam.


O MCP explicado para quem conhece Mainframe

Muita gente acredita que MCP é uma IA.

Não é.

Também não é um banco.

Nem um framework.

MCP é um protocolo.

Pense nele como:

  • JDBC

  • ODBC

  • MQ

  • TCP/IP

  • HTTP

  • REST

Seu trabalho é padronizar comunicação.

Nada mais.

Nada menos.

Sem ele, cada ferramenta precisaria conversar de uma forma diferente.

Com ele:

LLM

↓

MCP

↓

GitHub

↓

SAP

↓

Jira

↓

Mainframe

↓

Banco

↓

Filesystem

Tudo segue uma mesma linguagem.


Curiosidade nº 2

O sucesso do TCP/IP não aconteceu porque era o protocolo mais rápido.

Aconteceu porque todo mundo resolveu falar a mesma língua.

MCP caminha exatamente nessa direção.


Ferramentas são os novos EXEC CICS

Existe uma comparação extremamente divertida.

No COBOL temos:

EXEC SQL

CALL

EXEC CICS

LINK

XCTL

MQPUT

MQGET

Na IA temos:

Tool()

API()

Database()

Search()

Filesystem()

Email()

Calendar()

O conceito é idêntico.

A lógica continua sendo apenas um orquestrador.


O ciclo infinito da inteligência

A figura mostra algo fantástico.

O agente nunca para de observar.

Ele vive em um ciclo permanente.

Observar

↓

Interpretar

↓

Planejar

↓

Executar

↓

Observar novamente

Isso lembra outro velho conhecido.

O monitor CICS.

Recebe transação

↓

Processa

↓

Envia resposta

↓

Espera próxima transação

É um ciclo eterno.


Easter Egg nº 3

O famoso laço de controle OODA (Observe, Orient, Decide, Act), criado pelo estrategista militar John Boyd, é frequentemente comparado ao ciclo de agentes modernos.

Curiosamente, muitos sistemas transacionais corporativos já implementavam ciclos semelhantes muito antes da popularização da IA.


O agente não pensa sozinho

Esta talvez seja a maior descoberta da IA moderna.

Pensar custa caro.

Consultar custa barato.

Por isso surgiu o RAG.

Ao invés de decorar tudo...

O agente consulta.

Isso lembra muito um programa COBOL.

Um sistema bancário não possui todos os clientes em memória.

Ele consulta o Db2.

Sempre que necessário.


Curiosidade nº 3

Quanto maior o agente, menos ele depende da memória interna.

Parece contraditório.

Mas faz sentido.

Grandes sistemas preferem consultar fontes oficiais do que confiar apenas na memória.

Os bancos fazem isso há décadas.


Planejamento lembra um velho conhecido...

JCL.

Antes do programa executar:

STEP001

↓

STEP002

↓

STEP003

↓

STEP004

Tudo já foi planejado.

Os agentes fazem exatamente isso.

Antes de responder.

Eles decompõem o problema.


Easter Egg nº 4

O conceito moderno chamado Task Decomposition é praticamente o equivalente filosófico ao particionamento de um grande JOB em múltiplos STEP's reutilizáveis.


O maior erro de um iniciante

Quem está começando em IA normalmente pergunta:

"Qual é o melhor modelo?"

Essa pergunta equivale a perguntar:

"Qual é o melhor compilador COBOL?"

Não é a pergunta correta.

A pergunta correta seria:

Como toda a arquitetura foi construída?


O verdadeiro diferencial

Os agentes realmente impressionantes possuem:

✔ memória

✔ ferramentas

✔ planejamento

✔ logs

✔ recuperação

✔ auditoria

✔ monitoramento

✔ controle

✔ validação

✔ observabilidade

Parece familiar?

Claro.

É exatamente assim que sistemas críticos são construídos.


Curiosidade nº 4

Os bancos nunca confiaram apenas no programa COBOL.

Sempre confiaram na arquitetura inteira.

A IA está aprendendo essa mesma lição.


O papel da avaliação

Uma diferença enorme entre um chatbot simples e um agente corporativo está na etapa de avaliação.

Depois de executar uma ação, o agente pergunta:

  • A API respondeu?

  • O banco confirmou?

  • O arquivo foi criado?

  • O usuário recebeu?

  • O resultado faz sentido?

No Mainframe fazemos isso desde sempre.

IF SQLCODE = ZERO

IF FILE-STATUS = "00"

IF RETURN-CODE = ZERO

A validação é parte da lógica.

Nunca um detalhe.


Easter Egg nº 5

Um dos padrões mais modernos em agentes é chamado Reflection.

Depois de responder...

O agente analisa sua própria resposta.

Curiosamente, isso lembra bastante um programador experiente revisando o próprio código antes do code review.


Observabilidade: a grande esquecida

Um agente sem logs é como um programa batch sem SYSOUT.

Quando algo dá errado...

Ninguém sabe por quê.

Por isso arquiteturas modernas utilizam:

  • Telemetria

  • Métricas

  • Traces

  • Logs

  • Auditoria

  • Eventos

No IBM Z temos equivalentes extremamente maduros:

  • SMF

  • RMF

  • SYSLOG

  • SDSF

  • JESMSGLG

  • JESYSMSG

Mais uma vez, o Mainframe já praticava esses conceitos há muito tempo.


A verdadeira autonomia

Existe uma frase que merece ser lembrada.

Um agente não é inteligente porque executa muitas ações.

Ele é inteligente porque sabe quando não executar.

Essa é a diferença entre automação e autonomia responsável.

É por isso que governança, políticas de acesso, autenticação, autorização e auditoria são componentes indispensáveis em ambientes corporativos.


O maior Easter Egg de todos

Talvez o aspecto mais curioso dessa nova geração de IA seja perceber que muitos dos conceitos considerados "inovadores" já existiam, com outros nomes, no universo Mainframe.

IA AgênticaIBM Z / Mainframe
Working MemoryWorking-Storage
Procedural MemoryProcedure Division
Tool CallingEXEC CICS / EXEC SQL / CALL
PlannerJCL / Scheduler
RetrievalDb2 / VSAM / IMS
ReflectionValidação de RC, SQLCODE, FILE STATUS
OrchestratorCICS, JES2, Control-M, OPC
ObservabilitySMF, RMF, SDSF, SYSLOG
Agent RuntimeMonitor transacional + lógica de negócio
GovernanceRACF, SAF, Auditoria

É claro que não são tecnologias equivalentes em implementação, mas os princípios arquiteturais apresentam paralelos notáveis.


Conselho final para um Padawan COBOL

Se você acredita que a Inteligência Artificial substituirá completamente os profissionais de Mainframe, talvez esteja olhando apenas para a superfície.

Os melhores arquitetos de agentes precisarão entender muito mais do que prompts. Eles precisarão dominar orquestração, governança, integração, confiabilidade, observabilidade, recuperação de falhas e regras de negócio — exatamente os pilares sobre os quais os grandes sistemas IBM Z foram construídos ao longo de décadas.

Enquanto muitos enxergam um AI Agent como um "chatbot com ferramentas", um programador COBOL experiente reconhece algo muito mais profundo: um ecossistema de componentes cooperando de forma disciplinada para atingir um objetivo comum.

No fim das contas, a grande lição é quase poética. A indústria da IA está descobrindo que inteligência não nasce de um modelo gigantesco, mas da engenharia cuidadosa que conecta memória, planejamento, raciocínio, execução, auditoria e controle. E para quem passou anos desenvolvendo aplicações críticas em bancos, seguradoras e governos, isso soa surpreendentemente familiar.

Como diria um velho Mestre Jedi do IBM Z:

"Os modelos impressionam nas demonstrações. Mas são as arquiteturas bem projetadas que sobrevivem por décadas."


segunda-feira, 6 de julho de 2026

IA Generativa Muito Além do ChatGPT - Parte II

Bellacosa Mainfram apresenta ia generativa

☕ Um Café no Bellacosa Mainframe

IA Generativa Muito Além do ChatGPT

O Que Todo Programador COBOL Padawan Precisa Saber Sobre RAG, MCP, watsonx, IBM Z, CICS, Db2, APIs e Como a Inteligência Artificial Está Transformando os Sistemas Mais Críticos do Mundo (Parte 2)

"A tecnologia muda. Os princípios permanecem. Empresas não sobrevivem porque adotam modismos, mas porque conseguem evoluir preservando aquilo que já funciona."


Quando a IA Encontra o Mundo Real

Na primeira parte deste artigo vimos que a Inteligência Artificial não veio substituir o Mainframe.

Na verdade, ela depende dele.

Agora vamos responder uma pergunta ainda mais importante:

Como isso acontece dentro de uma grande instituição financeira?

Esqueça por um momento os chatbots públicos.

Imagine um banco que processa:

  • 150 milhões de transações por dia;

  • milhares de PIX por segundo;

  • milhões de cartões;

  • investimentos;

  • empréstimos;

  • seguros;

  • câmbio;

  • previdência.

Todo esse universo continua sendo coordenado por aplicações executando no IBM Z.

A IA entra como uma camada de inteligência.

Não como substituição.


Caso 1 — Atendimento Inteligente

Imagine que um cliente escreve:

"Meu cartão foi recusado. O que aconteceu?"

Sem IA:

  • abertura de chamado;

  • consulta manual;

  • operador verifica sistemas;

  • resposta alguns minutos depois.

Com IA integrada ao Mainframe:

Cliente

↓

Assistente IA

↓

RAG

↓

API REST

↓

CICS

↓

Programa COBOL

↓

Db2

↓

Regras de Negócio

↓

Resposta Personalizada

Resposta:

"Sua compra foi recusada porque ultrapassou o limite diário de segurança definido para transações internacionais. Você pode aumentar esse limite diretamente pelo aplicativo."

Nenhuma informação foi inventada.

Tudo veio do sistema corporativo.


Caso 2 — Explicando Programas COBOL

Imagine um programa com 25.000 linhas.

O desenvolvedor recém-chegado pergunta:

"Como esse programa calcula juros?"

Sem IA:

Dias analisando código.

Com IA:

Programa COBOL

↓

Parser

↓

Embedding

↓

Base Vetorial

↓

LLM

↓

Resumo Técnico

Resposta:

O cálculo de juros ocorre nos parágrafos CALC-JUROS e APLICA-TAXA. A taxa depende do tipo de contrato, perfil do cliente e índice econômico armazenado na tabela FIN_RATE.

O profissional continua responsável pela validação.

Mas economiza horas.


Caso 3 — Documentação Automática

Uma das maiores dores em sistemas legados é documentação desatualizada.

Hoje podemos construir pipelines que façam:

Git

↓

Programa COBOL

↓

Parser

↓

IA

↓

Markdown

↓

Wiki

↓

Confluence

Resultado:

Toda alteração gera documentação automaticamente.


Caso 4 — Geração de Casos de Teste

Imagine este trecho COBOL:

IF SALDO < VALOR-SAQUE
    MOVE "N" TO AUTORIZADO
ELSE
    MOVE "S" TO AUTORIZADO
END-IF

Uma IA pode sugerir automaticamente:

Caso 1

Saldo = 500

Saque = 300

Resultado esperado:

AUTORIZADO = S

Caso 2

Saldo = 300

Saque = 500

Resultado esperado:

AUTORIZADO = N

Caso 3

Saldo = 500

Saque = 500

Resultado esperado:

AUTORIZADO = S

Isso acelera significativamente testes unitários.


Agentes de IA

O próximo passo da evolução são os agentes.

Enquanto um chatbot apenas responde perguntas, um agente executa tarefas.

Imagine:

"Abra um chamado porque houve aumento de ABEND S0C7."

O agente poderá:

  • consultar o SDSF;

  • analisar logs;

  • pesquisar incidentes semelhantes;

  • abrir ticket;

  • notificar equipes;

  • sugerir solução.

Tudo automaticamente.


Arquitetura de um Agente Mainframe

                    Usuário

                       │

                       ▼

               Agente Inteligente

                       │

          ┌────────────┼────────────┐

          ▼            ▼            ▼

      MCP Tool     RAG Engine   Prompt Engine

          │            │            │

          └────────────┼────────────┘

                       ▼

             IBM API Connect

                       │

          ┌────────────┼────────────┐

          ▼            ▼            ▼

      z/OS Connect    MQ      REST APIs

          │

          ▼

      CICS

          │

          ▼

      COBOL

          │

          ▼

     Db2 / VSAM / IMS

Observe que o agente não substitui aplicações.

Ele coordena.


Observabilidade Inteligente

Ferramentas como:

  • OpenTelemetry

  • Grafana

  • Prometheus

  • Instana

  • IBM Z APM Connect

produzem milhões de métricas.

Uma IA consegue resumir tudo.

Exemplo:

Ao invés de mostrar:

CPU = 83%

I/O = 65%

Storage = 72%

Buffer Pool = 94%

Response Time = 1,8s

A IA apresenta:

Detectamos degradação iniciada às 14h23 causada por aumento nas leituras aleatórias do Db2. Existe forte correlação com o deploy realizado às 14h18.

Isso muda completamente a produtividade.


Segurança com IA

Fraudes evoluem diariamente.

A IA ajuda identificando padrões.

Exemplo:

Cliente normalmente utiliza:

São Paulo

09:00 às 20:00

Compras abaixo de R$ 500.

De repente:

Compra de US$ 8.000

Outro continente

03:17 da manhã.

O modelo identifica anomalias antes mesmo da autorização.


IA Não Pode Alucinar

Esse é um ponto crítico.

Em sistemas financeiros:

Não existe "quase certo".

Imagine responder:

Seu saldo é R$ 15.000

quando na verdade são R$ 1.500.

Por isso arquiteturas corporativas utilizam:

  • RAG

  • MCP

  • APIs oficiais

  • Catálogo de Dados

  • Governança

  • Logs

  • Auditoria

Toda resposta precisa ser rastreável.


Engenharia de Prompt para Mainframe

Prompt ruim:

Explique esse programa.

Prompt profissional:

Você é um arquiteto IBM Z.

Analise este programa COBOL.

Explique:

• regras de negócio

• dependências

• tabelas Db2

• transações CICS

• arquivos VSAM

• riscos

• complexidade

• sugestões de testes

Não invente informações.
Indique apenas aquilo identificado no código.

A qualidade muda completamente.


DevOps + IA

Imagine um pipeline.

Git

↓

Pull Request

↓

SonarQube

↓

COBOL Check

↓

IA

↓

Resumo

↓

Code Review

↓

Deploy

Antes mesmo do revisor abrir o código, a IA já produziu:

  • resumo;

  • riscos;

  • impacto;

  • módulos afetados;

  • documentação.


O Papel do Desenvolvedor

Existe medo.

"IA vai substituir programadores."

A história mostra outra coisa.

Quando surgiram:

  • compiladores;

  • IDEs;

  • Git;

  • Java;

  • frameworks;

  • Cloud;

  • DevOps.

Disseram exatamente a mesma coisa.

O profissional mudou.

Não desapareceu.


O Novo Desenvolvedor Mainframe

Nos próximos anos veremos um perfil diferente.

Além de COBOL, ele entenderá:

✓ APIs

✓ JSON

✓ Python

✓ Engenharia de Prompt

✓ RAG

✓ MCP

✓ IA Generativa

✓ DevOps

✓ Observabilidade

✓ Segurança

✓ Arquitetura

Esse profissional será extremamente valorizado.


O Que Ainda Não Será Substituído

A IA pode escrever código.

Mas ela não conhece:

  • estratégia do banco;

  • legislação;

  • decisões executivas;

  • riscos jurídicos;

  • compliance;

  • auditoria;

  • cultura organizacional.

Quem conhece isso?

As pessoas.


Um Possível Futuro

Imagine daqui a alguns anos.

Você chega ao trabalho.

Pergunta:

"Existe algum problema crítico hoje?"

Resposta:

Foram detectadas três degradações.

Corrigi automaticamente duas.

A terceira envolve alteração de regra de negócio.

Já preparei documentação.

Seguem possíveis soluções.

Isso não é ficção.

É exatamente para onde estamos caminhando.


Arquitetura Completa de IA Corporativa para IBM Z

                    ┌──────────────────────────────────────────────┐
                    │              Usuário Final                   │
                    └──────────────────┬───────────────────────────┘
                                       │
                                       ▼
                        Web │ Mobile │ Chatbot │ Teams │ Slack
                                       │
                                       ▼
                  ┌────────────────────────────────────────┐
                  │        Gateway de APIs / WAF           │
                  └────────────────┬───────────────────────┘
                                   │
                    ┌──────────────┼──────────────┐
                    ▼              ▼              ▼
               Autenticação     Auditoria     Rate Limit
                                   │
                                   ▼
                      ┌────────────────────────────┐
                      │      Modelo Generativo     │
                      │        (watsonx.ai)        │
                      └────────────┬───────────────┘
                                   │
                  ┌────────────────┼────────────────┐
                  ▼                ▼                ▼
              Prompt           RAG Engine       MCP Server
             Orchestrator        Vetores        Ferramentas
                  │                │                │
                  └────────────────┼────────────────┘
                                   ▼
                    ┌──────────────────────────────────┐
                    │ APIs Corporativas / z/OS Connect │
                    └────────────────┬─────────────────┘
                                     │
              ┌──────────────────────┼──────────────────────┐
              ▼                      ▼                      ▼
           CICS                 IBM MQ                Batch
              │                      │                      │
              └──────────────┬───────┴──────────────────────┘
                             ▼
                     Aplicações COBOL
                             │
        ┌────────────────────┼────────────────────┐
        ▼                    ▼                    ▼
      Db2                  VSAM                 IMS
                             │
                             ▼
                    Fonte Oficial da Verdade

Considerações Finais

Durante décadas, ouvimos previsões sobre o fim do Mainframe. Entretanto, a realidade mostrou algo diferente: os sistemas que sustentam bancos, seguradoras, governos e grandes empresas continuam evoluindo porque concentram o ativo mais valioso de qualquer organização — seus dados e suas regras de negócio.

A Inteligência Artificial Generativa amplia esse cenário ao adicionar novas capacidades de interpretação, automação e interação. Tecnologias como RAG, MCP, watsonx, APIs, z/OS Connect e modelos privados permitem que aplicações modernas dialoguem com décadas de conhecimento implementado em COBOL, CICS e Db2, sem abrir mão de segurança, governança ou desempenho.

Não estamos testemunhando a substituição do Mainframe, mas o surgimento de uma nova geração de arquiteturas corporativas em que IA e IBM Z trabalham lado a lado. Para os profissionais da área, isso representa uma oportunidade única: dominar tanto os fundamentos dos sistemas críticos quanto as novas ferramentas de Inteligência Artificial.

O futuro pertence aos profissionais capazes de conectar esses dois mundos. Afinal, a inovação mais duradoura não nasce da ruptura, mas da integração inteligente entre o legado que funciona e as tecnologias que apontam para o amanhã.


☕ Continua a conversa no Bellacosa Mainframe

https://eljefemidnightlunch.blogspot.com/2026/07/ia-generativa-muito-alem-do-chatgpt.html




domingo, 5 de julho de 2026

IA Generativa Muito Além do ChatGPT

 

Bellacosa Mainframe e a ia generativa muito alem do chatgpt

☕ Um Café no Bellacosa Mainframe

IA Generativa Muito Além do ChatGPT

O Que Todo Programador COBOL Padawan Precisa Saber Sobre RAG, MCP, watsonx, IBM Z, CICS, Db2, APIs e Como a Inteligência Artificial Está Transformando os Sistemas Mais Críticos do Mundo (Parte 1)

"A Inteligência Artificial não substituirá o Mainframe. Ela tornará o Mainframe ainda mais indispensável."


Introdução

Se você acompanha as notícias sobre tecnologia, provavelmente já ouviu centenas de vezes que a Inteligência Artificial mudará tudo.

Empresas anunciam novos modelos quase diariamente. LLMs (Large Language Models), Agentes Inteligentes, Copilots, IA Generativa, RAG, MCP, Engenharia de Prompt... os nomes surgem em um ritmo tão acelerado que muitos profissionais começam a acreditar que tudo o que aprenderam nos últimos anos ficou obsoleto.

Mas existe uma pergunta que raramente aparece nas manchetes:

Onde estão os dados que realmente importam?

A resposta continua sendo a mesma há décadas.

Nos grandes bancos.

Nas seguradoras.

Nas bolsas de valores.

Nas empresas aéreas.

Nos governos.

Nas operadoras de cartão.

E, principalmente, dentro do IBM Z.

É justamente por isso que a próxima revolução da IA não será construída apenas na nuvem. Ela acontecerá onde os dados mais valiosos já vivem.

Bem-vindo ao futuro do Mainframe.


A Grande Mudança de Paradigma

Durante muito tempo acreditou-se que toda inovação exigia substituir sistemas antigos.

Era comum ouvir frases como:

"Vamos migrar tudo para a nuvem."

"COBOL morreu."

"Mainframe é legado."

Entretanto, o mercado mostrou uma realidade completamente diferente.

Os sistemas considerados "legados" continuam processando bilhões de transações diariamente.

Enquanto isso, empresas descobriram algo importante:

Mover petabytes de dados custa muito dinheiro.

Mais do que isso.

Pode aumentar riscos de segurança, criar problemas regulatórios e reduzir a performance.

Assim nasceu uma nova filosofia.

Não levar os dados para a IA.

Levar a IA até os dados.


O Mainframe Nunca Foi Apenas um Computador

Quando pensamos em IBM Z, muita gente imagina apenas enormes racks pretos.

Na prática, ele é muito mais do que isso.

Ele representa décadas de conhecimento empresarial.

Imagine um banco.

O saldo da sua conta não existe "na internet".

Existe dentro de regras cuidadosamente escritas ao longo de décadas.

Essas regras determinam:

  • como calcular juros;

  • como validar empréstimos;

  • como impedir fraudes;

  • como processar PIX;

  • como liquidar operações financeiras;

  • como calcular tarifas;

  • como registrar auditorias.

Grande parte desse conhecimento está codificado em programas COBOL, PL/I, CICS e Db2.

Isso significa que a IA não pode simplesmente "inventar" respostas.

Ela precisa consultar essas regras.


IA Generativa Não É um Banco de Dados

Esse é um dos maiores equívocos atuais.

Um LLM não "sabe" quanto dinheiro existe em sua conta.

Ele também não sabe:

  • limite do cartão;

  • última transação;

  • saldo do FGTS;

  • número da apólice;

  • posição dos investimentos.

Essas informações vivem em sistemas transacionais.

O papel da IA é diferente.

Ela interpreta.

Resume.

Explica.

Conversa.

Traduz.

Mas quem fornece a verdade continua sendo o sistema corporativo.

É exatamente por isso que IBM Z e IA trabalham tão bem juntos.


O Papel do RAG

Uma das tecnologias mais importantes da IA moderna chama-se Retrieval-Augmented Generation (RAG).

Em vez de confiar apenas no conhecimento aprendido durante o treinamento do modelo, o RAG consulta informações atualizadas antes de responder.

Imagine este fluxo.

Usuário
    │
    ▼
Pergunta
    │
    ▼
Modelo de IA
    │
    ▼
Consulta Base Corporativa
    │
    ▼
Db2
VSAM
Documentos
COBOL
CICS
APIs
    │
    ▼
Contexto Recuperado
    │
    ▼
Resposta Inteligente

Agora imagine um cliente perguntando:

"Por que meu financiamento foi recusado?"

Sem RAG, o modelo poderia apenas explicar genericamente como funcionam financiamentos.

Com RAG:

  • consulta o cadastro;

  • verifica políticas;

  • identifica pendências;

  • acessa documentação;

  • monta uma resposta personalizada.

A diferença é enorme.


O Que é MCP?

Nos últimos meses surgiu um termo que promete mudar completamente a forma como agentes inteligentes trabalham.

MCP.

Model Context Protocol.

Pense nele como um padrão para conectar modelos de IA a ferramentas externas.

Sem MCP:

IA

↓

Resposta baseada apenas
no treinamento

Com MCP:

IA

↓

Ferramentas

↓

Banco de Dados

↓

Mainframe

↓

APIs

↓

Documentos

↓

Resposta muito mais precisa

Isso permite que um agente converse naturalmente enquanto consulta sistemas reais.

Não é mais apenas um chatbot.

É um assistente corporativo.


IBM watsonx e o IBM Z

Quando se fala em IA na IBM, um nome aparece constantemente.

watsonx.

Diferentemente de plataformas voltadas apenas para geração de texto, o watsonx foi concebido pensando no ambiente corporativo.

Seu foco inclui:

  • governança;

  • segurança;

  • compliance;

  • modelos customizados;

  • dados privados;

  • integração empresarial.

Isso faz enorme diferença.

Imagine um banco.

Ele dificilmente enviará informações sigilosas para um serviço público de IA.

Em vez disso, utilizará modelos privados, treinados dentro de sua própria infraestrutura.

É exatamente aí que soluções como o watsonx ganham destaque.


IA e COBOL Não Competem

Essa talvez seja a maior surpresa para quem está começando.

A IA não veio substituir COBOL.

Na verdade, ela depende dele.

Imagine um sistema bancário.

Cliente

↓

Chatbot

↓

Modelo Generativo

↓

API REST

↓

CICS

↓

Programa COBOL

↓

Db2

↓

Resposta Oficial

Perceba algo importante.

Quem decide se o cliente possui saldo suficiente?

COBOL.

Quem verifica regras de negócio?

COBOL.

Quem calcula juros?

COBOL.

Quem registra a transação?

COBOL.

A IA apenas transforma tudo isso em uma conversa mais natural.


APIs: A Ponte Entre Dois Mundos

Nos anos 80, aplicações conversavam usando protocolos proprietários.

Hoje, o cenário é outro.

REST.

JSON.

GraphQL.

gRPC.

OpenAPI.

Essas tecnologias tornaram possível integrar sistemas modernos com aplicações escritas décadas atrás.

Exemplo simplificado.

Aplicativo Mobile

↓

REST API

↓

IBM z/OS Connect

↓

CICS

↓

COBOL

↓

Db2

O usuário acredita estar falando com um aplicativo moderno.

Na realidade, o coração da operação continua sendo o Mainframe.


Exemplo Prático: Consulta de Saldo com IA

Imagine o seguinte diálogo.

Cliente:

Quanto tenho disponível para investir?

Fluxo interno:

Usuário

↓

LLM

↓

API

↓

COBOL

↓

Db2

↓

Saldo

↓

Perfil Financeiro

↓

IA gera resposta

Resposta:

"Você possui R$ 18.450 disponíveis. Considerando seu perfil conservador e seus investimentos atuais, existem alternativas de baixo risco compatíveis com seu histórico."

Quem calculou o saldo?

Db2.

Quem aplicou regras financeiras?

COBOL.

Quem transformou isso em linguagem natural?

A IA.


CICS Continua Sendo o Maestro

Durante décadas, o CICS foi responsável por coordenar milhões de transações.

Hoje ele ganha uma nova função.

Ser o elo entre aplicações modernas e sistemas críticos.

Imagine uma transferência PIX.

Aplicativo

↓

API

↓

CICS

↓

COBOL

↓

Db2

↓

Confirmação

↓

IA explica resultado

Em vez de substituir o CICS, a IA torna sua utilização ainda mais relevante.


Por Que Bancos Não Trocam Tudo?

Essa pergunta aparece constantemente.

A resposta é simples.

Porque funciona.

Mas existe outro motivo.

Imagine reescrever milhões de linhas de COBOL.

Quanto tempo levaria?

Quantos erros seriam introduzidos?

Quanto custaria?

Quanto risco financeiro seria criado?

Agora compare com outra abordagem.

Adicionar APIs

+

Adicionar IA

+

Adicionar Observabilidade

+

Adicionar Automação

=

Modernização gradual

Essa estratégia preserva décadas de conhecimento acumulado enquanto incorpora recursos modernos.

É muito mais segura e economicamente viável.


Primeira Arquitetura Completa

A seguir, uma visão simplificada de como uma arquitetura moderna pode integrar IA Generativa ao IBM Z:

                           ┌─────────────────────────────┐
                           │       Cliente Web/App       │
                           └─────────────┬───────────────┘
                                         │ HTTPS
                                         ▼
                           ┌─────────────────────────────┐
                           │   Chatbot / Assistente IA   │
                           └─────────────┬───────────────┘
                                         │
                              Prompt + Contexto
                                         │
                                         ▼
                      ┌─────────────────────────────────────┐
                      │      Modelo Generativo (LLM)        │
                      └─────────────┬───────────────────────┘
                                    │
                    RAG             │             MCP
                                    │
                                    ▼
          ┌───────────────────────────────────────────────────────┐
          │           Camada de Integração Inteligente            │
          │ APIs │ Ferramentas │ Documentos │ Catálogo │ Vetores  │
          └─────────────┬─────────────────────────────────────────┘
                        │
                REST / JSON / MQ
                        │
                        ▼
              ┌─────────────────────────┐
              │    IBM z/OS Connect     │
              └──────────┬──────────────┘
                         │
        ┌────────────────┼─────────────────┐
        ▼                ▼                 ▼
   CICS Online       Batch COBOL       MQ / Eventos
        │                │                 │
        └────────────┬───┴─────────────────┘
                     ▼
              ┌───────────────┐
              │ Programas COBOL│
              └──────┬────────┘
                     ▼
          ┌─────────────────────┐
          │ Db2 │ VSAM │ IMS DB │
          └─────────────────────┘

Essa arquitetura demonstra que a IA não elimina os sistemas existentes. Ela adiciona uma camada inteligente de interação, recuperação de contexto e geração de respostas, preservando o Mainframe como sistema de registro e fonte oficial da verdade.


Conclusão da Parte 1

Nos últimos anos, o debate sobre Inteligência Artificial concentrou-se em modelos cada vez maiores e mais sofisticados. No entanto, o verdadeiro diferencial competitivo das empresas não está apenas no modelo utilizado, mas na capacidade de conectar esses modelos aos dados corretos, com segurança, governança e desempenho.

É justamente nesse ponto que o IBM Z se destaca. Em vez de representar um obstáculo à inovação, ele se torna o alicerce sobre o qual soluções modernas de IA podem ser construídas. Tecnologias como RAG, MCP, APIs e o ecossistema watsonx mostram que a evolução dos sistemas corporativos não depende de substituir décadas de conhecimento, mas de integrá-las de forma inteligente.

Na Parte 2, vamos aprofundar essa jornada explorando casos reais do setor financeiro, arquiteturas de agentes de IA, observabilidade, DevOps para IBM Z, segurança, exemplos práticos de integração com COBOL, CICS e Db2, além de discutir como a Inteligência Artificial está transformando o papel do desenvolvedor Mainframe na próxima década.




   FAQ

  •  O Mainframe pode utilizar IA Generativa?
 Sim. 

  • A IA pode ser integrada ao IBM Z por meio de APIs, z/OS Connect, IBM MQ, RAG e plataformas como watsonx, permitindo que modelos consultem dados corporativos com segurança. O COBOL será substituído pela IA?
Não. 

A IA complementa aplicações COBOL, automatizando documentação, testes e atendimento, enquanto o COBOL continua executando as regras críticas de negócio. 

  •  O que é RAG? 

 Retrieval-Augmented Generation é uma técnica que permite ao modelo consultar bases de dados e documentos antes de responder, reduzindo alucinações e aumentando a precisão.

  • O que é MCP? 

Model Context Protocol é um protocolo aberto que padroniza a comunicação entre modelos de IA e ferramentas externas, como APIs, bancos de dados e sistemas corporativos. 

  •  O IBM watsonx funciona com Mainframe?
 Sim.

 O ecossistema watsonx foi desenvolvido para integração corporativa, oferecendo governança, segurança e suporte a modelos privados, podendo trabalhar em conjunto com aplicações IBM Z. 

  •  IA pode acessar Db2 e CICS? 
 Sim. 

Normalmente essa integração ocorre por meio de APIs REST, IBM z/OS Connect, IBM MQ ou serviços específicos que expõem funcionalidades do Mainframe de forma segura.

.



Vagner Bellacosa

quinta-feira, 2 de julho de 2026

Dos Cartões Perfurados ao Enterprise COBOL: A Evolução do STOP RUN e do GOBACK

 

Bellacosa Mainframe e as diferencas entre o goback e o stop run


Dos Cartões Perfurados ao Enterprise COBOL: A Evolução do STOP RUN e do GOBACK

Essa é uma excelente pergunta, e a resposta curta é:

Hoje, em projetos modernos de Enterprise COBOL para z/OS, a IBM e a maioria das empresas recomendam usar GOBACK em vez de STOP RUN. Não é apenas modismo; existem razões técnicas, arquiteturais e de reutilização do ambiente de execução (Language Environment). (IBM)

Vamos analisar como um arquiteto de Mainframe faria.


A origem do STOP RUN

Quando COBOL surgiu na década de 1960, praticamente todos os programas eram executados diretamente pelo sistema operacional.

O fluxo era simples:

JCL
 │
 ▼
Programa COBOL
 │
STOP RUN
 │
 ▼
MVS

Naquela época:

  • não existiam APIs REST;

  • não existiam aplicações reutilizáveis;

  • praticamente não existiam subprogramas complexos;

  • o programa começava e terminava.

O STOP RUN fazia exatamente isso:

"Acabei. Pode encerrar tudo."


O surgimento do GOBACK

Com o crescimento dos sistemas apareceram:

  • subprogramas

  • bibliotecas

  • módulos reutilizáveis

  • CICS

  • IMS

  • DB2

  • Language Environment (LE)

Agora um programa não era mais necessariamente o "programa principal".

Exemplo:

JCL

  MAIN01

     │

 CALL CLIENTE

     │

 CALL CALCJURO

     │

 CALL VALIDA

Imagine se CALCJURO executasse:

STOP RUN

O que aconteceria?

Toda a aplicação terminaria imediatamente.

Não apenas o módulo.

Todo o Run Unit.

É exatamente isso que a IBM documenta. STOP RUN termina toda a Run Unit; já GOBACK retorna ao chamador quando usado em um programa chamado. (IBM)


A grande diferença

STOP RUN

Programa

↓

encerra TODA a Run Unit

↓

retorna ao sistema operacional

GOBACK

Programa

↓

retorna para quem chamou

↓

continua a execução

Se o programa for o principal:

GOBACK

↓

faz praticamente o mesmo trabalho do STOP RUN

A IBM afirma isso explicitamente:

Em um programa principal, GOBACK funciona como STOP RUN. Em um subprograma, GOBACK funciona como EXIT PROGRAM. (IBM)


Exemplo prático

Programa principal

MAIN
CALL "A"

DISPLAY "FIM"

STOP RUN

Programa A

DISPLAY "A"

STOP RUN

Resultado

A

O DISPLAY "FIM"

nunca acontece.


Agora usando GOBACK

Programa A

DISPLAY "A"

GOBACK

Resultado

A

FIM

Porque voltou para o MAIN.


Então por que muitas empresas proíbem STOP RUN?

Não porque ele esteja errado.

Mas porque ele cria risco.

Imagine um programa hoje.

Batch

↓

Framework

↓

Biblioteca

↓

Serviço

↓

Seu Programa

Você nem sempre sabe quem chamou seu módulo.

Se usar

STOP RUN

você encerra toda a aplicação.

Se usar

GOBACK

o programa simplesmente devolve o controle.

Muito mais seguro.


O princípio da reutilização

Hoje escrevemos programas para serem reutilizados.

Um módulo pode ser chamado por:

  • Batch

  • CICS

  • IMS

  • API REST

  • MQ

  • Java

  • z/OS Connect

  • outro COBOL

O módulo não deve assumir que é o "dono" da aplicação.

Ele apenas faz seu trabalho.

Depois devolve o controle.

Isso é exatamente o comportamento do GOBACK.


O impacto no Language Environment (LE)

Aqui está uma das razões mais importantes.

O Enterprise COBOL roda sobre o Language Environment (LE).

O LE controla:

  • memória

  • pilha

  • heap

  • tratamento de exceções

  • inicialização

  • reutilização do runtime

Quando ocorre

STOP RUN

o LE encerra o Run Unit.

Quando ocorre

GOBACK

ele apenas retorna ao chamador.

Isso permite reutilizar o ambiente de execução em muitos cenários. (IBM)


O caso do RTEREUS

Pouca gente conhece essa opção.

Existe um parâmetro do LE chamado

RTEREUS

(Runtime Reuse)

Ele permite reutilizar o ambiente de execução COBOL.

A IBM afirma claramente:

Para obter os benefícios do RTEREUS, substitua STOP RUN por GOBACK. STOP RUN encerra o ambiente reutilizável. (IBM)

Ou seja:

STOP RUN

↓

destrói o ambiente

↓

novo ambiente precisa ser criado

Enquanto

GOBACK

↓

reutiliza o ambiente

↓

menos overhead

Performance

O ganho normalmente não é enorme em um programa isolado.

Mas imagine milhares de execuções por minuto.

1000 programas

↓

cada um recria o Runtime

↓

mais CPU

Com reutilização:

Runtime permanece ativo

↓

menos inicialização

↓

menos CPU

É exatamente por isso que grandes bancos adotam GOBACK como padrão.


E no CICS?

No CICS normalmente termina-se com

EXEC CICS RETURN

e não com

STOP RUN

porque quem controla a aplicação é o CICS.

O mesmo raciocínio vale para IMS.

O programa devolve o controle ao ambiente.

Não encerra a Run Unit.


Um exemplo interessante: DFSORT

A IBM é ainda mais direta na documentação de user exits do DFSORT:

User exits escritos em COBOL não devem usar STOP RUN. Para retornar ao DFSORT, use GOBACK. (IBM)

Ou seja,

STOP RUN

↓

encerra tudo

↓

ERRADO
GOBACK

↓

retorna ao DFSORT

↓

CORRETO

Existe recomendação oficial da IBM?

Sim.

A documentação oficial afirma que:

  • em programas principais, GOBACK tem o mesmo efeito de STOP RUN;

  • em subprogramas, GOBACK retorna ao chamador, enquanto STOP RUN termina toda a Run Unit. (IBM)

Além disso, para ambientes reutilizáveis (RTEREUS), a IBM recomenda trocar STOP RUN por GOBACK. (IBM)

Documentação oficial da IBM:

Minha recomendação para um COBOL Padawan

Se você está desenvolvendo em Enterprise COBOL moderno, adote esta regra simples:

SituaçãoRecomendação
Programa Batch principalGOBACK
Subprograma (CALL)GOBACK
Biblioteca reutilizávelGOBACK
Módulo chamado por Java, CICS, IMS ou APIsGOBACK
Novo desenvolvimentoGOBACK como padrão

Na prática, GOBACK é um superconjunto de STOP RUN: ele faz o papel de STOP RUN quando está no programa principal e o de EXIT PROGRAM quando está em um programa chamado. Isso reduz riscos, melhora a reutilização do runtime e torna o código mais flexível para arquiteturas modernas. Por esse conjunto de vantagens, a preferência atual por GOBACK é muito mais uma decisão de engenharia do que um simples modismo.

Design Patterns no COBOL Mainframe Os Padrões que os Grandes Programadores Sempre Usaram (Mesmo Antes de Eles Receberem um Nome)

 

Bellacosa Mainframe e os design pattern em cobol mainframe

☕ Um Café no Bellacosa Mainframe

Design Patterns no COBOL Mainframe

Os Padrões que os Grandes Programadores Sempre Usaram (Mesmo Antes de Eles Receberem um Nome)

"Todo programador COBOL iniciante acredita que um bom sistema nasce de um bom código. O programador experiente sabe que um bom sistema nasce de boas decisões de arquitetura."

Existe uma curiosidade fascinante na história da computação.

Quando ouvimos falar em Design Patterns, quase todo mundo lembra imediatamente do famoso livro Design Patterns: Elements of Reusable Object-Oriented Software, publicado em 1994 pelo famoso Gang of Four (GoF).

Muitos acreditam que os padrões nasceram ali.

Mas isso não é verdade.

Na realidade, os profissionais de Mainframe utilizavam padrões muito antes de eles receberem nomes elegantes.

Os sistemas bancários dos anos 70, 80 e 90 já possuíam separação de responsabilidades, reutilização de código, módulos especializados, camadas de acesso a banco, mecanismos de validação, tratamento centralizado de erros, componentes compartilhados e arquiteturas extremamente organizadas.

Eles simplesmente não chamavam isso de Pattern.

Chamavam de:

"Boa programação."

E existe um motivo simples.

Quando um sistema precisa sobreviver por 40 anos, processar bilhões de transações e nunca parar, improvisação não funciona.

É por isso que aprender Patterns em COBOL significa aprender como os grandes sistemas do mundo realmente funcionam.

Hoje vamos explorar essa jornada.

Pegue seu café.

Vamos entrar na mente dos arquitetos que construíram os sistemas que movimentam praticamente todo o dinheiro do planeta.


O que é um Pattern?

Pattern significa literalmente:

Padrão de solução.

Não é código.

Não é framework.

Não é biblioteca.

É uma maneira comprovada de resolver um problema recorrente.

Sempre que um problema aparece repetidamente, alguém encontra uma solução elegante.

Depois de milhares de aplicações, essa solução vira um padrão.


A origem dos Patterns

Antes mesmo da computação, um arquiteto chamado Christopher Alexander estudava cidades e construções.

Ele percebeu algo interessante.

As melhores cidades do mundo utilizavam soluções semelhantes para problemas semelhantes.

Uma praça.

Uma rua.

Uma entrada.

Uma janela.

Tudo seguia padrões.

Em 1977 ele publicou:

A Pattern Language.

Décadas depois, programadores perceberam:

"Software também possui problemas repetitivos."

Assim nasceram os Design Patterns modernos.


Mas... e o Mainframe?

Enquanto isso...

Em grandes bancos...

Seguradoras...

Governos...

Empresas aéreas...

Os analistas já utilizavam exatamente a mesma filosofia.

Um exemplo clássico.

Em vez de cada programa acessar DB2 diretamente...

Criava-se um módulo responsável apenas por isso.

Hoje chamaríamos isso de:

DAO Pattern.

Na época era apenas:

"O módulo que conversa com o banco."


Por que Patterns são importantes?

Imagine um hospital.

Você não quer que cada médico invente sua própria forma de operar.

Existe um procedimento.

Uma sequência.

Uma organização.

Software crítico funciona da mesma forma.

Patterns tornam sistemas:

  • previsíveis

  • fáceis de manter

  • fáceis de evoluir

  • seguros

  • reutilizáveis


Pattern 1 — Modularização

O primeiro pattern da história do Mainframe.

Um programa enorme faz tudo.

Depois de alguns anos...

Ninguém entende mais nada.

A solução?

Separar responsabilidades.

Exemplo:

Programa Principal

Validação

Regras de Negócio

DB2

Relatórios

Logs

Cada módulo possui apenas uma função.

Hoje isso parece óbvio.

Na década de 70 era revolucionário.


Como aplicar

Nunca escreva um programa de 5.000 linhas.

Pergunte:

Esta rotina pode virar um subprograma?

Se a resposta for sim...

Faça isso.


Pattern 2 — COPYBOOK Pattern

Uma das maiores invenções do COBOL.

Em vez de repetir estruturas...

Criamos COPYBOOKS.

Exemplo:

Cliente

Conta

Saldo

Endereço

CPF

Esses campos aparecem em centenas de programas.

Sem COPYBOOK...

Bastaria alterar um campo para criar centenas de inconsistências.

Com COPYBOOK...

Uma alteração.

Todos utilizam.


Boas práticas

Nunca copie estruturas manualmente.

Sempre centralize.


Pattern 3 — Validation Layer

Nunca misture validação com regra de negócio.

Errado:

Recebe CPF

Consulta DB2

Calcula juros

Valida CPF

Atualiza saldo

Tudo misturado.

Certo:

Entrada

Validação

Negócio

Persistência


Benefícios

Código mais limpo.

Testes mais simples.

Menos bugs.


Pattern 4 — Error Handler Centralizado

Um clássico absoluto.

Em vez de cada programa escrever mensagens diferentes...

Existe um módulo especializado.

Exemplo:

DISPLAY

ABEND

LOG

RETURN-CODE

Tudo passa por um componente comum.


Vantagens

Padronização.

Auditoria.

Facilidade de suporte.


Pattern 5 — File Access Layer

Em vez de cada programa abrir arquivos VSAM...

Criamos uma camada.

Programa

Arquivo Layer

VSAM

Se amanhã o arquivo virar DB2...

O programa quase não muda.


Isso é desacoplamento

A lógica de negócio não conhece detalhes físicos.

Esse conceito ficou famoso décadas depois.

No Mainframe já era realidade.


Pattern 6 — Database Access Layer

Muito comum em DB2.

Programa

Subprograma SQL

DB2

O programa não conhece SQL.

Conhece apenas serviços.

Exemplo:

Consultar Cliente

Atualizar Saldo

Inserir Conta

Excluir Registro

Muito semelhante aos Repository Patterns modernos.


Pattern 7 — Service Programs

Grandes empresas possuem centenas de programas.

Algumas regras aparecem em todos.

Cálculo de CPF.

Validação de agência.

Máscara.

Data.

Moeda.

Essas regras viram serviços.


Exemplo

CALL "CALCJURO"

CALL "VALIDCPF"

CALL "FORMATA"

CALL "DATAUTIL"

Isso reduz milhares de linhas duplicadas.


Pattern 8 — Dispatcher

Muito usado em CICS.

Um programa recebe uma operação.

Dependendo da função...

Chama outro programa.

Entrada

Dispatcher

Consulta

Inclusão

Alteração

Exclusão

Hoje chamamos isso de Command Dispatcher.


Pattern 9 — Table Driven Programming

Em vez de dezenas de IF...

Utilize tabelas.

Errado:

IF UF = SP

IF UF = RJ

IF UF = MG

...

Melhor:

Tabela de estados.

Pesquisa.

Resultado.

Menos código.

Mais manutenção.


Pattern 10 — Configuration Pattern

Nunca coloque constantes espalhadas.

Crie parâmetros.

Copybooks.

Arquivos.

Tabelas.

Isso evita recompilar programas para pequenas mudanças.


Pattern 11 — Batch Pipeline

Muito usado em processamento noturno.

Leitura

Validação

Transformação

Classificação

Carga

Cada etapa faz apenas uma coisa.

Se uma falhar...

A anterior permanece íntegra.


Pattern 12 — Restart Pattern

Um dos mais importantes.

Imagine um Batch de 8 horas.

Na hora 7 ocorre falha.

Sem Restart...

Tudo começa novamente.

Com Restart...

Continua do último checkpoint.

Essa ideia economiza milhões de dólares todos os anos.


Pattern 13 — Checkpoint Pattern

Muito usado com IMS.

A cada quantidade de registros...

Grava-se um ponto seguro.

Em caso de falha...

Retorna dali.


Pattern 14 — Logging Pattern

Nunca dependa apenas do DISPLAY.

Registre:

Programa

Data

Hora

Usuário

Arquivo

SQLCODE

Chave

Operação

Isso salva equipes inteiras durante incidentes.


Pattern 15 — Retry Pattern

DB2 indisponível?

Arquivo bloqueado?

MQ ocupado?

Em vez de falhar imediatamente...

Tente novamente algumas vezes.

Mas cuidado.

Retry infinito vira desastre.


Pattern 16 — Circuit Breaker (Modernização)

Muito usado via APIs.

Se um serviço externo está indisponível...

Pare de chamá-lo temporariamente.

Evita sobrecarga.


Pattern 17 — Adapter

Muito utilizado na modernização.

Sistema antigo

Adapter

API REST

O COBOL permanece praticamente igual.


Pattern 18 — Facade

Imagine vinte programas acessando vinte módulos.

Complicado.

Criamos uma fachada.

Programa

Facade

Serviços internos

Tudo fica mais simples.


Pattern 19 — Strategy

O cálculo muda conforme o produto.

Em vez de centenas de IF...

Criamos estratégias.

Produto A

Regra A

Produto B

Regra B

Produto C

Regra C


Pattern 20 — Template Process

Muito comum em Batch.

Todos os programas fazem:

Inicialização

Leitura

Processamento

Gravação

Fechamento

Apenas a lógica muda.

A estrutura permanece.


Como identificar quando usar um Pattern

Faça cinco perguntas:

  1. Estou repetindo código?

  2. Esse módulo possui mais de uma responsabilidade?

  3. Se mudar amanhã, quantos programas serão alterados?

  4. Consigo testar isoladamente?

  5. Outra equipe entenderia isso facilmente?

Se várias respostas forem "não"...

Provavelmente existe um Pattern melhor.


Os erros mais comuns dos iniciantes

O famoso "programa monolítico".

Tudo dentro da PROCEDURE DIVISION.

Milhares de linhas.

GO TO para todos os lados.

Variáveis globais.

DISPLAY espalhados.

SQL misturado.

Validação misturada.

Regras misturadas.

Esse tipo de programa funciona...

Até o primeiro incidente em produção.


Como evoluir como Programador COBOL

Existe uma evolução natural.

Nível 1

Aprende sintaxe.

MOVE.

IF.

PERFORM.

READ.

WRITE.


Nível 2

Aprende organização.

Seções.

Parágrafos.

COPYBOOKS.

Subprogramas.


Nível 3

Aprende Patterns.

Reutilização.

Arquitetura.

Modularização.


Nível 4

Aprende integração.

DB2.

CICS.

IMS.

MQ.

REST.

JSON.


Nível 5

Pensa como arquiteto.

Nesse ponto, você não escreve apenas programas.

Você desenha soluções.


Curiosidades

  • Muitos sistemas bancários escritos há mais de 35 anos continuam ativos porque seguiram padrões consistentes.

  • Diversos conceitos popularizados em Java, C# e outras linguagens já eram praticados em ambientes COBOL, ainda que com nomes diferentes.

  • O uso disciplinado de COPYBOOKS foi um dos fatores que permitiu manter aplicações enormes sincronizadas por décadas.

  • Grandes equipes de Mainframe costumam definir padrões internos de nomenclatura, tratamento de erros, chamadas de subprogramas e acesso a dados para reduzir riscos operacionais.


Melhores práticas para o dia a dia

  • Dê a cada programa uma responsabilidade clara.

  • Evite duplicação de lógica.

  • Centralize estruturas em COPYBOOKS.

  • Padronize mensagens de erro.

  • Isole acesso a arquivos e bancos de dados.

  • Documente interfaces de subprogramas.

  • Use nomes consistentes para programas, parágrafos e variáveis.

  • Escreva código pensando em quem fará a manutenção daqui a dez anos.

  • Prefira simplicidade à esperteza.

  • Revise continuamente seu código procurando oportunidades de extrair novos módulos reutilizáveis.


O futuro dos Patterns no Mainframe

O Mainframe moderno conversa com APIs REST, mensageria, microsserviços, Kubernetes, aplicações Java, Python e serviços em nuvem. Nesse cenário, os Patterns clássicos continuam mais relevantes do que nunca. Adapter, Facade, Retry, Circuit Breaker, Service Layer e Repository ajudam a integrar aplicações COBOL com tecnologias modernas sem sacrificar estabilidade.

O profissional que domina esses conceitos deixa de ser apenas um desenvolvedor de programas e passa a ser um engenheiro de soluções. Ele entende quando reutilizar, quando desacoplar, quando encapsular e quando simplificar. Esse conhecimento vale muito mais do que decorar comandos da linguagem.


Conclusão

Existe uma frase muito conhecida entre arquitetos de software:

"Código ruim pode funcionar. Arquitetura ruim cobra juros."

No universo IBM Z, essa cobrança aparece em horas extras, incidentes de produção, dificuldades de manutenção e projetos de modernização cada vez mais caros.

Os Patterns existem justamente para evitar esse cenário. Eles representam décadas de experiência acumulada por milhares de profissionais que enfrentaram os mesmos problemas e encontraram soluções elegantes, reutilizáveis e seguras.

Se você é um Programador COBOL Padawan, não tente memorizar todos os Patterns de uma vez. Comece pelos mais importantes: modularização, COPYBOOKS, validação, tratamento centralizado de erros, acesso a dados desacoplado e reutilização de serviços. À medida que sua experiência crescer, você perceberá que esses padrões aparecem naturalmente em praticamente todos os grandes sistemas corporativos.

Lembre-se: escrever código é uma habilidade. Escrever código que continuará funcionando e sendo compreendido daqui a vinte anos é uma arte. E essa arte é construída com disciplina, boas práticas e padrões sólidos.

No Bellacosa Mainframe, costumamos dizer que o verdadeiro poder de um Programador COBOL não está na quantidade de comandos que ele conhece, mas na qualidade das decisões que toma antes mesmo de começar a digitar a primeira linha de código.

Esse é o caminho que transforma um Padawan em um verdadeiro Mestre do Mainframe.

Se desejar, posso criar a Parte 2 com mais de 3.000 palavras, abordando 40+ Design Patterns específicos para COBOL, CICS, DB2, IMS, Batch, APIs REST, MQ e modernização no IBM Z, com exemplos completos de código COBOL para cada padrão.


sábado, 13 de junho de 2026

Guard Rails, COBOL, Mainframe, Engenharia de Software, Desenvolvimento COBOL, Sistemas Críticos, Confiabilidade, Governança de TI, DevOps, Arquitetura de Software, Batch Processing, Segurança da Informação, SRE, Boas Práticas, Tecnologia Bancária

 

Bellacosa Mainframe e o guard rails em desenvolvimento de software

Guard Rails: A Arte de Impedir que um Desenvolvedor Derrube o Banco

Uma conversa que todo desenvolvedor COBOL deveria ter

Imagine a seguinte situação.

Você acabou de entrar em uma instituição financeira.

É seu terceiro mês como desenvolvedor COBOL.

Depois de semanas corrigindo pequenos bugs, finalmente recebe uma tarefa importante.

Uma rotina responsável pelo envio de notificações para clientes.

O gerente explica:

— Precisamos incluir um novo tipo de comunicação.

Você faz a alteração.

Compila.

Executa os testes.

Tudo parece funcionar.

A mudança é promovida para produção.

Horas depois, milhares de clientes recebem uma mensagem errada.

O call center entra em colapso.

O aplicativo registra picos de acesso.

O time de negócios inicia uma reunião de emergência.

A diretoria quer explicações.

E então surge a pergunta:

Como isso foi possível?

A resposta geralmente não é:

"Porque o desenvolvedor errou."

A resposta correta costuma ser:

"Porque o sistema permitiu que um erro chegasse à produção."

É exatamente nesse ponto que surge um dos conceitos mais importantes da engenharia moderna:

Guard Rails.


O que são Guard Rails?

A tradução literal seria:

"trilhos de proteção".

A inspiração vem das rodovias.

Quando um carro sai da pista, existe uma barreira metálica para impedir que ele caia de um penhasco.

O guard rail não evita o erro do motorista.

Ele reduz as consequências.

Na engenharia de software acontece exatamente a mesma coisa.

Os desenvolvedores inevitavelmente cometerão erros.

Os analistas inevitavelmente esquecerão requisitos.

Os operadores inevitavelmente clicarão em algo errado.

Os administradores inevitavelmente executarão comandos incorretos.

O objetivo não é eliminar o erro humano.

O objetivo é impedir que o erro se transforme em desastre.


O erro é inevitável

Desenvolvedores juniores costumam acreditar que sistemas caem porque alguém não sabia programar.

Essa visão desaparece rapidamente em ambientes corporativos.

Os maiores incidentes da história da tecnologia não foram causados por programadores incompetentes.

Foram causados por profissionais experientes trabalhando sob pressão.

Pessoas excelentes.

Pessoas inteligentes.

Pessoas treinadas.

Pessoas humanas.

A questão nunca foi:

"Quem errou?"

A questão sempre foi:

"Por que o sistema permitiu?"

Essa diferença muda completamente a forma de construir software.


Um exemplo COBOL simples

Considere um programa que realiza transferência bancária.

Versão sem Guard Rails:

IF SALDO-CONTA > 0
   SUBTRACT VALOR FROM SALDO-CONTA
END-IF.

Parece correto.

Mas existe um problema.

Suponha:

Saldo = 100

Transferência = 1000

O programa permitirá saldo negativo.

Agora uma versão mais segura.

IF VALOR > SALDO-CONTA
   DISPLAY "TRANSFERENCIA NEGADA"
   GO TO FIM-PROGRAMA
END-IF.

O sistema agora protege o negócio.

Isso é um Guard Rail.


Guard Rail não é regra de negócio

Esse é um erro comum.

Muitos desenvolvedores confundem os dois conceitos.

Regra de negócio:

"O cliente não pode sacar mais que possui."

Guard Rail:

"Mesmo que alguém esqueça a regra, o sistema impedirá a operação."

Uma regra define comportamento.

Um Guard Rail protege comportamento.


A filosofia do mainframe

Durante décadas, os ambientes mainframe desenvolveram uma cultura diferente do mundo moderno.

Em startups existe uma frase famosa:

Move fast.

Nos bancos existe outra:

Don't break production.

A razão é simples.

Um erro em rede social gera reclamações.

Um erro bancário gera prejuízo.

Por isso o mundo COBOL sempre valorizou:

  • validação;

  • redundância;

  • auditoria;

  • segregação;

  • rastreabilidade.

Sem perceber, os ambientes mainframe implementavam Guard Rails muito antes do conceito ganhar popularidade.


O caso clássico do JCL

Todo profissional de mainframe já ouviu histórias de horror envolvendo JCL.

Imagine um dataset:

CLIENTES.PRODUCAO

Agora imagine um utilitário de exclusão.

DELETE CLIENTES.PRODUCAO

Um comando simples.

Um erro simples.

Um desastre gigantesco.

Por isso empresas maduras criam Guard Rails.

Por exemplo:

  • confirmação obrigatória;

  • aprovação dupla;

  • ambiente segregado;

  • backup automático.

A exclusão continua possível.

Mas torna-se muito mais difícil.


O princípio do “Are You Sure?”

Existe uma categoria inteira de Guard Rails baseada em confirmação.

Exemplo.

Você tenta apagar um arquivo.

O sistema pergunta:

"Tem certeza?"

Parece algo trivial.

Mas essa simples pergunta já evitou milhões de erros ao longo da história da computação.

Em sistemas financeiros essa ideia evolui.

Em vez de uma confirmação:

  • duas confirmações;

  • dois operadores;

  • dois gestores;

  • duas aprovações.

Chamamos isso de Four Eyes Principle.

Princípio dos quatro olhos.


Guard Rails em processamento batch

O universo COBOL vive cercado de batches.

Folha de pagamento.

Compensação bancária.

Fechamento contábil.

Liquidação financeira.

Imagine um programa que processa:

10.000 registros

Normal.

Agora imagine:

100 milhões de registros

Algo está errado.

Sem Guard Rails o programa continua.

Com Guard Rails ele interrompe:

IF QTDE-REGISTROS > LIMITE-MAXIMO
   DISPLAY "PROCESSAMENTO ANORMAL"
   ABEND
END-IF.

Esse simples teste pode evitar horas de caos operacional.


O conceito de Fail Fast

Existe um princípio muito importante:

Fail Fast.

Falhe rapidamente.

Muitos sistemas tentam continuar funcionando mesmo após identificar inconsistências.

Isso parece inteligente.

Na prática costuma piorar tudo.

Se um dado crítico estiver errado, o melhor comportamento é parar imediatamente.

Exemplo:

IF CODIGO-CLIENTE = SPACES
   ABEND
END-IF.

Parar cedo é melhor do que produzir milhões de registros incorretos.


Guard Rails contra desenvolvedores

Esse é um tema que incomoda iniciantes.

Ninguém gosta de ouvir:

"O sistema precisa proteger a empresa de você."

Mas essa é a realidade.

Um Guard Rail existe justamente porque até profissionais excelentes erram.

Imagine um comando SQL.

Sem proteção:

DELETE FROM CLIENTES;

Com proteção:

DELETE FROM CLIENTES
WHERE ID = :CLIENTE;

Ou ainda melhor.

Permissão somente leitura em produção.

O desenvolvedor continua competente.

O ambiente apenas se torna mais seguro.


O incidente do Nubank e os Guard Rails

O caso do falso aviso de liquidação tornou-se um exemplo interessante.

Independentemente dos detalhes internos, uma pergunta surgiu:

Como uma comunicação tão crítica chegou aos clientes?

A resposta provavelmente envolve ausência ou falha de Guard Rails.

Por exemplo:

  • validação insuficiente;

  • aprovação inadequada;

  • rollout inexistente;

  • testes incompletos.

Nenhum sistema deveria conseguir informar a liquidação de um banco sem múltiplas camadas de proteção.


Rollout gradual

Imagine um envio para:

50 milhões de clientes

Sem Guard Rail:

envio imediato.

Com Guard Rail:

1% da base.

Validação.

5%.

Validação.

10%.

Validação.

100%.

Empresas como Google, Amazon e Netflix utilizam esse modelo constantemente.

O objetivo é reduzir o raio da explosão.


Blast Radius

Todo arquiteto experiente faz uma pergunta.

Se isso falhar, quantas pessoas serão afetadas?

Chamamos isso de Blast Radius.

Raio de explosão.

Exemplo.

Erro em um batch:

Impacto:

500 clientes.

Blast Radius pequeno.

Erro em compensação nacional:

Impacto:

50 milhões de clientes.

Blast Radius enorme.

Guard Rails existem para reduzir esse raio.


Observabilidade também é Guard Rail

Muitos desenvolvedores acreditam que Guard Rails são apenas validações.

Não.

Monitoramento também é proteção.

Imagine:

Processamento esperado:

1000 transações por minuto

Sistema detecta:

500.000 transações por minuto

Algo claramente está errado.

Um bom sistema dispara alarmes.

Isso também é Guard Rail.


O conceito de Circuit Breaker

Em sistemas distribuídos modernos existe outro Guard Rail famoso.

Circuit Breaker.

Inspirado nos disjuntores elétricos.

Se uma dependência começa a falhar:

o sistema corta a conexão.

Em vez de derrubar tudo.

No mundo mainframe encontramos equivalentes há décadas:

  • limites operacionais;

  • interrupções controladas;

  • filas protegidas;

  • rejeições automáticas.

A ideia é a mesma.

Conter danos.


O erro mais caro é o silencioso

Existe uma frase conhecida entre engenheiros de confiabilidade:

Sistemas barulhentos são irritantes.

Sistemas silenciosamente errados são perigosos.

Um programa que falha imediatamente chama atenção.

Um programa que produz dados incorretos durante três dias pode gerar prejuízos gigantescos.

Por isso Guard Rails modernos privilegiam transparência.

Tudo deve ser:

  • registrado;

  • monitorado;

  • auditado;

  • rastreável.


A maturidade profissional

Existe um momento na carreira em que o desenvolvedor deixa de pensar:

"Meu código funciona."

E começa a pensar:

"O que acontece quando ele falhar?"

Essa mudança separa programadores iniciantes de engenheiros experientes.

O foco deixa de ser funcionalidade.

Passa a ser confiabilidade.


O que um desenvolvedor COBOL Jr deve fazer

Sempre pergunte:

O que pode dar errado?

Quem será impactado?

Existe limite operacional?

Existe validação?

Existe rollback?

Existe auditoria?

Existe monitoramento?

Existe aprovação?

Existe segregação?

Existe plano de contingência?

Se alguma resposta for "não sei", continue investigando.


A grande lição

Guard Rails não existem porque desenvolvedores são ruins.

Eles existem porque sistemas são complexos.

Quanto maior a empresa, mais perigoso se torna assumir que ninguém cometerá erros.

O verdadeiro papel da engenharia não é criar sistemas perfeitos.

É criar sistemas resilientes.

Sistemas que sobrevivam a erros humanos.

Sistemas que sobrevivam a falhas operacionais.

Sistemas que sobrevivam a decisões equivocadas.

No universo bancário, onde bilhões de reais transitam diariamente por programas COBOL escritos ao longo de décadas, essa diferença não é apenas uma questão técnica.

É uma questão de sobrevivência operacional.

E talvez a principal lição para qualquer desenvolvedor COBOL Jr seja esta:

Seu trabalho não é apenas fazer o programa funcionar.

Seu trabalho é impedir que ele cause danos quando inevitavelmente algo der errado.

Esse é o verdadeiro significado de Guard Rails.


Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...