☕ 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 Engenharia Reversa. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Engenharia Reversa. 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.

sexta-feira, 30 de maio de 2025

CASE Tools - Muito Além da Geração de Código: A Tecnologia que Mudou a Engenharia de Software para Sempre

 

Bellacosa Mainframe e os primeiros passos em Case Tools

☕ Um Café no Bellacosa Mainframe

CASE Tools

Muito Além da Geração de Código: A Tecnologia que Mudou a Engenharia de Software para Sempre

"As CASE Tools nunca tiveram como objetivo substituir programadores. Elas nasceram para transformar programação em Engenharia de Software. Quarenta anos depois, continuam influenciando praticamente todas as ferramentas modernas, da UML à Inteligência Artificial."


Introdução

Quando alguém fala em CASE Tools, é comum ouvir a resposta:

"Isso é tecnologia antiga."

Na realidade, poucas afirmações estão tão distantes da verdade.

As CASE Tools podem até não aparecer mais nas manchetes, mas seus conceitos continuam presentes em praticamente todas as plataformas modernas de desenvolvimento.

Se você utiliza:

  • UML;

  • Enterprise Architect;

  • IBM Application Discovery;

  • IBM Developer for z/OS;

  • GitHub Copilot;

  • IBM watsonx Code Assistant;

  • Low-Code;

  • No-Code;

  • DevOps;

  • Model Driven Engineering;

você está, direta ou indiretamente, utilizando ideias que nasceram há mais de quatro décadas.

Para quem trabalha com IBM Mainframe, compreender CASE Tools significa entender a origem da engenharia que permitiu a bancos, seguradoras e governos manterem sistemas críticos funcionando por décadas.


Afinal, o que são CASE Tools?

CASE significa:

Computer-Aided Software Engineering

ou

Engenharia de Software Assistida por Computador.

O objetivo nunca foi substituir programadores.

O objetivo sempre foi automatizar tarefas repetitivas da Engenharia de Software.

Em vez de começar escrevendo código, a ideia era começar criando modelos.

A partir desses modelos, as ferramentas poderiam gerar:

  • programas COBOL;

  • tabelas DB2;

  • layouts VSAM;

  • telas CICS;

  • documentação;

  • diagramas;

  • dicionários de dados;

  • especificações técnicas.

O código passava a ser consequência do projeto, não seu ponto de partida.


Por que elas surgiram?

Durante as décadas de 1970 e 1980 a indústria enfrentou a chamada Crise do Software.

Os computadores evoluíam rapidamente, mas os sistemas tornavam-se cada vez maiores e mais difíceis de manter.

Projetos atrasavam.

Custos aumentavam.

A documentação ficava desatualizada.

Mudanças simples provocavam erros inesperados.

As CASE Tools surgiram para trazer disciplina, padronização, rastreabilidade e reutilização ao desenvolvimento de software.


O grande diferencial

A maior inovação das CASE Tools não foi a geração automática de código.

Foi a criação de um repositório de conhecimento.

Nele eram armazenados:

  • processos;

  • entidades;

  • regras de negócio;

  • relacionamentos;

  • programas;

  • tabelas;

  • dependências;

  • documentação.

Hoje chamamos isso de metadados.

Na época, era uma revolução.


O papel no IBM Mainframe

Foi no Mainframe que as CASE Tools demonstraram todo o seu potencial.

Imagine uma instituição financeira com:

  • milhões de clientes;

  • milhares de transações CICS;

  • centenas de bancos DB2;

  • milhares de arquivos VSAM;

  • milhões de linhas de COBOL.

Sem uma visão integrada, compreender o impacto de uma simples alteração seria praticamente impossível.

As CASE Tools permitiram analisar dependências, gerar documentação, identificar impactos e padronizar o desenvolvimento, tornando viável a evolução contínua desses sistemas.


Elas desapareceram?

Não.

Mudaram de nome.

Os princípios continuam presentes em tecnologias modernas como:

  • UML;

  • Model Driven Development (MDD);

  • Model Driven Engineering (MDE);

  • Domain-Driven Design (DDD);

  • Low-Code;

  • No-Code;

  • DevOps;

  • Infrastructure as Code;

  • Inteligência Artificial aplicada ao desenvolvimento.

A engenharia baseada em modelos continua mais viva do que nunca.


O que isso significa para o programador COBOL?

Significa que escrever código já não é suficiente.

O profissional moderno precisa compreender:

  • arquitetura;

  • modelagem;

  • regras de negócio;

  • engenharia reversa;

  • análise de impacto;

  • documentação automática;

  • integração entre sistemas;

  • automação.

Quem domina esses conceitos consegue evoluir sistemas complexos com muito mais segurança.


Esta série completa

Para explorar esse universo em profundidade, preparamos uma série especial dividida em quatro artigos.

📘 Parte 1 — A origem das CASE Tools

Conheça a história da Crise do Software, o nascimento da Engenharia de Software, os primeiros CASE Tools e como surgiu a ideia de modelar sistemas antes de escrever código.

Você entenderá por que essa tecnologia foi considerada revolucionária e como ela mudou a forma de construir aplicações corporativas.

https://eljefemidnightlunch.blogspot.com/2025/01/case-tools-tecnologia-que-tentou.html


📗 Parte 2 — Upper CASE, Lower CASE e Integrated CASE

Descubra como funcionavam as diferentes categorias de CASE Tools.

Entenda conceitos como:

  • Upper CASE;

  • Lower CASE;

  • I-CASE;

  • Forward Engineering;

  • Reverse Engineering;

  • Round Trip Engineering;

  • Repositórios;

  • Dicionários de Dados;

  • Metodologias clássicas de Engenharia de Software.

É a base conceitual que influenciou praticamente todas as ferramentas modernas.

https://eljefemidnightlunch.blogspot.com/2025/02/case-tools-upper-case-lower-case-i-case.html


📙 Parte 3 — CASE Tools no IBM Mainframe

Veja como bancos, seguradoras e órgãos governamentais utilizaram CASE Tools para administrar enormes ambientes COBOL.

Conheça a relação dessas ferramentas com:

  • COBOL;

  • CICS;

  • DB2;

  • IMS;

  • VSAM;

  • JCL;

  • IBM Application Discovery (ADDI);

  • IBM Developer for z/OS;

  • CA Gen;

  • Enterprise Architect;

  • PowerDesigner.

Uma leitura indispensável para quem trabalha com IBM Z.

https://eljefemidnightlunch.blogspot.com/2025/03/case-tools-case-tools-no-ibm-mainframe.html


📕 Parte 4 — Das CASE Tools à Inteligência Artificial

Entenda por que Low-Code, No-Code, MDD, MDE, DDD, DevOps e Inteligência Artificial representam uma evolução natural dos princípios introduzidos pelas CASE Tools.

Descubra como ferramentas como o IBM watsonx Code Assistant e assistentes baseados em IA continuam seguindo a mesma filosofia: automatizar tarefas repetitivas para que os engenheiros concentrem seus esforços na solução dos problemas de negócio.

https://eljefemidnightlunch.blogspot.com/2025/04/case-tools-das-case-tools-inteligencia.html


O maior legado das CASE Tools

Talvez a maior contribuição das CASE Tools tenha sido mudar a forma como enxergamos o desenvolvimento de software.

Elas mostraram que sistemas complexos não sobrevivem por décadas apenas porque utilizam uma boa linguagem de programação.

Eles sobrevivem porque foram construídos sobre princípios sólidos de engenharia.

Modelagem.

Padronização.

Rastreabilidade.

Reutilização.

Documentação.

Governança.

Esses conceitos permanecem essenciais, independentemente da linguagem, da plataforma ou da tecnologia utilizada.


Conclusão

A história das CASE Tools é, na verdade, a história da própria Engenharia de Software moderna.

O nome pode ter desaparecido das apresentações comerciais, mas suas ideias continuam presentes em praticamente todas as tecnologias atuais.

Quando utilizamos UML, geramos APIs automaticamente, criamos pipelines DevOps, fazemos engenharia reversa de aplicações COBOL ou pedimos que uma Inteligência Artificial produza código, estamos ampliando um conceito que nasceu há mais de quarenta anos.

Para o profissional de IBM Mainframe, conhecer CASE Tools não significa estudar uma tecnologia do passado.

Significa compreender por que os sistemas que movimentam bancos, seguradoras, bolsas de valores e governos continuam evoluindo com segurança após décadas de operação.

A tecnologia muda.

As ferramentas mudam.

As linguagens mudam.

Mas a Engenharia de Software continua sendo o verdadeiro diferencial.

"Quem aprende apenas uma linguagem de programação constrói aplicações. Quem compreende Engenharia de Software constrói sistemas capazes de atravessar gerações. Esse sempre foi o legado das CASE Tools."

 

segunda-feira, 24 de março de 2025

CASE Tools : CASE Tools no IBM Mainframe – Parte III

 

Bellacosa Mainframe apresenta case tools parte III

☕ Um Café no Bellacosa Mainframe

CASE Tools – Parte 3

CASE Tools no IBM Mainframe

Como Bancos, Seguradoras e Governos Construíram Sistemas que Duram Décadas

"Quem olha apenas para milhões de linhas de COBOL imagina um oceano de código. Quem conhece as CASE Tools enxerga algo muito maior: um enorme mapa de conhecimento que permitiu manter esses sistemas vivos por décadas."


Introdução

Até agora vimos como nasceram as CASE Tools e como elas transformaram a Engenharia de Software.

Mas existe uma pergunta que muitos programadores COBOL fazem:

O que isso tem a ver com Mainframe?

A resposta é:

Tudo.

Na verdade, poucos ambientes aproveitaram tanto as CASE Tools quanto o IBM Mainframe.

Enquanto aplicações desktop normalmente possuíam dezenas de programas, um banco podia possuir:

  • 200.000 programas COBOL

  • milhares de transações CICS

  • milhares de Jobs

  • centenas de bancos DB2

  • milhares de arquivos VSAM

  • milhões de regras de negócio

Gerenciar tudo isso manualmente seria impossível.

Foi justamente aí que as CASE Tools encontraram seu ambiente ideal.


O Mainframe sempre foi uma plataforma de engenharia

Existe um mito curioso.

Muitas pessoas imaginam que o Mainframe nasceu para executar COBOL.

Na realidade, ele nasceu para executar negócios.

O COBOL é apenas um dos componentes.

Um sistema bancário normalmente envolve:

Usuários

↓

Canais Digitais

↓

APIs

↓

CICS

↓

Programas COBOL

↓

DB2

↓

VSAM

↓

IMS

↓

MQ

↓

Batch

↓

Relatórios

↓

Auditoria

Agora imagine documentar isso manualmente.

Quase impossível.


A explosão dos sistemas corporativos

Durante os anos 80 surgiram projetos gigantescos.

Bancos nacionais.

Seguradoras.

Previdência.

Telecomunicações.

Receita Federal.

INSS.

Grandes varejistas.

Cada organização possuía milhares de programas.

Um simples cadastro de cliente podia depender de centenas de componentes.


O problema da documentação

Imagine um programa COBOL chamado

CB0010

O que ele faz?

Ninguém sabe.

Agora imagine milhares deles.

CB0011

CB0012

CB0013

CB0014

...

CB8945

Sem documentação isso vira um pesadelo.

Foi exatamente esse cenário que impulsionou as CASE Tools.


O repositório virou o coração da empresa

As CASE Tools introduziram uma ideia revolucionária.

O conhecimento do sistema não deveria estar apenas no código.

Ele deveria existir em um repositório corporativo.

Nesse repositório eram registrados:

  • programas

  • tabelas

  • arquivos

  • transações

  • telas

  • menus

  • relacionamentos

  • processos

  • regras

  • usuários

  • departamentos

  • dependências

Hoje chamaríamos isso de metadados.

Na época era algo extremamente inovador.


Um programa nunca trabalha sozinho

Considere um simples saque em caixa eletrônico.

O cliente vê apenas uma tela.

Por trás dela, entretanto, ocorre uma verdadeira orquestra.

ATM

↓

API

↓

CICS

↓

COBOL

↓

DB2

↓

VSAM

↓

MQ

↓

Auditoria

↓

SMF

↓

Logs

Cada componente depende do outro.

Modificar apenas um pode afetar dezenas de sistemas.


É aqui que nasce a Análise de Impacto

Imagine alterar um campo.

CPF

↓

11 posições

↓

14 posições

O desenvolvedor pensa:

"É apenas um campo."

A CASE Tool responde:

Não.

Ela afeta:

  • 1.842 programas COBOL

  • 216 transações CICS

  • 437 Jobs

  • 52 Stored Procedures

  • 31 APIs

  • 418 telas

  • 97 relatórios

Esse tipo de informação vale milhões de reais em grandes instituições.


COBOL e CASE

Ao contrário do que muitos imaginam, CASE não substituía COBOL.

Ela produzia COBOL.

Por exemplo.

O analista modelava:

Cliente

Conta

Saldo

Extrato

A ferramenta podia gerar automaticamente:

  • Data Division

  • File Section

  • Working-Storage

  • SQL

  • CICS Commands

  • Skeleton do programa

O desenvolvedor implementava apenas as regras específicas.


O ganho de produtividade

Considere dois cenários.

Desenvolvimento tradicional

Analista

↓

Documento

↓

Programador

↓

COBOL

↓

Testes

↓

Documentação

Agora utilizando CASE.

Modelo

↓

Repository

↓

COBOL

↓

DB2

↓

Documentação

↓

Testes

Observe que várias atividades repetitivas desaparecem.


CASE e CICS

Imagine desenvolver uma nova transação.

Sem CASE.

Era necessário:

  • criar BMS Map;

  • definir transação;

  • programar COBOL;

  • criar documentação;

  • atualizar diagramas;

  • registrar dependências.

Com CASE.

Grande parte disso era produzida automaticamente.


CASE e DB2

Outro grande benefício.

Imagine criar uma nova entidade.

CLIENTE

A ferramenta poderia gerar:

CREATE TABLE CLIENTE

Depois.

Gerar automaticamente:

  • programa COBOL;

  • SQL;

  • cursores;

  • layouts;

  • documentação;

  • dicionário de dados.

Tudo sincronizado.


CASE e VSAM

Mesmo bancos que utilizavam VSAM eram beneficiados.

A ferramenta conhecia:

  • KSDS

  • ESDS

  • RRDS

  • campos

  • chaves

  • índices

  • layouts

Se um campo aumentasse de tamanho.

Todo o ambiente poderia ser atualizado.


CASE e IMS

O mesmo acontecia com IMS.

Imagine modificar um segmento.

A CASE Tool informava imediatamente:

  • DBD

  • PSB

  • Programas COBOL

  • Batchs

  • Transações IMS/DC

Tudo relacionado.


CASE e JCL

Pouca gente lembra.

Mas diversas CASE Tools também geravam JCL.

Por exemplo.

Após criar um novo programa.

Ela podia produzir automaticamente.

  • Compile JCL

  • Link-edit

  • Bind DB2

  • Execução Batch

  • Testes

Hoje pipelines de DevOps fazem exatamente isso.


CASE e documentação

Um dos maiores custos da TI sempre foi manter documentação atualizada.

Imagine alterar um campo.

Sem CASE.

Era necessário atualizar:

  • documento funcional;

  • documento técnico;

  • layout;

  • diagrama;

  • especificação;

  • manual.

Com CASE.

Tudo era atualizado automaticamente.


Engenharia Reversa em Mainframe

Imagine um banco comprado por outro banco.

O novo proprietário encontra.

27 milhões

de linhas COBOL

Sem documentação.

Como entender?

A solução.

Reverse Engineering.

Ferramentas analisam:

  • COBOL

  • JCL

  • CICS

  • DB2

  • VSAM

  • IMS

  • MQ

Depois produzem.

  • diagramas

  • mapas

  • dependências

  • arquitetura

Hoje isso continua acontecendo.


IBM AD — O sucessor moderno

Uma das ferramentas mais conhecidas atualmente é o

IBM Application Discovery and Delivery Intelligence (IBM ADDI).

Ela faz exatamente o que as antigas CASE Tools faziam.

Por exemplo.

Analisa:

  • COBOL

  • PL/I

  • JCL

  • Easytrieve

  • Assembler

  • CICS

  • IMS

  • DB2

Depois constrói um enorme mapa de dependências.

É uma CASE Tool moderna.

Embora o nome tenha mudado.


IBM Developer for z/OS

O IDz também herdou diversos conceitos CASE.

Ele permite:

  • navegação entre programas;

  • referências cruzadas;

  • análise de chamadas;

  • impacto;

  • documentação;

  • integração Git.

Não é apenas uma IDE.

É uma ferramenta de engenharia.


Rational Rose

Durante muitos anos.

Foi praticamente sinônimo de UML.

Diversas empresas modelavam sistemas inteiros.

Depois implementavam COBOL.

Java.

C++.

PL/I.

Tudo a partir desses modelos.


Enterprise Architect

Ainda hoje é uma das ferramentas preferidas para arquitetura corporativa.

Permite modelar:

  • processos;

  • aplicações;

  • infraestrutura;

  • APIs;

  • bancos de dados.

É um descendente direto da filosofia CASE.


CA Gen

Talvez o exemplo mais famoso.

Antigamente chamado

Texas Instruments IEF.

Depois

COOL:Gen.

Mais tarde

CA Gen.

Ele conseguia gerar aplicações corporativas completas.

Milhares de sistemas bancários nasceram dessa ferramenta.

Muitos continuam em produção.


Oracle Designer

Muito utilizado em ambientes Oracle.

Gerava:

  • banco;

  • forms;

  • reports;

  • documentação;

  • SQL.

Outro exemplo clássico de CASE.


PowerDesigner

Muito conhecido entre DBAs.

Excelente para:

  • modelagem;

  • engenharia reversa;

  • documentação;

  • impacto.

Continua extremamente utilizado.


O que mudou com DevOps?

Muitos acreditam que DevOps substituiu CASE.

Na realidade.

DevOps automatiza outra parte do processo.

CASE automatiza engenharia.

DevOps automatiza entrega.

Os dois se complementam.

Veja.

CASE

↓

Modelo

↓

Código

↓

Git

↓

Pipeline

↓

Testes

↓

Deploy

Hoje eles trabalham juntos.


E a Inteligência Artificial?

A IA trouxe uma nova camada.

Antes.

O modelo gerava código.

Hoje.

O engenheiro descreve um requisito.

A IA cria:

  • código;

  • documentação;

  • testes;

  • diagramas.

Mas existe uma diferença importante.

A CASE conhecia toda a arquitetura.

A IA normalmente conhece apenas o contexto fornecido.

Quando ambas trabalham juntas, os resultados são muito mais consistentes.


O impacto na carreira do programador COBOL

Há vinte anos, conhecer apenas COBOL era suficiente para muitos projetos.

Hoje, o profissional mais valorizado entende também:

  • arquitetura corporativa;

  • modelagem;

  • engenharia reversa;

  • análise de impacto;

  • documentação automática;

  • pipelines de DevOps;

  • APIs;

  • governança de software.

Essas competências tornam o desenvolvedor capaz de evoluir sistemas críticos sem comprometer sua estabilidade.


Como um banco moderno trabalha

Imagine a solicitação:

"Adicionar PIX Internacional."

O processo raramente começa pelo código.

Normalmente segue um fluxo semelhante:

Requisito

↓

Modelagem

↓

Impacto

↓

Arquitetura

↓

Análise CASE

↓

COBOL

↓

Testes

↓

Produção

Observe que programar representa apenas uma etapa.

As CASE Tools ensinaram exatamente isso.


O futuro do Mainframe

Muito se fala em modernização.

Mas modernizar não significa reescrever tudo.

Na maioria das vezes significa:

  • compreender;

  • documentar;

  • medir impactos;

  • expor APIs;

  • integrar novas tecnologias;

  • preservar regras de negócio.

E isso sempre foi a essência das CASE Tools.


Lições para o programador COBOL

Se você trabalha com Mainframe, algumas conclusões são inevitáveis:

  • O código é apenas uma parte do sistema.

  • A documentação deve refletir a realidade do ambiente.

  • Toda alteração precisa ser analisada antes da implementação.

  • Modelagem reduz riscos e facilita a manutenção.

  • Ferramentas de engenharia aumentam produtividade sem substituir o desenvolvedor.

  • Sistemas legados bem documentados tornam-se ativos estratégicos para a organização.

  • IA e CASE não competem; juntas, ampliam a capacidade dos engenheiros de software.


Conclusão

O IBM Mainframe foi um dos maiores laboratórios da Engenharia de Software corporativa. Em ambientes onde um erro pode interromper pagamentos, comprometer milhões de clientes ou afetar serviços essenciais, improvisação nunca foi uma opção.

Foi nesse contexto que as CASE Tools encontraram seu maior valor. Elas transformaram conhecimento em modelos, modelos em código, código em documentação e documentação em governança.

Embora muitas ferramentas clássicas tenham desaparecido ou mudado de nome, seus princípios permanecem vivos em soluções como IBM ADDI, IBM Developer for z/OS, Enterprise Architect, PowerDesigner e em plataformas modernas de DevOps e Inteligência Artificial.

Para o programador COBOL, compreender CASE não é estudar uma tecnologia antiga. É entender como grandes organizações conseguem manter aplicações críticas evoluindo por décadas com segurança, rastreabilidade e qualidade.

No próximo artigo encerraremos esta série explorando a evolução das CASE Tools para Low-Code, No-Code, Model Driven Development (MDD), Model Driven Engineering (MDE) e Inteligência Artificial, mostrando por que a automação da engenharia de software continua mais relevante do que nunca.

"As melhores ferramentas nunca tiveram como objetivo substituir engenheiros. Elas existem para que os engenheiros gastem menos tempo repetindo tarefas e mais tempo resolvendo problemas que realmente importam. Essa era a missão das CASE Tools ontem. Continua sendo a missão da Inteligência Artificial hoje."

 

terça-feira, 3 de dezembro de 2024

☕ O Padawan COBOL e o Holocron da Modernização: Como Ir Mais Longe na Era da IA Generativa e do IBM Z

 

Bellacosa Mainframe e a modernização do cobol 

☕ O Padawan COBOL e o Holocron da Modernização: Como Ir Mais Longe na Era da IA Generativa e do IBM Z

"O Mainframe nunca foi uma caixa preta. Apenas faltava um Jedi suficientemente paciente para abrir seus antigos holocrons."

Introdução – O fim da Era dos Guardiões do Conhecimento

Durante décadas, trabalhar em Mainframe significava conviver com uma estranha forma de magia corporativa.

Existiam sistemas que processavam bilhões de reais por dia.

Aplicações escritas em COBOL desde os anos 80.

Jobs executados religiosamente às 02h17 da manhã.

Mapsets BMS que ninguém ousava modificar.

Programas chamados por outros programas chamados por outros programas, formando árvores de dependências dignas da genealogia dos Skywalker.

E quase sempre existia uma figura lendária.

O Analista Sênior.

O último guardião.

Aquele profissional capaz de responder perguntas como:

"Quem atualiza a tabela CLIENTE_MASTER?"

"Onde está implementada a regra do IOF?"

"O que acontece se removermos esse copybook?"

Era comum ouvir:

— Pergunta para o João.

— O João aposentou.

— Então pergunta para o Carlos.

— O Carlos foi para Portugal.

— E agora?

Silêncio.

Era o medo ancestral do Mainframe.

A crença de que o IBM Z era uma espécie de monólito indecifrável.

Uma caixa preta.

Mas isso nunca foi verdade.


O Mainframe Nunca Foi uma Caixa Preta

Na realidade, poucas plataformas possuem tanta capacidade de introspecção quanto um ambiente z/OS.

Ele produz informações em praticamente todos os níveis:

SMF

RMF

JES2

SDSF

RACF

Catalogs

DB2 Catalog

CICS Statistics

MQ Accounting

Endevor Metadata

SMP/E CSI

DFSMS

Workload Manager

OMEGAMON

Fault Analyzer

Abend-AID

IBM ADDI

A informação sempre esteve disponível.

O problema era outro.

O problema era cognitivo.

Imagine um ambiente com:

7.000 programas COBOL

3.000 copybooks

2.000 jobs

1.000 BMS

400 tabelas DB2

600 transações CICS

40 anos de evolução contínua

Nenhum ser humano consegue manter isso completamente em memória.

Nem mesmo o Sysprog Jedi mais experiente.


A IA Não Substitui Especialistas

Ela Amplifica Especialistas

Talvez a frase mais importante de toda essa discussão seja:

AI didn't replace my Mainframe expertise — it amplified it.

Concordo integralmente.

Uma IA não sabe o que é importante.

Ela não conhece a história da empresa.

Não participou do go-live de 1998.

Não sabe que determinado programa falha sempre no fechamento anual.

Não conhece as gambiarras feitas durante a fusão de bancos.

Mas ela consegue fazer algo extraordinário.

Ela consegue ler.

Muito.

Muito rápido.

E muito consistentemente.


O Novo Poder do Padawan COBOL

Antigamente um profissional iniciante precisava de anos para compreender um ambiente corporativo.

Hoje ele pode construir um verdadeiro Holocron Digital.

Utilizando Python.

IA.

Grafos.

Vetorização.

LLMs.

Neo4J.

RAG.

OpenSearch.

Elastic.

SQLite.

HTML.

Excel.

PowerBI.

VS Code.

Zowe.

GitHub.

Jupyter.

Claude.

ChatGPT.

Copilot.

Gemini.


Primeira Missão do Padawan

Mapear o universo.

Escanear diretórios Endevor.

Analisar fontes.

Identificar relacionamentos.

Exemplo:

glob("**/*.cbl")
glob("**/*.cpy")
glob("**/*.bms")
glob("**/*.jcl")

A primeira descoberta será surpreendente.

O sistema não é um monstro.

Ele possui estrutura.


Construindo um Grafo de Conhecimento Mainframe

Imagine um programa.

COB001

Utiliza:

COPY CLIENTE

Executa:

CALL PGM002

Atualiza:

TB_CLIENTE

Executado por:

JOBD001

Exposto em:

TXN001

Visualmente:

COB001

├──COPY CLIENTE

├──CALL PGM002

├──TB_CLIENTE

├──JOBD001

└──TXN001

Agora multiplique isso por oito mil programas.

Você terá um mapa navegável da aplicação.

Algo que nem sempre existiu em muitas empresas.


O Que a IA Faz Melhor

A IA possui uma capacidade extremamente interessante.

Ela consegue enriquecer metadados.

Exemplo:

Código:

EXEC SQL

SELECT SALDO

FROM CONTA

END-EXEC

Descrição gerada:

"Programa responsável pela consulta de saldo de conta corrente."


Outro exemplo:

PERFORM CALCULAR-IOF

Descrição:

"Módulo fiscal associado ao cálculo de imposto financeiro."


Isso parece simples.

Mas representa uma mudança gigantesca.

Porque documentação técnica sempre foi um dos maiores problemas do Mainframe.


O Próximo Passo: RAG para IBM Z

Imagine indexar:

COBOL

JCL

BMS

Copybooks

SQL

SMF

MQ

CICS

SDSF

JESMSGLG

Procs

Control-M

CA7

IZWS

Tudo em um banco vetorial.

Agora pergunte:

"Quem calcula IOF?"

Resposta:

PGMIOF01

COPY FISCAL

TBIMPOSTO

JOBFECH

TXNIOF

Tempo:

3 segundos.


Agentes Especializados

A próxima geração provavelmente terá agentes dedicados.

COBOL Agent

Explica código.


DB2 Agent

Analisa SQL.


CICS Agent

Entende transações.


Batch Agent

Mapeia dependências.


RACF Agent

Audita segurança.


MQ Agent

Encontra integrações.


IMS Agent

Talvez o mais difícil de todos.


O Que o Padawan Deve Aprender

Muitos iniciantes acreditam que modernização significa reescrever COBOL em Java.

Esse talvez seja um dos maiores equívocos da indústria.

Modernização significa compreender.

Documentar.

Inventariar.

Reduzir riscos.

Automatizar.

Expor APIs.

Criar observabilidade.

Produzir conhecimento.

O código COBOL pode permanecer.

E muitas vezes deve permanecer.

O que precisa mudar é a forma como interagimos com ele.


O Kit de Ferramentas do Padawan Moderno

Aprenda:

Python

Pandas

OpenPyXL

NetworkX

Neo4J

Graphviz

FAISS

LangChain

RAG

Prompt Engineering

VS Code

Zowe CLI

Git

GitHub Actions

Ansible for z/OS

OpenTelemetry

REST APIs

JSON

YAML

Docker

MCP

Agentes de IA

DB2 Catalog

SMF

RMF

CICS Statistics


Conselhos de um Mestre Bellacosa para um Padawan COBOL

Nunca tenha vergonha de usar IA.

Tenha vergonha apenas de aceitar respostas sem questionar.

A IA erra.

Mas ela erra rápido.

E permite aprender rápido.

Aprenda a fazer perguntas melhores.

Aprenda a decompor problemas.

Aprenda a pensar como arquiteto.

Não seja apenas um codificador COBOL.

Seja um arqueólogo digital.

Um cartógrafo do legado.

Um construtor de grafos.

Um guardião das regras de negócio.

O mercado não precisa de mais pessoas capazes apenas de escrever um PERFORM UNTIL EOF.

O mercado precisa de profissionais capazes de conversar com cinquenta anos de história computacional e transformá-los em conhecimento acessível para a próxima geração.

E talvez essa seja a maior revolução silenciosa da IA no Mainframe.

Ela não está aposentando os mestres.

Está permitindo que novos Padawans encontrem, estudem e compreendam os antigos holocrons corporativos antes que eles desapareçam para sempre.

Porque, no fim das contas, modernizar Mainframe nunca foi destruir o legado.

Sempre foi aprender a enxergá-lo com novos olhos.


domingo, 7 de janeiro de 2024

Magic Maker: COBOL, Ciência e o Dia em que Descobrimos que Magia Era Apenas uma API sem Documentação

 

Bellacosa Mainframe magic maker e a ciencia do dia api cobol

☕ Um Café no Bellacosa Mainframe

Magic Maker: COBOL, Ciência e o Dia em que Descobrimos que Magia Era Apenas uma API sem Documentação

🪄 Quando Shion encontrou um fenômeno estranho, fez aquilo que todo programador experiente faria: desconfiou da documentação. O problema é que não havia documentação.

Existe uma regra não escrita da informática corporativa:

se alguma coisa funciona há tempo suficiente, eventualmente ninguém mais saberá explicar por quê.

O programa está lá.

Compila.

Executa toda madrugada.

Recebe um arquivo de 14 milhões de registros.

Abre um VSAM que alguém criou quando Michael Jackson ainda lançava discos.

Consulta uma tabela Db2 cujo nome começa com TBHIST.

Chama três módulos COBOL.

Um deles possui comentário de 1997 dizendo:

      * ALTERADO CONFORME SOLICITACAO DO USUARIO.
      * NAO REMOVER ESTA VALIDACAO.

Qual usuário?

Qual solicitação?

Por que não remover?

Ninguém sabe.

Mas você remove?

Nem morto.

Agora imagine a situação inversa.

Você chega a um sistema gigantesco, encontra evidências de que existe uma funcionalidade extraordinária escondida em algum lugar, mas ninguém sequer sabe que ela existe.

Não existe manual.

Não existe README.

Não existe Swagger.

Não existe Javadoc.

Não existe copybook.

Não existe runbook.

Não existe um veterano chamado Cláudio sentado no canto da sala dizendo:

“Ah, isso aí foi o Marcão que fez em 1988.”

Nada.

Você possui apenas o fenômeno.

Uma espécie de resposta produzida pelo sistema.

E precisa descobrir:

qual é a API?

Essa, camaradas, é uma maneira deliciosamente nerd de enxergar Magic Maker: Isekai Mahou no Tsukurikata.

Shion não chegou a um mundo sem magia.

Talvez essa seja nossa primeira interpretação errada.

Ele chegou a um mundo onde a magia existia como fenômeno, mas ainda não existia como tecnologia.

E essa diferença muda tudo.


🧙‍♂️ MAGIC NOT FOUND

A premissa é quase uma piada pronta.

Nosso protagonista sempre sonhou com magia.

Morre.

Reencarna em outro mundo.

Olha em volta.

Fantasia medieval.

Campo.

Espadas.

Castelos.

Tudo certo.

Agora só falta aparecer alguém dizendo:

Fireball!

Nada.

Shion começa a investigar e percebe algo absurdo:

as pessoas daquele mundo não conhecem magia.

Se fosse um isekai convencional, abriria uma tela:

WELCOME, SHION!

CLASS: ARCHMAGE
LEVEL: 1
MANA: 999999
SPECIAL SKILL:
[CREATION MAGIC SSS+]

Obrigado por jogar.

Mas Magic Maker escolhe um caminho mais interessante.

Shion recebe praticamente:

IEF450I MAGIC JOB FAILED
SYSTEM COMPLETION CODE=0C4

MAGIC FACILITY NOT AVAILABLE

E então surge a pergunta fundamental:

E se magia não estiver ausente?
E se ninguém simplesmente descobriu como utilizá-la?

O programador COBOL imediatamente levanta uma sobrancelha.

Ahhhhh.

Agora temos um problema interessante.


🔬 1. A diferença entre fenômeno e tecnologia

Relâmpagos existiam antes de Benjamin Franklin.

Magnetismo existia antes de alguém construir um motor elétrico.

Ondas eletromagnéticas existiam antes do rádio.

Urânio era radioativo antes de Becquerel.

Microrganismos existiam antes de Leeuwenhoek olhar através de suas lentes.

A natureza não esperou nossa documentação para funcionar.

Nós é que demoramos para compreender a interface.

Isso nos leva a uma ideia fundamental:

Uma coisa pode existir muito antes de alguém descobrir como controlá-la.

Em Magic Maker, Shion começa justamente aí.

Ele observa fenômenos.

Luzes.

Energia.

Comportamentos estranhos.

E começa a perguntar.

O QUE É ISSO?
       ↓
QUANDO ACONTECE?
       ↓
POR QUE ACONTECE?
       ↓
POSSO REPETIR?
       ↓
POSSO CONTROLAR?
       ↓
POSSO ENSINAR?

Observe a transformação.

Quando acontece espontaneamente:

fenômeno.

Quando conseguimos reproduzir:

experimento.

Quando entendemos parcialmente:

conhecimento.

Quando conseguimos controlar:

tecnologia.

Quando outra pessoa consegue repetir:

engenharia.

E quando criamos um manual de 1.842 páginas que ninguém lê:

produto IBM.

😆


🧪 2. Shion inventou o laboratório antes de inventar a magia

Essa é uma das coisas que mais gosto conceitualmente em Magic Maker.

Shion não precisa descobrir apenas magia.

Ele precisa descobrir como descobrir magia.

Parece uma diferença pequena.

Não é.

Imagine receber uma caixa preta.

Existe uma entrada.

Existe uma saída.

Você não possui código-fonte.

Então começa:

INPUT A → OUTPUT X
INPUT B → OUTPUT X
INPUT C → OUTPUT Y
INPUT C + TEMPERATURA → OUTPUT Z

Você anota.

Repete.

Altera uma variável.

Observa.

Tenta novamente.

Parabéns.

Você acabou de começar uma engenharia reversa.

É exatamente o que Shion faz com seu universo.

A natureza é o mainframe.

A magia é uma rotina escondida.

E Shion está tentando descobrir o CALL.

       CALL 'MAGIC001'
           USING WS-INTENCAO
                 WS-ENERGIA
                 WS-ALVO
                 WS-RESULTADO.

Problema:

ninguém possui o copybook.

😂


🧠 3. O maior superpoder de Shion não é magia

Aqui mora uma sutileza maravilhosa.

O maior poder que Shion trouxe de nosso mundo talvez não seja conhecimento científico específico.

É uma coisa muito mais simples:

ele sabe que magia deveria ser possível.

Parece bobagem.

Mas pense.

Duas pessoas observam uma luz estranha sobre um lago.

Pessoa A:

Bonito.

Pessoa B:

O que produz isso?

Pessoa A:

Sei lá. Sempre acontece.

Pessoa B:

Sempre quando?

Pessoa A:

À noite.

Pessoa B:

Com determinada temperatura?

Pessoa A:

Nunca pensei nisso.

Pessoa B:

Acontece em outro lago?

Pessoa A:

Nunca procurei.

Pessoa B:

Podemos capturar?

Pessoa A:

Para quê?!

Essa última pergunta é maravilhosa.

Para quê?

Porque grande parte das descobertas começa antes de existir uma utilidade.


☕ 4. A curiosidade é uma transação sem business case

Aqui entramos numa área perigosíssima para qualquer departamento financeiro.

Imagine Shion apresentando o projeto.

Projeto MAGIC

Objetivo: descobrir se existe uma forma desconhecida de energia.

ROI previsto: desconhecido.

Prazo: desconhecido.

Aplicações comerciais: desconhecidas.

Probabilidade de sucesso: desconhecida.

Orçamento: precisamos descobrir.

O gerente fecha a apresentação.

Reprovado.

😂

Esse é um problema histórico da pesquisa básica.

Quando Faraday estudava eletricidade, ninguém poderia apresentar um PowerPoint mostrando:

ROADMAP

1831 — Indução eletromagnética
1879 — Lâmpadas comerciais
1947 — Transistor
1971 — Microprocessador
1981 — IBM PC
2007 — Smartphone
2026 — IA discutindo anime com COBOLzeiro

O futuro não fornece documentação antecipada.

Primeiro alguém pergunta.

Depois descobrimos para que serve.

Shion é movido inicialmente por algo tremendamente humano:

curiosidade.

Ele quer magia porque magia é fascinante.

E isso basta para começar.


⚙️ 5. O primeiro MVP mágico

Depois de observar e experimentar, eventualmente algum fenômeno torna-se reproduzível.

Temos então algo equivalente ao:

Hello World da magia.

Todo programador conhece esse momento.

Você instala uma linguagem.

Configura ambiente.

Cria projeto.

Compila.

Hello World

Tecnicamente inútil.

Emocionalmente gigantesco.

Porque significa:

a cadeia inteira funciona.

Compilador.

Runtime.

Bibliotecas.

Ambiente.

Execução.

Saída.

Na magia ocorre a mesma coisa.

O primeiro fenômeno controlado pode ser pequeno.

Mas prova uma hipótese colossal:

humanos conseguem interferir conscientemente nesse sistema.

Pronto.

Acabou.

O mundo mudou.

Só ainda não sabe.


📚 6. Da descoberta para a API

Agora chegamos ao nosso título.

Uma API é uma interface.

Você não precisa necessariamente saber tudo que acontece internamente.

Precisa conhecer:

entrada, contrato, comportamento e saída.

Imagine que Shion descubra:

INTENÇÃO
+
CONCENTRAÇÃO
+
ENERGIA MÁGICA
+
MÉTODO
=
EFEITO

Temos praticamente:

POST /magic/fire

{
   "mana": 20,
   "target": "goblin",
   "intensity": 5
}

Resposta:

HTTP/1.1 200 OK

{
   "spell": "fire",
   "status": "success"
}

Mas como todo desenvolvedor sabe, o inferno começa nos casos excepcionais.

400 BAD REQUEST

Concentração inválida.

401 UNAUTHORIZED

Usuário não possui habilidade.

429 TOO MANY REQUESTS

Mana esgotada.

500 INTERNAL MAGIC ERROR

Você transformou acidentalmente o galinheiro em antimateria.

😆


🧯 7. E alguém precisa descobrir os limites

Todo sistema possui limites.

É uma das diferenças entre fantasia infantil e engenharia.

Engenharia pergunta:

quanto?

Quanto processamento?

Quanto armazenamento?

Quantas transações?

Quantos usuários simultâneos?

Quanto tempo?

Qual intensidade?

Qual temperatura?

Qual tolerância?

Qual taxa de erro?

Shion começa a fazer perguntas semelhantes sobre magia.

Quanto consigo produzir?

Quantas vezes?

Qual o custo físico?

Quanto tempo preciso recuperar?

O que acontece quando ultrapasso o limite?

De repente surge algo semelhante a:

MAGICAL CAPACITY PLANNING

E aqui um sysprog começa a sorrir.

Porque descobrimos o WLM da magia.

😂

Não basta possuir recurso.

É preciso gerenciá-lo.


🏥 8. Quando o brinquedo vira sistema crítico

Então Magic Maker faz algo importante.

A magia deixa de ser brincadeira.

Surge doença.

Surgem pessoas precisando daquela descoberta.

Nesse momento Shion atravessa uma fronteira ética.

Antes:

“Vamos tentar isso para ver o que acontece.”

Agora:

“Se eu errar, alguém pode sofrer.”

Bem-vindo aos sistemas críticos.

Um SOC7 num programa de treinamento é aprendizado.

Um SOC7 processando folha salarial às quatro da manhã é incidente.

Um erro num jogo pode derrubar seu personagem.

Um erro num sistema hospitalar pode afetar uma pessoa real.

A tecnologia é a mesma.

A responsabilidade mudou.


⚠️ 9. A descoberta cria responsabilidade

Existe uma mensagem escondida muito interessante aí.

Enquanto Shion é o único capaz de fazer alguma coisa, existe uma dependência enorme.

Chamamos isso em TI de:

bus factor = 1.

Ou, no dialeto Bellacosa:

Se Shion for atropelado pela carroça amanhã, acabou a magia?

😆

Esse é um problema sério.

Se sim, ele não criou uma tecnologia.

Criou uma habilidade pessoal.

Para virar tecnologia de verdade, magia precisa sair da cabeça de Shion.

Precisa existir:

DOCUMENTAÇÃO
     ↓
TREINAMENTO
     ↓
REPETIBILIDADE
     ↓
PADRONIZAÇÃO
     ↓
NOVOS PRATICANTES

Isso talvez seja ainda mais importante do que lançar feitiços.


🧙‍♀️ 10. Marie é a primeira homologação

E aqui Marie assume um papel conceitualmente delicioso.

Ela não é simplesmente “a irmã do protagonista”.

Marie representa o primeiro teste fundamental:

outra pessoa consegue compreender aquilo que Shion descobriu?

Se apenas Shion consegue produzir magia:

FEATURE

Se Marie consegue:

PROOF OF CONCEPT

Se dez pessoas conseguem:

TECHNOLOGY

Se dez mil conseguem:

INFRASTRUCTURE

Se ninguém sabe mais quem inventou:

LEGACY

😂


🏛️ 11. O momento em que magia vira legado

Agora vamos avançar cem anos.

Shion morreu.

Marie virou personagem histórica.

Existem escolas de magia.

Há especialistas.

Feitiços possuem classificação.

Existem normas.

Bibliotecas.

Departamentos.

Certificações.

Provavelmente teremos:

Certified Magic Professional Level 1.

Depois:

Magic Solution Architect.

Depois alguém cria:

Agile Magic Practitioner.

Pronto.

Destruíram tudo.

😂

Mas então surge uma nova geração.

Um jovem mago olha um encantamento ancestral:

MAGIC-CURE-LEGACY-V17

São 34 páginas de símbolos.

Ele reclama:

Por que essa porcaria é tão complicada?

Outro responde:

Foi Shion quem fez.

— Quem?

— Um mago antigo.

— Vamos reescrever.

🚨🚨🚨

NÃO!

Porque ninguém lembra que naquela linha aparentemente inútil existe uma validação criada durante a epidemia da Doença da Letargia.

E finalmente fechamos o círculo.

A magia de Shion virou...

COBOL.


🧓 12. O verdadeiro mago é o veterano

Imagine Shion aos 75 anos.

Chega um jovem arquiteto.

— Senhor Shion, vamos modernizar a plataforma mágica.

Shion olha desconfiado.

— Como?

— Microservices.

— De magia?

— Sim.

— Por quê?

— Escalabilidade.

— Quantos feitiços vocês executam?

— Quarenta por dia.

Silêncio.

— E vocês precisam de Kubernetes para isso?

😂😂😂

Shion pega café.

A reunião acabou.


🔐 13. E ninguém pensou na segurança

Porque todo inventor eventualmente descobre outra regra universal:

Se uma tecnologia pode fazer algo útil, alguém tentará utilizá-la para fazer alguma besteira.

Magia cura?

Pode ferir.

Produz energia?

Pode destruir.

Move objetos?

Pode roubar.

Influencia matéria?

Pode virar arma.

Portanto, depois da descoberta inevitavelmente chegará:

MAGIC SECURITY FRAMEWORK

Precisamos de autenticação.

Autorização.

Auditoria.

Logs.

Segregação de funções.

Princípio do menor privilégio.

Shion acaba inventando o:

RACF mágico.

PERMIT FIREBALL
       CLASS(SPELL)
       ID(MARIE)
       ACCESS(READ)

Marie:

— READ?!

Shion:

— Ainda não confio em você com UPDATE.

😂


🧬 14. Ciência não é conhecer todas as respostas

Outra bela mensagem de Magic Maker é uma coisa que frequentemente esquecemos.

Ciência não significa:

“Eu sei.”

Frequentemente significa:

“Eu não sei, mas sei como investigar.”

Essa diferença é monumental.

Shion não possui respostas.

Possui método.

E método é extremamente poderoso.

não sei
   ↓
observo
   ↓
formulo hipótese
   ↓
experimento
   ↓
erro
   ↓
aprendo
   ↓
repito

O fracasso deixa de ser oposição ao conhecimento.

Torna-se parte do processo.


💥 15. MAXCC=0008 também ensina

Programadores antigos sabem disso.

Às vezes o erro ensina mais do que o sucesso.

Quando tudo funciona:

ótimo.

Quando quebra:

por quê?

Você abre log.

Dump.

SYSOUT.

CEEDUMP.

Abend-AID.

Fault Analyzer.

SMF.

Descobre algo que não sabia sobre o sistema.

Shion faz exatamente isso com seu universo.

Cada experimento fracassado elimina hipóteses.

Portanto:

FAILURE != NOTHING

Fracasso experimental produz informação.

Isso é ciência.

Isso também é debugging.


🌍 16. E então aparece a consequência que ninguém planejou

Imagine novamente cem anos depois.

Shion queria simplesmente fazer magia.

Mas sua descoberta produz:

escolas mágicas, profissões, medicina mágica, agricultura mágica, armas mágicas, transporte mágico, comunicação mágica, indústria mágica.

Ele criou uma tecnologia de propósito geral.

Isso aconteceu conosco várias vezes.

Eletricidade.

Computadores.

Internet.

IA.

Cada uma começou resolvendo determinados problemas e depois alterou sistemas inteiros.

O inventor perde controle sobre todas as aplicações futuras.

Essa é uma mensagem enorme escondida dentro da fantasia:

inventar alguma coisa significa liberar possibilidades que você talvez jamais consiga prever.


🤖 17. E chegamos inevitavelmente à Inteligência Artificial

Há uma semelhança interessante com nosso momento atual.

Durante décadas, IA era pesquisa.

Depois começou a funcionar melhor.

Depois saiu do laboratório.

Depois chegou aos produtos.

Depois chegou ao público.

Agora estamos discutindo:

segurança, ética, emprego, educação, copyright, autonomia, agentes, governança, auditoria e legislação.

Ou seja:

descobrir que alguma coisa funciona é apenas o começo da história.

Shion descobre magia.

Nossa primeira reação é:

Fantástico!

A pergunta seguinte deveria ser:

E agora?

Quem pode usar?

Quem ensina?

Quem controla?

Quem responde pelo erro?

Quem define limites?

Quem audita?

Quem recebe acesso?

E quem aperta o botão vermelho?


🥚 Easter Egg: MAGIC.PROD

Alguns anos depois, Shion finalmente cria três ambientes:

MAGIC.DEV
MAGIC.HML
MAGIC.PROD

Marie entra na sala.

— Shion, preciso testar um feitiço.

— DEV.

— Mas é rapidinho.

— DEV.

— Só quero ver se funciona.

— DEV.

— Posso testar aqui mesmo.

— MARIE.

— O quê?

Shion lentamente vira a cadeira.

Ninguém testa magia em produção.

Marie revira os olhos.

Cinco minutos depois:

ICH408I USER(MARIE)
SPELL(FIREBALL)
ACCESS INTENT(UPDATE)
ACCESS ALLOWED(NONE)

Shion havia finalmente criado a maior invenção daquele mundo.

Não era magia.

Era controle de acesso.

😂


☕ 18. No fim, Magic Maker fala sobre nós

É por isso que gosto tanto da premissa.

Retire:

castelos, monstros, reencarnação, fantasia e feitiços.

O que sobra?

Um sujeito curioso encontra algo que ninguém compreende.

Ele pergunta.

Observa.

Experimenta.

Falha.

Repete.

Descobre.

Aplica.

Ensina.

E transforma conhecimento individual em conhecimento coletivo.

Essa história aconteceu milhares de vezes na humanidade.

O fogo.

Metalurgia.

Agricultura.

Escrita.

Matemática.

Navegação.

Máquina a vapor.

Eletricidade.

Computação.

Internet.

Inteligência Artificial.

Toda tecnologia suficientemente madura parece óbvia para quem nasceu depois dela.

Uma criança toca uma tela e conversa instantaneamente com alguém do outro lado do planeta.

Não parece milagre.

É rotina.

Mas mostre um smartphone para alguém de 1726.

Você será o mago.


🪄 O segredo nunca foi a magia

Talvez essa seja a grande mensagem de Magic Maker.

Shion não é especial simplesmente porque consegue produzir magia.

Ele é especial porque olhou para alguma coisa que todos viam e fez uma pergunta diferente.

E existe uma enorme diferença entre:

“Isso não existe.”

e:

“Ainda não descobrimos como fazer.”

A primeira frase encerra uma investigação.

A segunda começa uma aventura.

É assim que ciência avança.

É assim que engenharia avança.

É assim que programação avança.

E talvez seja assim que civilizações avancem.


🖥️ Epílogo — 40 anos depois

Um jovem aprendiz encontra Shion numa sala escura.

Há grimórios empilhados por toda parte.

Cristais piscam nas paredes.

No centro da sala existe uma enorme máquina mágica.

— Mestre Shion...

— Sim?

— Precisamos alterar o sistema.

Shion levanta os olhos.

— Qual sistema?

— O sistema central de magia do reino.

Silêncio.

— Você leu a documentação?

— Não existe documentação.

Shion fecha os olhos.

Respira.

Toma um gole de café.

— Existe.

— Onde?

Shion aponta para uma estante gigantesca.

427 grimórios.

O aprendiz empalidece.

— Preciso ler tudo isso?

— Não.

O garoto suspira aliviado.

Shion completa:

Primeiro você precisa entender por que escrevemos tudo isso.

E naquele instante o jovem finalmente compreendeu.

Ele não estava diante do maior mago daquele mundo.

Estava diante de algo muito mais raro.

O último sujeito que sabia como o sistema funcionava.

Na tela de cristal, silenciosamente, apareceu:

MAGIC MAINFRAME V42.1

SYSTEM READY

ACTIVE USERS: 8,492,117
SPELLS TODAY: 417,883,291
UPTIME: 14,327 DAYS

LAST IPL:
DO NOT ASK.

O aprendiz olhou para Shion.

— Mestre... podemos substituir isso por uma arquitetura moderna?

Shion terminou o café.

Sorriu.

E respondeu:

“Claro. Primeiro me explique exatamente o que essa máquina faz.”

O jovem abriu a boca.

Fechou.

Olhou novamente para os 427 grimórios.

E pediu café.

☕😆

Porque no final descobrimos uma verdade universal:

a magia nunca foi apenas uma API sem documentação.

Era um sistema legado esperando alguém curioso o suficiente para fazer engenharia reversa.

E Shion fez exatamente aquilo que cientistas, engenheiros e programadores vêm fazendo desde que o primeiro humano olhou para alguma coisa incompreensível e decidiu não aceitar simplesmente:

“É assim porque sempre foi assim.”

Ele perguntou:

“Por quê?”

Depois:

“Como?”

E finalmente:

“Será que consigo fazer também?”

Foi assim que nasceu a magia.

Foi assim que nasceu a ciência.

Foi assim que nasceu a engenharia.

E, em algum momento obscuro da história...

provavelmente foi assim que nasceu aquele programa COBOL que continua processando corretamente às 03:17 da madrugada, embora ninguém tenha coragem de mexer nele.

//MAGIC   JOB CLASS=A,MSGCLASS=X
//STEP01  EXEC PGM=SHION
//SYSIN   DD *
   OBSERVE
   QUESTION
   EXPERIMENT
   FAIL
   LEARN
   REPEAT
/*

IEF142I MAGIC STEP01 - STEP WAS EXECUTED

MAXCC=0000

Fim do job.

Ou talvez...

apenas o primeiro step. ☕🪄💻

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