☕ 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

quinta-feira, 21 de maio de 2026

☕🔥 Por que quase ninguém usa ponto flutuante em COBOL?

 


Bellacosa Mainframe uso de ponto flutuante em cobol

☕🔥 Por que quase ninguém usa ponto flutuante em COBOL?

Essa pergunta parece simples… mas toca em um dos temas mais profundos da arquitetura dos sistemas corporativos.

A verdade é que:

O COBOL foi criado para o mundo financeiro.
E o mundo financeiro NÃO tolera erro decimal.

Enquanto linguagens científicas valorizam amplitude numérica e velocidade matemática, o COBOL nasceu em bancos, seguradoras, folha de pagamento, contabilidade e governo — ambientes onde 1 centavo errado pode virar um desastre jurídico, contábil e operacional.

E é exatamente aí que o ponto flutuante começa a se tornar um problema.


O QUE É PONTO FLUTUANTE?

Quando falamos em COMP-1 e COMP-2, estamos falando de números armazenados em formato binário exponencial, parecido com IEEE Floating Point usado em C, Java, Python e hardware matemático.

Em vez de armazenar:

50000.00

o computador guarda algo próximo de:

mantissa × base^expoente

Exemplo conceitual:

5.000000 × 10^4

Isso permite:

✅ números gigantescos
✅ cálculos rápidos
✅ grande amplitude matemática
✅ excelente uso científico

Mas cria um problema clássico:

❌ muitos decimais NÃO existem exatamente em binário.


O GRANDE VILÃO: BINÁRIO NÃO REPRESENTA DECIMAL DIREITO

O mesmo problema ocorre em quase TODAS as linguagens.

Por exemplo:

0.1 + 0.2

Em várias linguagens o resultado interno vira:

0.30000000000000004

Porque:

0.1 decimal

não possui representação binária exata.

É parecido com tentar representar:

1/3

em decimal.

Você obtém:

0.333333333333...

Ou seja:

  • decimal sofre para representar certas frações binárias

  • binário sofre para representar certas frações decimais

E dinheiro é DECIMAL.


POR QUE ISSO É UM PESADELO EM SISTEMAS FINANCEIROS?

Imagine:

  • juros compostos

  • imposto

  • IOF

  • parcelamento

  • amortização

  • câmbio

  • atualização monetária

Agora imagine isso sendo executado:

  • milhões de vezes

  • durante décadas

  • em batchs gigantescos

  • conciliando bilhões

Se cada operação errar:

0.0000001

o erro acumulado explode.

Seu exemplo mostrou isso perfeitamente.


ANALISANDO O EXEMPLO

Seu programa é brilhante porque demonstra algo MUITO real:

perform 5000000 times
    add 0,01 to ponto-fixo
    add 0,01 to float-curto
    add 0,01 to float-longo
end-perform

Teoricamente:

5.000.000 × 0,01 = 50.000,00

O decimal fixo (COMP-3) chega exatamente nisso.

Mas observe os floats:

Float Curto..: 52.159,66
Float Longo..: 49.999,99

O COMP-1 ficou MAIS DE DOIS MIL REAIS errado.

Isso assusta muita gente iniciante.

Mas faz total sentido tecnicamente.


POR QUE O COMP-1 ERRA TANTO?

Porque ele possui apenas cerca de:

7 dígitos de precisão

E seu processamento acumulou arredondamentos continuamente.

O computador não está “errando”.

Ele está armazenando aproximações sucessivas.

Exemplo simplificado:

0,01

internamente pode virar:

0,0099999997

ou:

0,0100000003

Após milhões de somas:

💥 divergência enorme.


O COMP-2 É MELHOR… MAS AINDA NÃO É CONFIÁVEL

O COMP-2 usa 8 bytes.

Possui aproximadamente:

15~16 dígitos de precisão

Por isso o erro final ficou pequeno:

delta +0000000000000,000013

Mas para o mercado financeiro:

“quase certo” ainda significa ERRADO.

Em banco:

  • 0,01 errado é incidente

  • 0,001 errado é problema

  • 0,000013 errado pode quebrar conciliação

Mainframe não trabalha com “praticamente”.

Ele trabalha com:

✅ exatidão auditável
✅ rastreabilidade
✅ conformidade legal
✅ precisão contábil


POR ISSO O COBOL AMA COMP-3

O verdadeiro rei do mundo financeiro é:

PACKED DECIMAL

ou:

COMP-3

Porque ele armazena os dígitos DECIMAIS diretamente.

Exemplo:

PIC S9(7)V99 COMP-3

Armazena:

12345,67

como decimal compactado.

Sem conversão binária aproximada.

Resultado:

✅ precisão absoluta
✅ cálculos exatos
✅ sem erro acumulativo
✅ ideal para dinheiro


O QUE O COMP-3 SACRIFICA?

Ele perde em:

  • velocidade matemática bruta

  • amplitude numérica

  • cálculos científicos

Mas ganha no que importa ao negócio:

✅ confiabilidade financeira

E essa foi a prioridade histórica do COBOL.


O HARDWARE IBM FOI FEITO PARA ISSO

Aqui entra algo MUITO interessante da arquitetura IBM Z.

Os mainframes possuem instruções de hardware específicas para decimal packed.

Não é “emulação lenta”.

O próprio processador IBM Z possui:

  • decimal arithmetic instructions

  • packed decimal engine

  • decimal floating point support (mais moderno)

  • instruções financeiras especializadas

Ou seja:

o hardware foi literalmente desenhado para contabilidade.

Isso é um diferencial gigantesco do mundo mainframe.


POR QUE LINGUAGENS MODERNAS USAM FLOAT O TEMPO TODO?

Porque muitas aplicações modernas:

  • gráficos

  • IA

  • jogos

  • física

  • machine learning

  • rendering

  • estatística

não precisam de precisão decimal absoluta.

Para um jogo:

x = 14.99999997

não importa.

Para uma animação:

0.3000000004

é irrelevante.

Já num banco:

💀 isso vira reconciliação quebrada.


COBOL E O TRAUMA HISTÓRICO DOS CENTAVOS

Existe uma regra não escrita no mundo corporativo:

“Nunca use float para dinheiro.”

Isso veio de décadas de incidentes reais.

Sistemas antigos em C, Java e VB frequentemente causavam:

  • divergência bancária

  • erros de fechamento

  • problemas fiscais

  • falhas de arredondamento

  • diferenças em lote

Por isso Java criou:

BigDecimal

C# criou:

decimal

Python recomenda:

Decimal

Todos tentando reproduzir a filosofia do COBOL.


O PARADOXO

Curiosamente:

o COBOL estava CERTO desde os anos 60.

Enquanto outras linguagens correram atrás depois.

O modelo COBOL de:

✅ decimal fixo
✅ precisão absoluta
✅ representação financeira
✅ aritmética decimal

era exatamente o que sistemas corporativos precisavam.


MAS ENTÃO COMP-1 E COMP-2 SERVEM PARA QUÊ?

Eles existem principalmente para:


1. Aplicações científicas

Exemplo:

  • engenharia

  • estatística

  • meteorologia

  • cálculos atuariais

  • física


2. Integração com outras linguagens

Exemplo:

  • C

  • Java JNI

  • APIs numéricas

  • cálculos externos


3. Processamento matemático de alta amplitude

Exemplo:

6.022 × 10^23

número de Avogadro.

Impossível com decimal fixo convencional.


4. Dados vindos de hardware externo

Exemplo:

  • sensores

  • telemetria

  • cálculos industriais


O COBOL MODERNO E DECIMAL FLOATING POINT

Aqui entra algo avançado.

Os IBM Z modernos suportam:

  • Decimal Floating Point (DFP)

  • IEEE 754R decimal

  • hardware decimal floating

Isso tenta unir:

✅ amplitude
✅ velocidade
✅ precisão decimal

Mas mesmo assim:

em aplicações financeiras clássicas o COMP-3 continua soberano.

Porque ele é previsível, auditável e historicamente confiável.


UM DETALHE IMPORTANTE: ORDEM DAS OPERAÇÕES

Com float, até a ordem das somas pode mudar o resultado.

Exemplo:

(A + B) + C

pode ser diferente de:

A + (B + C)

Isso acontece por arredondamentos intermediários.

Em processamento paralelo isso vira um inferno.

Já decimal fixo reduz drasticamente esse problema.


OUTRA QUESTÃO CRÍTICA: COMPARAÇÃO

Em float:

IF VALOR = 0.3

pode falhar.

Porque internamente:

0.30000000000004

Isso causa bugs clássicos.

Por isso sistemas científicos usam tolerância:

ABS(A-B) < epsilon

Mas imagine isso em contabilidade.

💀 inviável.


O QUE UM PROGRAMADOR MAINFRAME APRENDE CEDO

O desenvolvedor COBOL veterano aprende rapidamente:

✅ dinheiro → COMP-3
✅ contador → COMP
✅ flags → DISPLAY/COMP
✅ float → evitar

É quase uma cultura histórica do mundo IBM.


RESUMO FINAL

COMP-1 / COMP-2 são ótimos para:

✅ ciência
✅ estatística
✅ amplitude numérica
✅ interoperabilidade
✅ cálculos matemáticos extremos


Mas são perigosos para:

❌ dinheiro
❌ contabilidade
❌ juros
❌ impostos
❌ conciliação
❌ sistemas bancários


A GRANDE LIÇÃO

O COBOL não evita ponto flutuante por limitação.

Ele evita porque:

precisão financeira vale mais que velocidade matemática.

E essa decisão arquitetural ajudou o mainframe a sustentar por décadas:

  • bancos

  • bolsas de valores

  • cartões

  • previdência

  • sistemas fiscais

  • compensação bancária

  • processamento financeiro global

com um nível de confiabilidade que poucas plataformas conseguiram igualar.

☕🔥 Guia Completo — ABENDs Clássicos do IBM OS/VS e z/OS

Bellacosa Mainframe e a lista de abends


☕🔥 Guia Completo — ABENDs Clássicos do IBM OS/VS e z/OS

Excelente observação!
No resumo anterior realmente ficaram faltando vários ABENDs importantes da lista original do artigo histórico do OS/VS. Agora segue a versão completa, revisada e expandida, incluindo TODOS os códigos mencionados no documento.


🔥 S013 — OPEN ERROR / DCB ERROR

Mensagem comum

IEC141I

O que significa

Falha ao abrir dataset.

Principais causas

  • BLKSIZE incompatível

  • RECFM incorreto

  • LRECL errado

  • Membro inexistente em PDS

Muito comum em

  • SORT

  • COBOL batch

  • IDCAMS


🔥 S0C1 — OPERATION EXCEPTION

O que significa

Execução de instrução inválida.

Causas

  • Overlay de memória

  • Programa corrompido

  • Executar área de dados como código

  • Compilação/link incorreto


🔥 S0C4 — PROTECTION EXCEPTION

O clássico absoluto do z/OS

O que significa

Acesso inválido à memória.

Causas comuns

  • Subscript fora do limite

  • Ponteiro inválido

  • Tabela ultrapassada

  • LINKAGE SECTION incorreta


🔥 S0C5 — ADDRESSING EXCEPTION

O que significa

Tentativa de acessar endereço inexistente.

Muito comum em

  • CALLs errados

  • Parâmetros incompatíveis

  • Ponteiros inválidos


🔥 S0C7 — DATA EXCEPTION

O ABEND mais famoso do COBOL

O que significa

Campo numérico contém valor inválido.

Exemplos clássicos

MOVE 'ABC' TO WS-VALOR-NUM
ADD 1 TO WS-VALOR-NUM

Principais causas

  • Campo COMP-3 corrompido

  • Dados não numéricos

  • Index fora da tabela

  • Working-storage sem inicialização


🔥 S106 — LINK/LOAD ERROR

O que significa

Falha durante LOAD ou LINK.

Causas

  • Biblioteca incorreta

  • Módulo inconsistente

  • Problema de disco


🔥 S213 — DATASET NOT FOUND

Mensagem comum

IEC143I

O que significa

Dataset inexistente.

Causas

  • DSNAME errado

  • Dataset não catalogado

  • VOL=SER incorreto


🔥 S222 — JOB CANCELADO

Mensagem comum

IEF301I

O que significa

Operador cancelou o job.

Normalmente ocorre por

  • Loop infinito

  • Job preso

  • Alto consumo


🔥 S2F3 — SYSTEM FAILURE

O que significa

Falha do sistema operacional durante execução.

Causas

  • Crash do sistema

  • IPL

  • Problema interno do z/OS

Procedimento

  • Reexecutar o job

  • Verificar logs do sistema


🔥 S322 — TIME EXCEEDED

O que significa

Job excedeu o tempo permitido.

Muito comum em

  • Loops infinitos

  • SQL sem índice

  • SORT gigantes

Exemplo

TIME=1

🔥 S613 — TAPE I/O ERROR

Mensagem comum

IEC147I

O que significa

Erro de I/O em fita magnética.

Causas

  • Fita mal posicionada

  • Multi-volume incorreto

  • Problema físico na fita


🔥 S722 — SYSOUT LIMIT EXCEEDED

O que significa

Quantidade de linhas impressas excedeu limite.

Muito comum em

  • LOOP com DISPLAY

  • Relatórios infinitos

  • Dumps excessivos


🔥 S804 — INSUFFICIENT VIRTUAL STORAGE

O que significa

Falta de memória virtual.

Causas

  • REGION pequena

  • Programa gigante

  • Uso excessivo de tabelas

Exemplo

REGION=512K

🔥 S806 — MODULE NOT FOUND

O loader não encontrou o módulo

Causas

  • STEPLIB errada

  • LOADLIB ausente

  • Nome incorreto do programa

Mensagem clássica

CSV003I REQUESTED MODULE NOT FOUND

🔥 S80A — STORAGE SHORTAGE

O que significa

Complemento do S804.

Causa principal

Falta de memória virtual disponível.


🔥 S813 — TAPE LABEL ERROR

Mensagem comum

IEC149I

O que significa

Nome do dataset na fita não bate com DD.

Causas

  • LABEL incorreto

  • DSNAME errado

  • Volume errado


🔥 S913 — RACF SECURITY VIOLATION

Mensagem comum

IEC150I

O que significa

Acesso negado pelo RACF.

Muito comum em

  • Produção

  • Db2

  • GDGs

  • VSAM corporativo


🔥 SA13 — END OF TAPE / FILE NOT FOUND

Mensagem comum

IEC151I

O que significa

Arquivo não encontrado na fita.

Causas

  • LABEL incorreto

  • Número sequencial errado

  • Volume incorreto


🔥 SB37 — OUT OF SPACE

Mensagem comum

IEC030I

O que significa

Dataset ficou sem espaço.

Causas

  • Espaço secundário insuficiente

  • Muitas extents

  • Volume cheio


🔥 SD37 — NO SECONDARY SPACE

Mensagem comum

IEC031I

O que significa

Acabou espaço primário e não existe secondary allocation.

Exemplo clássico

SPACE=(CYL,(10,0))

🔥 SE37 — EXTENT LIMIT EXCEEDED

Mensagem comum

IEC032I

O que significa

Dataset atingiu limite máximo de extents.

Muito comum em

  • PDS antigos

  • SORT gigantes

  • Arquivos temporários


☕🔥 Os ABENDs Mais Icônicos da História do Mainframe

ABENDSignificado
S0C7Data Exception
S0C4Protection Exception
S806Module Not Found
S913RACF Violation
SB37Dataset sem espaço
S322Timeout
S213Dataset não encontrado

☕ Curiosidade Histórica

Nos tempos do:

  • OS/360

  • OS/VS1

  • OS/VS2

  • MVS/XA

os operadores praticamente decoravam os ABENDs “na raça”.

Muitos programadores COBOL antigos conseguiam identificar o erro apenas olhando:

IEF450I

ou:

IEC141I

sem precisar abrir dump.

Isso virou quase uma “linguagem secreta” do mundo mainframe.


quarta-feira, 20 de maio de 2026

🔥☕ Do COBOL ao Arquiteto Enterprise Por Que Engenharia de Software Virou a Skill Mais Importante Para o Programador Mainframe Moderno

 

Bellacosa Mainframe e topicos de engenharia de software para mainframers


🔥☕ Do COBOL ao Arquiteto Enterprise

Por Que Engenharia de Software Virou a Skill Mais Importante Para o Programador Mainframe Moderno

Existe uma frase silenciosa que ecoa dentro dos grandes bancos, seguradoras e sistemas financeiros do planeta:

“O sistema pode até mudar de interface… mas o COBOL continua sustentando o mundo.”

E isso não é exagero.

Enquanto muita gente acredita que o universo enterprise vive apenas de microservices coloridos, containers e frameworks JavaScript da moda… milhões de transações financeiras continuam atravessando silenciosamente ambientes IBM Z, CICS, DB2 e aplicações COBOL gigantescas que nunca podem parar.

Mas algo mudou.

Muito.

O mercado não procura mais apenas:

  • “quem sabe COBOL”

Hoje o mercado procura:

  • engenheiros de software enterprise.

E existe uma diferença brutal entre essas duas coisas.


☕ O Antigo Programador COBOL

Durante décadas, muitos profissionais cresceram no modelo clássico:

  • alterar rotina

  • corrigir bug

  • compilar

  • subir pacote

  • fechar chamado

O foco era:

  • implementação

  • manutenção

  • operação

E isso funcionou por muito tempo.

Mas o mundo enterprise moderno virou um ecossistema absurdamente mais complexo.

Hoje um simples sistema bancário pode envolver:

  • APIs REST

  • aplicações mobile

  • cloud híbrida

  • microsserviços

  • observabilidade

  • CI/CD

  • autenticação distribuída

  • mensageria

  • integração em tempo real

  • analytics

  • IA

E no meio disso tudo…

o COBOL continua lá.

Silencioso.

Processando.

Confiável.


🏗️ O Que é Engenharia de Software de Verdade?

Muita gente acha que engenharia de software é:

  • aprender framework

  • decorar design pattern

  • usar UML

Mas engenharia de software é algo muito maior.

Ela existe para resolver um problema fundamental:

Como construir sistemas gigantes sem criar caos?

Porque sistemas enterprise crescem.

E crescem rápido.

Sem arquitetura:

  • o sistema vira espaguete

  • manutenção explode

  • bugs aumentam

  • deploys quebram produção

  • integração vira pesadelo

A engenharia surge para controlar complexidade.


🧱 Arquitetura Não É Luxo. É Sobrevivência.

O programador júnior normalmente olha para:

  • programas

  • copybooks

  • tabelas

  • jobs

O arquiteto olha para:

  • ecossistemas

  • fluxos

  • dependências

  • escalabilidade

  • disponibilidade

  • integração

Essa mudança de mentalidade é gigantesca.

Um banco não sobrevive décadas apenas porque tem “código”.

Ele sobrevive porque existe:

  • arquitetura

  • organização

  • separação de responsabilidades

  • governança

E curiosamente…

o mundo mainframe sempre fez isso muito antes da cloud existir.


☕ O Mainframe Já Pensava Como Cloud Décadas Atrás

Esse talvez seja um dos maiores segredos da computação enterprise.

Muitos conceitos vendidos hoje como “modernos” já existiam no ecossistema IBM há décadas.

Veja isso:

Mundo ModernoMainframe Enterprise
Alta disponibilidadeSysplex
Load BalancingCICSPlex
APIsz/OS Connect
TransactionsCICS
ObservabilidadeOMEGAMON
Segurança centralizadaRACF
MensageriaMQ

Ou seja…

o IBM Z nunca ficou ultrapassado.

O que aconteceu foi:

  • a interface mudou

  • o marketing mudou

  • o nome mudou

Mas os fundamentos de engenharia continuaram fortíssimos.


⚔️ O Problema do “Só Saber Programar”

Existe um erro muito comum entre iniciantes.

Acreditar que carreira se resume a:

  • linguagem

  • sintaxe

  • framework

Mas linguagens mudam.

Frameworks morrem.

Hypes desaparecem.

O que permanece é:

  • arquitetura

  • modelagem

  • design

  • integração

  • capacidade analítica

É exatamente por isso que engenheiros experientes continuam relevantes por décadas.

Eles entendem sistemas.

Não apenas ferramentas.


🧩 Design Patterns: O Conhecimento Condensado dos Veteranos

Quando um júnior vê:

  • Factory

  • Singleton

  • Observer

  • Strategy

ele normalmente pensa:

“isso parece complicado”

Mas design patterns são apenas soluções repetidas para problemas repetidos.

Eles nasceram porque grandes sistemas começaram a enfrentar:

  • acoplamento

  • manutenção impossível

  • crescimento descontrolado

  • dependências caóticas

Então engenheiros começaram a criar padrões reutilizáveis.

E isso mudou a indústria.

No fundo:

  • design patterns

  • clean code

  • arquitetura em camadas

  • UML

são tentativas humanas de controlar complexidade.


🧠 Clean Code Não É Frescura

Muitos sistemas COBOL antigos sofrem não por causa da idade.

Mas por causa da falta de engenharia.

Código ruim custa:

  • dinheiro

  • tempo

  • performance

  • estabilidade

  • saúde mental

E isso vale para qualquer linguagem.

Um programa COBOL bem escrito pode durar décadas.

Um programa moderno mal escrito pode virar lixo em seis meses.

A diferença está na engenharia.


🌐 O Novo COBOL Está Conectado

Hoje o programador mainframe moderno precisa entender:

  • APIs REST

  • JSON

  • integração

  • cloud híbrida

  • DevOps

  • pipelines

  • observabilidade

Porque o COBOL moderno não vive mais isolado.

Agora ele conversa com:

  • mobile

  • fintechs

  • microsserviços

  • IA

  • analytics

  • cloud pública

O COBOL deixou de ser “backoffice”.

Ele virou parte do ecossistema digital global.


🚀 DevOps Chegou ao IBM Z

Durante muito tempo existiu um mito:

“Mainframe não acompanha DevOps.”

Hoje isso caiu completamente.

O ecossistema IBM já possui:

  • Git

  • CI/CD

  • automação

  • pipelines

  • testes automatizados

  • observabilidade moderna

  • integração cloud-native

Ferramentas como:

  • Zowe

  • Jenkins

  • UrbanCode

  • GitHub

  • OpenShift

aproximaram ainda mais o IBM Z do universo moderno.


☕ O Que o Mercado Espera Agora?

O mercado não procura mais apenas:

  • operador

  • codificador

  • executor de tarefas

Ele procura:

  • solucionadores de problemas

O profissional valioso hoje entende:

  • negócio

  • arquitetura

  • integração

  • confiabilidade

  • escalabilidade

  • comunicação

E aqui existe uma vantagem absurda para quem vem do mainframe.

Porque poucos ambientes ensinam:

  • sistemas críticos

  • alta disponibilidade

  • milhões de transações reais

  • tolerância zero para falhas

O programador COBOL enterprise já nasce perto de problemas gigantes.


🧭 O Roadmap do Programador COBOL Moderno

A evolução natural hoje passa por:

Base

  • COBOL

  • JCL

  • VSAM

  • SDSF

Intermediário

  • DB2

  • CICS

  • SQL

  • MQ

Modernização

  • APIs

  • JSON

  • REST

  • Git

  • DevOps

Engenharia

  • Arquitetura

  • Design Patterns

  • UML

  • Observabilidade

  • Segurança

Próximo nível

  • Cloud híbrida

  • SRE

  • Performance

  • Integração distribuída

  • Engenharia enterprise


🔥 O Grande Erro do Mercado

Enquanto muitos perseguem apenas:

  • hype

  • frameworks

  • modinhas

o mundo enterprise continua valorizando:

  • confiabilidade

  • estabilidade

  • engenharia sólida

E é exatamente aí que o profissional IBM Z moderno pode se tornar raro.

Porque ele entende:

  • legado

  • missão crítica

  • integração

  • arquitetura real


☕ O Futuro Não Está Escolhendo Entre COBOL ou Cloud

O futuro está integrando os dois.

Os sistemas modernos não vão substituir completamente o mainframe.

Eles vão conversar com ele.

Porque no final:

  • o aplicativo pode mudar

  • a interface pode mudar

  • a cloud pode mudar

Mas alguém ainda precisa garantir:

  • consistência

  • transação

  • segurança

  • disponibilidade

E silenciosamente…

o IBM Z continua fazendo isso melhor do que quase qualquer outra plataforma do planeta.


🔥☕ Conclusão Bellacosa Mainframe

O programador COBOL que entender engenharia de software deixará de ser apenas:

  • “o cara do legado”

e começará a se tornar:

  • arquiteto

  • integrador

  • especialista enterprise

  • engenheiro de sistemas críticos

Porque no final…

o verdadeiro diferencial nunca foi apenas a linguagem.

Sempre foi:

entender como sistemas gigantes funcionam.

 

SKILL.md : O JCL da Inteligência Artificial?




☕ Um Café no Bellacosa Mainframe

SKILL.md

O JCL da Inteligência Artificial?

Como transformar prompts descartáveis em componentes reutilizáveis de IA

"Programadores COBOL nunca escreveram comandos repetidos quando podiam criar uma PROC. O SKILL.md segue exatamente essa filosofia."


O problema do Prompt Engineering

Hoje a maioria das pessoas trabalha assim:

Abre ChatGPT

↓

Escreve um prompt enorme

↓

Recebe resposta

↓

Fecha

↓

No dia seguinte...

Escreve tudo novamente

É praticamente isso.

Imagine um DBA que toda manhã tivesse que escrever novamente o JCL inteiro para executar o RUNSTATS.

Ninguém faria isso.

Criaria uma PROC.

Ou um CLIST.

Ou um REXX.

Ou um Script.

Ou um Pipeline.

Então por que fazemos isso com IA?


O nascimento do SKILL.md

A ideia do SKILL.md é simples.

Em vez de guardar conhecimento na cabeça...

...guardamos conhecimento em arquivos.

Esses arquivos descrevem exatamente:

  • quando executar

  • como executar

  • quais regras seguir

  • quais ferramentas usar

  • qual formato devolver

Ou seja...

não é um prompt.

É um módulo.


Pense como um programador COBOL

No COBOL existe:

COPYBOOK

Você escreve uma vez.

Depois reutiliza em centenas de programas.

O SKILL.md é praticamente o COPYBOOK da IA.


Outro exemplo.

No z/OS temos

PROC JCL

Em vez de copiar:

IEFBR14

DISP

SPACE

DCB

...

criamos

PROC

e chamamos:

//STEP EXEC PROC=BACKUP

O SKILL.md faz exatamente isso.


Em vez de escrever

Analise este código COBOL...

gere documentação...

explique...

crie testes...

faça HTML...

gere JSON...

você apenas chama

/documentar-cobol

E pronto.


O que realmente existe dentro de um SKILL.md?

A imagem resume isso muito bem.

Vamos aprofundar.


1 Nome

name:

É o identificador.

Exemplo

documentar-cobol

ou

analisar-jcl

ou

explicar-vsam

2 Description

Essa talvez seja a parte mais importante.

Ela não serve apenas para humanos.

Serve para a IA descobrir:

"quando devo usar este Skill?"

Exemplo.

Sempre que o usuário enviar um programa COBOL
e pedir documentação.

Observe.

Não é um prompt.

É um gatilho.


3 Instructions

Aqui mora o cérebro.

Exemplo.

1 Leia o código

2 Identifique variáveis

3 Gere fluxograma

4 Explique SQL

5 Explique CICS

6 Gere documentação

7 Gere Markdown

É praticamente um algoritmo.


4 Constraints

Muito importante.

Exemplo.

Nunca invente campos

Nunca altere lógica

Explique apenas o que existe

Sempre preserve comentários

Sem restrições...

a IA improvisa.

Com restrições...

ela fica previsível.


5 Output

Como devolver.

Exemplo.

Markdown

JSON

HTML

Tabela

Mermaid

Ascii Art

PlantUML

Isso elimina enorme parte da inconsistência.


Progressive Disclosure

Essa parte da imagem é excelente.

Ela mostra algo pouco conhecido.

A IA não precisa carregar tudo imediatamente.

Ela faz:

Stage 1

↓

Carrega apenas metadados

Depois

Stage 2

↓

Carrega instruções completas

Depois

Stage 3

↓

Busca scripts externos

Isso reduz consumo de contexto.

É parecido com paginação de memória.

Ou até mesmo:

Demand Paging

no z/OS.

Só carrega quando precisa.


Anatomia

A imagem resume assim:

name

description

instructions

Mas, na prática, um bom Skill costuma ter também:

Examples

References

Templates

Output

Validation

Error Handling

Scripts

Assets

Ou seja...

é quase um pequeno projeto.


Estrutura de diretórios

A imagem mostra algo como

.claude/

skills/

review-pr/

Dentro temos

SKILL.md

scripts/

references/

assets/

Isso é fantástico.

Porque aproxima IA da engenharia de software.

Não existe mais um prompt perdido.

Existe um componente organizado.


Um exemplo para Mainframe

Imagine:

skills/

analisar-cobol/

SKILL.md

copybooks/

templates/

scripts/

Dentro do Skill:

Receba um programa COBOL.

Explique:

Data Division

Working Storage

Linkage

File Section

Procedure Division

CICS

SQL

VSAM

Performance

Sugestões

Checklist

Fluxograma

Sempre igual.

Sempre consistente.


Outro exemplo

Imagine um Skill chamado

JCL Review

Quando alguém envia

//STEP01 EXEC PGM=IDCAMS

automaticamente a IA faz:

✔ verifica DISP

✔ verifica SPACE

✔ verifica UNIT

✔ verifica DCB

✔ verifica GDG

✔ verifica retorno

✔ identifica problemas

✔ sugere melhorias

Sem escrever prompt algum.


Outro exemplo

RACF Auditor

Entrada

Comandos RACF

Saída

Riscos

Boas práticas

Least Privilege

Violação

Explicação

Checklist

Normas IBM

Outro exemplo

Explicar Dump S0C7

Sempre devolvendo

Causa

Registro PSW

Offset

Hex

Instrução COBOL

Correção

Exemplo

Por que isso escala?

Porque agora existe padronização.

Imagine uma empresa.

Hoje.

100 desenvolvedores.

Cada um escreve prompts diferentes.

Resultados diferentes.

Qualidade diferente.

Agora imagine.

Todos usam

review-api

review-cobol

review-java

security

documentation

A empresa inteira produz praticamente no mesmo padrão.


Isso lembra muito...

Quem trabalha em Mainframe provavelmente percebeu.

SKILL.md lembra vários conceitos clássicos:

MainframeMundo IA
PROCSkill
COPYBOOKSkill compartilhado
CLISTSkill
REXXSkill com lógica
ISPF PanelInterface para Skill
JCL ProcedureReutilização
PARMLIBConfiguração
EXITPersonalização
Macro AssemblerTemplate reutilizável

Na verdade...

a filosofia é praticamente a mesma.


Skills × Config × MCP

A imagem também mostra essa diferença.

Skills

São capacidades.

Gerar documentação

Revisar código

Criar testes

Explicar erros

Converter formatos

São executadas sob demanda.


Configs

São comportamentos permanentes.

Exemplo.

Sempre responda em português.

Sempre seja objetivo.

Nunca gere código inseguro.

É equivalente às configurações globais do ambiente.


MCP

É outra camada completamente diferente.

MCP conecta IA a recursos externos.

Por exemplo:

GitHub

Jira

Confluence

PostgreSQL

Oracle

VSCode

Filesystem

AWS

IBM APIs

Enquanto um Skill ensina como pensar, o MCP fornece acesso ao mundo externo.


O futuro: IA Programável

A mensagem mais importante da imagem é esta:

"The shift is happening towards programmable AI systems."

Esse é realmente o movimento que está ganhando força.

A evolução pode ser vista em quatro fases:

2023

Prompt Engineering

2024

Prompt Libraries

2025

AI Agents

2026+

Skills

MCP

Workflows

Memory

Ferramentas

Automação

Cada etapa reduz trabalho manual e aumenta a reutilização e a previsibilidade.


Como isso se aplica ao Bellacosa Mainframe

Esse conceito combina muito com o projeto Bellacosa Mainframe. Em vez de criar prompts longos para cada artigo ou análise, você pode construir uma biblioteca de Skills especializadas, por exemplo:

  • Artigo Bellacosa — gera artigos longos no seu estilo, com curiosidades, história, exemplos, SEO, FAQ e chamadas para ação.

  • Review COBOL — analisa código COBOL com foco em bancos brasileiros, boas práticas, legibilidade e performance.

  • Analisador JCL — valida DISP, SPACE, GDG, retornos, organização dos DDs e oportunidades de melhoria.

  • Explicador CICS — detalha COMMAREA, Channels/Containers, TSQ/TDQ, RESP/RESP2, BMS e tratamento de erros.

  • Gerador de Quiz — cria avaliações com diferentes níveis de dificuldade e gabarito comentado.

  • Criador de Laboratórios — produz exercícios práticos para Hercules, ADCD e ambientes IBM Z.

  • SEO Blogspot — gera meta description, marcadores, slug e estrutura otimizada para mecanismos de busca.

Cada Skill seria reutilizada inúmeras vezes, garantindo consistência em todos os seus conteúdos.


Conclusão

O SKILL.md representa uma mudança importante na forma de trabalhar com IA. O foco deixa de ser escrever prompts elaborados para cada interação e passa a ser a criação de componentes reutilizáveis, documentados e padronizados, muito semelhantes aos princípios que profissionais de mainframe já utilizam há décadas com COPYBOOKs, PROCs, CLISTs, REXX e módulos reutilizáveis.

No fim das contas, a lógica é familiar para qualquer desenvolvedor experiente:

Não copie conhecimento. Encapsule-o. Não repita instruções. Reutilize-as. Não trate a IA como uma calculadora. Trate-a como uma plataforma programável.

Essa mudança aproxima a Inteligência Artificial das boas práticas de engenharia de software e tende a tornar seu uso mais confiável, escalável e sustentável em ambientes corporativos — exatamente como aconteceu com a evolução do desenvolvimento no mundo IBM Z ao longo das últimas décadas.

terça-feira, 19 de maio de 2026

☕💥 Guia Completo do CICS TS — O Coração Invisível Que Ainda Mantém o Mundo Financeiro Vivo no IBM Z 🖥️🔥

 

Bellacosa Mainframe apresenta o cics ts para padawans

☕💥 Guia Completo do CICS TS — O Coração Invisível Que Ainda Mantém o Mundo Financeiro Vivo no IBM Z 🖥️🔥

Existe um detalhe curioso sobre a computação moderna que pouca gente fora do universo enterprise percebe.

Enquanto milhões discutem cloud, Kubernetes, IA generativa e microsserviços, existe um sistema silencioso processando bilhões de transações financeiras com níveis absurdos de disponibilidade, consistência e performance que praticamente nenhum ambiente distribuído conseguiu reproduzir em escala global.

Esse sistema atende bancos, seguradoras, bolsas de valores, operadoras de cartão, governos, companhias aéreas e gigantes do varejo.

E no centro dessa engenharia quase “alienígena” existe uma criatura lendária chamada:

IBM CICS TS (Customer Information Control System Transaction Server)

Sim…

O famoso CICS.

O “monstro sagrado” do IBM Z.

O middleware transacional que sobreviveu décadas de revoluções tecnológicas enquanto inúmeros “substitutos definitivos” desapareceram da história.

E talvez o mais impressionante:

A maioria das pessoas usa CICS todos os dias sem sequer imaginar.


☕ O Que É o CICS TS?

O IBM CICS TS é um monitor transacional online para IBM Z.

Mas essa definição é pequena demais para explicar sua importância.

Na prática, o CICS é:

  • Um gerenciador de transações

  • Um ambiente de execução

  • Um middleware enterprise

  • Um controlador de recursos

  • Um servidor de aplicações

  • Um roteador de workloads

  • Um orquestrador de segurança

  • Um ecossistema inteiro de processamento online

Ele foi criado para resolver um problema extremamente complexo:

Como permitir milhares — ou milhões — de usuários simultâneos executando transações críticas sem destruir a integridade dos dados?

Esse problema continua existindo até hoje.

E o CICS continua sendo uma das melhores respostas já criadas.


☕ O Significado Real de “TS”

Muita gente fala apenas “CICS”.

Mas o nome atual é:

CICS TS = CICS Transaction Server

O “TS” surgiu quando o produto evoluiu de um simples monitor transacional para uma plataforma enterprise gigantesca.

Hoje o CICS TS oferece:

  • APIs modernas

  • REST

  • JSON

  • SOAP

  • Web Services

  • integração com cloud

  • OpenTelemetry

  • observabilidade

  • containers Java

  • Liberty

  • eventos em tempo real

  • integração com Kafka

  • z/OS Connect

  • APIs híbridas

Ou seja:

O CICS moderno não é “legacy”.

Ele é um sistema transacional enterprise híbrido.


☕ A História Que Quase Ninguém Conhece

O CICS nasceu em 1968.

Isso mesmo.

ANTES da internet moderna.

ANTES do Unix virar padrão.

ANTES do PC existir.

ANTES da computação distribuída.

E mesmo assim seus conceitos arquiteturais continuam modernos.

Isso assusta muita gente.

Porque mostra que alguns engenheiros da IBM literalmente projetaram sistemas décadas à frente do tempo.


☕ O Verdadeiro Papel do CICS no Banco

Imagine um banco sem CICS por 10 minutos.

Agora imagine:

  • PIX parado

  • TED indisponível

  • cartão recusando

  • ATM travado

  • saldo inconsistente

  • autorização falhando

  • filas congestionadas

  • compensação interrompida

O caos.

O CICS existe exatamente para impedir isso.

Ele foi criado para ambientes onde:

  • falha custa milhões

  • inconsistência destrói empresas

  • downtime vira desastre nacional


☕ Como o CICS Funciona na Prática

O modelo do CICS é elegantemente brutal.

Ele recebe milhares de solicitações concorrentes:

  • terminais 3270

  • APIs REST

  • MQ

  • Web Services

  • aplicações móveis

  • gateways financeiros

  • integrações Java

  • middlewares distribuídos

E transforma tudo isso em transações controladas.

Cada transação possui:

  • contexto

  • controle

  • rollback

  • recovery

  • segurança

  • sincronização

  • isolamento

O objetivo é simples:

Garantir integridade absoluta.


☕ O Conceito Mais Importante: Transação

No CICS, tudo gira ao redor de transações.

Uma transação precisa ser:

  • rápida

  • consistente

  • recuperável

  • segura

  • atômica

Se ocorrer falha:

  • rollback

  • recovery

  • journaling

  • syncpoint

O sistema volta ao estado consistente.

Isso parece “normal” hoje.

Mas quando o CICS nasceu isso era engenharia futurista.


☕ O Modelo Pseudo-Conversacional

Aqui está uma das maiores genialidades do CICS.

Ao invés de manter sessões gigantes consumindo memória eternamente, o CICS criou o conceito pseudo-conversacional.

Fluxo simplificado:

  1. usuário envia dados

  2. programa processa

  3. estado é salvo

  4. tarefa termina

  5. recursos são liberados

  6. usuário responde depois

  7. contexto é restaurado

Resultado:

  • escalabilidade absurda

  • menor consumo

  • maior throughput

  • eficiência monstruosa

Esse conceito continua brilhante até hoje.


☕ Regiões CICS — O Mundo Interno

O universo CICS é dividido em regiões.

As mais famosas:

TOR — Terminal Owning Region

Responsável pela comunicação de entrada.

Recebe conexões.

Distribui workloads.


AOR — Application Owning Region

Onde a lógica de negócio roda.

Os programas COBOL vivem aqui.

É o “cérebro operacional”.


FOR — File Owning Region

Gerencia acesso aos datasets e arquivos.

Controla VSAM e recursos compartilhados.


WUI — Web User Interface

Interface administrativa moderna.


JVM Server

Permite workloads Java dentro do CICS.


☕ O Ciclo de Vida de uma Transação

Uma transação passa por múltiplas fases:

1. Attach

O CICS cria a task.


2. Dispatch

A tarefa recebe CPU.


3. Execute

Programa COBOL roda.

Comandos EXEC CICS são processados.


4. File Access

DB2, VSAM, MQ, APIs.


5. Syncpoint

Commit ou rollback.


6. Termination

Task encerrada.

Recursos liberados.


☕ EXEC CICS — A Linguagem Sagrada

Programas COBOL interagem com o CICS usando:

EXEC CICS
   SEND MAP('TELA1')
END-EXEC

ou:

EXEC CICS
   READ FILE('CLIENTE')
END-EXEC

O EXEC CICS funciona como uma API nativa do monitor transacional.

É praticamente uma “linguagem dentro da linguagem”.


☕ BMS — A Engenharia das Telas 3270

Antes de frameworks web existirem…

O CICS já possuía geração dinâmica de interfaces.

Isso acontecia via:

BMS — Basic Mapping Support

O BMS define:

  • campos

  • atributos

  • proteção

  • intensidade

  • validação

  • layouts

Tudo otimizado para terminais 3270.

E absurdamente eficiente.


☕ VSAM + CICS — A Dupla Histórica

Durante décadas:

VSAM + CICS + COBOL

foram a espinha dorsal do sistema financeiro mundial.

O VSAM oferecia:

  • acesso rápido

  • alta confiabilidade

  • baixa latência

  • recuperação eficiente

O CICS coordenava tudo.


☕ CICS + DB2 — A Evolução Enterprise

Com o crescimento do SQL, o DB2 tornou-se dominante.

Hoje o modelo clássico é:

  • CICS

  • COBOL

  • DB2

  • MQ

  • RACF

  • z/OS

A famosa “stack dourada” do IBM Z.


☕ Segurança no CICS

O CICS moderno integra profundamente com:

RACF

Controle de:

  • usuários

  • transações

  • programas

  • recursos

  • datasets

  • APIs

Tudo auditável.

Tudo rastreável.

Tudo controlado.


☕ Performance — O Verdadeiro Monstro

Aqui mora algo que impressiona engenheiros modernos.

O CICS consegue:

  • milhões de transações por segundo

  • latência extremamente baixa

  • uso eficiente de CPU

  • altíssimo throughput

  • estabilidade absurda

E muitas vezes usando menos recursos que arquiteturas distribuídas gigantescas.


☕ O Dispatcher do CICS

O dispatcher controla:

  • prioridades

  • tasks

  • waits

  • dispatching

  • TCBs

  • QR TCB

  • Open TCBs

É uma engenharia refinada ao extremo.

Muitos gargalos críticos surgem exatamente aqui.


☕ QR TCB — O Gargalo Clássico

A famosa QR TCB é quase uma entidade mitológica no mundo mainframe.

Ela controla grande parte do processamento serializado.

Quando ocorre saturação:

  • response time explode

  • filas aumentam

  • CPU sobe

  • throughput despenca

Performance tuning em CICS frequentemente gira ao redor disso.


☕ Open TCB — A Revolução Moderna

O CICS evoluiu para múltiplos TCBs paralelos.

Isso permitiu:

  • maior paralelismo

  • workloads Java

  • threadsafe

  • redução de contenção

  • melhor escalabilidade

Essa foi uma mudança gigantesca.


☕ Threadsafety — O Conceito Que Mudou Tudo

Programas threadsafe podem executar fora da QR.

Resultado:

  • menos serialização

  • mais paralelismo

  • maior throughput

  • menor contenção

Hoje isso é fundamental.


☕ Recovery Manager — O Guardião da Consistência

O CICS possui mecanismos sofisticados de recovery:

  • journaling

  • logging

  • syncpoints

  • backout

  • restart

  • warm start

  • cold start

  • emergency restart

Se algo falha…

O sistema tenta preservar integridade absoluta.


☕ CICS e APIs Modernas

Aqui muita gente fica surpresa.

O CICS moderno fala:

  • REST

  • JSON

  • HTTP

  • SOAP

  • XML

  • OpenAPI

Sim…

Você pode expor COBOL como API REST.

E milhões de empresas fazem isso diariamente.


☕ z/OS Connect — O Portal Entre Dois Mundos

O z/OS Connect EE revolucionou integração.

Ele transforma programas CICS em APIs modernas.

Isso permitiu:

  • integração cloud

  • mobile

  • fintechs

  • microsserviços

  • open banking

Sem reescrever décadas de negócio crítico.


☕ CICS Event Processing

O CICS moderno consegue gerar eventos em tempo real.

Exemplo:

  • transação executada

  • limite excedido

  • fraude detectada

  • cliente premium acessou

  • falha ocorreu

Esses eventos podem alimentar:

  • Kafka

  • Splunk

  • Elastic

  • SIEM

  • observabilidade

  • analytics


☕ Observabilidade Moderna no CICS

O CICS atual entrou oficialmente na era observability.

Hoje temos integração com:

  • OpenTelemetry

  • Grafana

  • Instana

  • Elastic

  • Splunk

  • OMEGAMON

O mundo “caixa preta do mainframe” acabou.


☕ CICS + Java

Sim…

Java dentro do CICS existe.

A IBM criou:

  • JVM Server

  • Liberty Profile

  • integração híbrida

  • APIs Java

  • containers modernos

Tudo coexistindo com COBOL.

É literalmente computação de múltiplas eras convivendo no mesmo ambiente.


☕ O Mito do “Legacy”

Existe uma confusão enorme aqui.

Muita gente chama CICS de legado porque ele é antigo.

Mas “antigo” não significa “obsoleto”.

Pelo contrário.

O CICS continua sendo utilizado porque:

  • funciona

  • escala

  • é resiliente

  • é auditável

  • é seguro

  • é eficiente

  • custa menos do que falhas

O verdadeiro problema não é o CICS.

O problema é engenharia ruim ao redor dele.


☕ O Erro das Empresas Modernas

Muitas organizações tentaram “matar o mainframe”.

Resultado comum:

  • explosão de custo

  • perda de performance

  • inconsistência

  • caos operacional

  • outages

  • rollback do projeto

Então descobriram algo doloroso:

Reproduzir décadas de engenharia transacional é absurdamente difícil.


☕ O Futuro do CICS

O futuro do CICS provavelmente será:

  • híbrido

  • API-first

  • integrado com IA

  • observável

  • conectado à cloud

  • orientado a eventos

  • automatizado

  • cada vez mais invisível

O usuário final nunca verá o CICS.

Mas continuará dependendo dele diariamente.


☕ O Grande Segredo do Mainframe

O público vê:

  • apps bonitos

  • fintechs modernas

  • bancos digitais

  • IA generativa

Mas nos bastidores…

Existe uma infraestrutura brutal garantindo que:

  • dinheiro não suma

  • transações não se corrompam

  • contas permaneçam consistentes

  • bilhões de operações sobrevivam diariamente

E o CICS continua sendo uma das maiores obras de engenharia da história da computação.


☕ Conclusão — O Sistema Que Sobreviveu a Tudo

O CICS sobreviveu:

  • ao nascimento do PC

  • à era Unix

  • à internet

  • ao client/server

  • à virtualização

  • à cloud

  • aos microsserviços

  • ao hype eterno do “fim do mainframe”

E continua processando o coração financeiro do planeta.

Talvez porque tecnologia enterprise real não seja sobre moda.

Talvez seja sobre:

  • estabilidade

  • consistência

  • engenharia

  • previsibilidade

  • confiança

Enquanto bilhões dependem disso…

O CICS continuará vivo.

Silencioso.

Invisível.

E absurdamente indispensável.

segunda-feira, 18 de maio de 2026

☕💥 “O MAINFRAME VAI MORRER?” — A PROFECIA QUE O IBM Z ENTERROU HÁ 40 ANOS… E NINGUÉM PERCEBEU 🖥️🔥

 

Bellacosa Mainframe e as muitas mortes do Mainframe

☕💥 “O MAINFRAME VAI MORRER?” — A PROFECIA QUE O IBM Z ENTERROU HÁ 40 ANOS… E NINGUÉM PERCEBEU 🖥️🔥

Existe uma frase que atravessa décadas dentro da TI:

“Agora o Mainframe morre.”

Ela apareceu:

  • quando surgiu o UNIX,

  • quando surgiu o client/server,

  • quando surgiu o Windows NT,

  • quando veio a virtualização,

  • quando nasceu a nuvem,

  • quando apareceu Kubernetes,

  • quando o x86 ficou barato,

  • quando a AWS explodiu,

  • e agora… quando a IA virou hype mundial.

E ainda assim…

o Mainframe continua processando:

  • bancos,

  • bolsas de valores,

  • cartões,

  • governos,

  • companhias aéreas,

  • seguradoras,

  • telecom,

  • PIX,

  • SWIFT,

  • clearing,

  • pagamentos globais,

  • sistemas militares,

  • transações críticas do planeta.

A pergunta real nunca foi:

“O Mainframe vai morrer?”

A pergunta correta é:

☕ “QUEM CONSEGUE SUBSTITUIR O QUE ELE ENTREGA?”

E é aqui que o padawan começa a entender a brutalidade da arquitetura IBM Z.


☕ O MAIOR ERRO DA INTERNET: ACHAR QUE MAINFRAME É “SERVIDOR ANTIGO”

Esse é o primeiro choque de realidade.

Mainframe não é:

  • “um servidor grande”

  • “um computador velho”

  • “COBOL rodando em tela preta”

Mainframe é:

uma filosofia de computação crítica.

Ele foi desenhado para:

  • não parar,

  • não corromper dados,

  • suportar volumes absurdos,

  • sobreviver a falhas,

  • proteger transações,

  • consolidar workloads gigantescos.

Enquanto o mundo x86 cresceu baseado em:

  • distribuição,

  • fragmentação,

  • farms,

  • clusters,

  • escalabilidade horizontal,

o IBM Z cresceu baseado em:

  • consistência,

  • integridade,

  • throughput,

  • I/O extremo,

  • isolamento,

  • disponibilidade.

São filosofias completamente diferentes.


☕ O MAINFRAME NÃO PAROU NO TEMPO — AS PESSOAS PARARAM DE ESTUDAR

Esse talvez seja o ponto mais importante.

Muita gente ainda imagina o mainframe como:

  • JCL dos anos 80,

  • terminais verdes,

  • aplicações monolíticas isoladas.

Só que o IBM Z moderno virou outra criatura.

Hoje existe:

  • Linux nativo no IBM Z,

  • containers,

  • OpenShift,

  • Kubernetes,

  • APIs REST,

  • z/OS Connect,

  • criptografia on-chip,

  • IA embarcada,

  • observabilidade moderna,

  • OpenTelemetry,

  • Grafana,

  • DevOps,

  • Git,

  • pipelines CI/CD,

  • automação massiva,

  • integração cloud híbrida.

O problema:

o mercado continua discutindo o Mainframe de 1998.

Enquanto isso, a IBM já está anos à frente.


☕ IBM z17 — O MONSTRO QUE O MERCADO X86 NÃO GOSTA DE COMPARAR

O IBM z17 representa algo que pouca gente entende:

consolidação extrema com eficiência absurda.

Quando um banco usa farms x86 gigantescas, ele enfrenta:

  • milhares de servidores,

  • switches,

  • racks,

  • refrigeração brutal,

  • consumo energético gigantesco,

  • licenciamento distribuído,

  • gerenciamento caótico,

  • patches infinitos,

  • superfície enorme de ataque.

O resultado?

Uma infraestrutura aparentemente “barata”…
mas operacionalmente monstruosa.


☕ O CUSTO ESCONDIDO DAS FARMS X86

O padawan normalmente olha apenas:

  • preço do servidor,

  • custo unitário,

  • VM barata.

Mas enterprise não funciona assim.

Existe:

  • energia,

  • refrigeração,

  • espaço físico,

  • licenciamento,

  • rede,

  • storage,

  • backup,

  • observabilidade,

  • administração,

  • segurança,

  • failover,

  • replicação,

  • downtime.

E é aqui que o Mainframe humilha.


☕ UM IBM Z PODE SUBSTITUIR CENTENAS OU MILHARES DE SERVIDORES

E isso muda tudo:

  • menos energia,

  • menos calor,

  • menos cabeamento,

  • menos switches,

  • menos pontos de falha,

  • menos datacenter,

  • menos equipe operacional fragmentada.

O mundo começou a perceber algo curioso:

escalabilidade horizontal infinita também cria caos infinito.


☕ ENERGIA VIROU O NOVO OURO DA TI

Esse é um tema que explodiu com IA generativa.

Datacenters modernos estão enfrentando:

  • limitações energéticas,

  • custos absurdos,

  • crises térmicas,

  • expansão inviável,

  • consumo elétrico insano.

Agora imagine:

  • milhares de GPUs,

  • milhares de servidores,

  • milhares de VMs,

  • milhares de containers.

A conta energética virou um pesadelo.

E o Mainframe reaparece como:

consolidação inteligente.

Pouca gente percebeu isso ainda.


☕ O MAINFRAME SEMPRE FOI “GREEN IT” ANTES DO TERMO EXISTIR

Enquanto o mercado celebrava:

  • “cloud first”,

  • “scale out”,

  • “microservices infinitos”,

o IBM Z continuava fazendo:

  • mais throughput,

  • menos espaço,

  • menos energia,

  • menos hardware.

O Mainframe nunca precisou provar eficiência.
Ele nasceu eficiente.


☕ “MAS CLOUD NÃO SUBSTITUI O MAINFRAME?”

Não totalmente.

Na verdade:

o futuro virou híbrido.

O mercado descobriu algo doloroso:

  • mover tudo para cloud custa caro,

  • latência importa,

  • transação crítica importa,

  • compliance importa,

  • soberania importa,

  • segurança importa,

  • throughput importa.

Resultado:
muitas empresas começaram movimentos de:

  • repatriação,

  • hybrid cloud,

  • integração z/OS + cloud,

  • APIs sobre workloads legacy.

E aqui entra um dos maiores saltos modernos do IBM Z.


☕ z/OS CONNECT — O PORTAL ENTRE O MUNDO LEGACY E O MUNDO MODERNO

O z/OS Connect foi uma revolução silenciosa.

Ele permite transformar:

  • COBOL,

  • CICS,

  • IMS,

  • DB2,

  • transações legacy

em:

  • APIs REST,

  • serviços JSON,

  • integrações modernas.

Isso destruiu um mito antigo:

“Mainframe não conversa com o mundo moderno.”

Hoje o IBM Z conversa:

  • com cloud,

  • com mobile,

  • com microsserviços,

  • com Kubernetes,

  • com APIs externas,

  • com IA,

  • com analytics.

O Mainframe deixou de ser “ilha”.
Agora ele virou:

núcleo transacional do ecossistema moderno.


☕ TCP/IP NO MAINFRAME NÃO É “ADAPTAÇÃO” — É PRODUÇÃO PESADA

Outro mito:

“Mainframe não é bom em rede.”

O z/OS possui stacks TCP/IP extremamente robustas.

E quando combinadas com:

  • Sysplex,

  • HiperSockets,

  • OSA,

  • workload balancing,

  • criptografia integrada,

o resultado é uma infraestrutura absurda para:

  • transações financeiras,

  • APIs,

  • mensageria,

  • integração distribuída.

O Mainframe moderno fala TCP/IP como cidadão nativo da internet enterprise.


☕ LINUX NO IBM Z MUDOU O JOGO

Esse foi um divisor histórico.

Muita gente ainda não entende o impacto disso.

O Linux on Z permitiu:

  • consolidar workloads Linux massivos,

  • reduzir farms x86,

  • virtualizar em escala absurda,

  • aumentar segurança,

  • integrar ambientes híbridos.

E o mais interessante:

Linux no IBM Z não destrói o z/OS — ele complementa.

Hoje o IBM Z virou:

  • plataforma Linux,

  • plataforma cloud,

  • plataforma API,

  • plataforma IA,

  • plataforma transacional,

  • plataforma de segurança.


☕ SEGURANÇA: O PONTO QUE O MUNDO COMEÇOU A RESPEITAR DE NOVO

O aumento de:

  • ransomware,

  • vazamentos,

  • ataques supply chain,

  • ataques financeiros,

  • espionagem digital,

fez o mercado redescobrir algo:

segurança custa caro.

E o IBM Z sempre foi paranoico com segurança.

O ecossistema possui:

  • RACF,

  • criptografia embarcada,

  • Secure Execution,

  • isolamento extremo,

  • hardware security,

  • auditoria massiva,

  • compliance pesado.

Enquanto muitos ambientes x86 foram construídos priorizando velocidade…
o Mainframe foi construído priorizando:

sobrevivência.


☕ O MAINFRAME NÃO MORREU PORQUE O MUNDO NÃO CONSEGUE PARAR

Esse é o ponto filosófico.

A internet tolera:

  • erro,

  • retry,

  • falha parcial,

  • eventual consistency.

O banco não.

O cartão não.

A bolsa não.

O PIX não.

A compensação financeira global não.

O Mainframe continua existindo porque:

alguém precisa garantir que a civilização digital não corrompa.


☕ O NOVO PROFISSIONAL MAINFRAME NÃO É MAIS “OPERADOR DE TELA VERDE”

Aqui acontece a maior mudança de mentalidade.

O profissional moderno do IBM Z precisa entender:

  • APIs,

  • integração,

  • Linux,

  • observabilidade,

  • automação,

  • segurança,

  • redes,

  • cloud híbrida,

  • DevOps,

  • containers,

  • OpenShift,

  • IA aplicada à operação.

O novo mainframe engineer virou:

arquiteto de sistemas críticos globais.


☕ O ERRO DAS NOVAS GERAÇÕES

Muitos jovens entram na TI ouvindo:

“Mainframe é legado morto.”

Mas aí descobrem:

  • salários altos,

  • baixa concorrência,

  • sistemas gigantescos,

  • tecnologia avançadíssima,

  • ambientes críticos,

  • engenharia de altíssimo nível.

E percebem algo chocante:

o Mainframe nunca foi ultrapassado — ele apenas ficou invisível.

Porque quando ele funciona…
ninguém percebe.


☕ O FUTURO DO IBM Z NÃO É SOBREVIVER

É pior que isso.

É crescer silenciosamente.

Porque o mundo está entrando numa era onde:

  • energia importa,

  • segurança importa,

  • IA consome recursos absurdos,

  • disponibilidade virou obsessão,

  • compliance virou inferno,

  • cyber warfare virou realidade,

  • transações digitais explodiram.

E curiosamente…

essas sempre foram as especialidades do Mainframe.


☕ “ENTÃO O MAINFRAME É PERFEITO?”

Claro que não.

Existem desafios:

  • curva de aprendizado,

  • escassez de profissionais,

  • custos iniciais elevados,

  • percepção antiquada,

  • dependência histórica,

  • modernização cultural.

Mas o erro é imaginar que:

“caro” significa “obsoleto”.

Ferrari também é cara.
Datacenter crítico também.

O que importa é:

  • custo por transação,

  • estabilidade,

  • throughput,

  • segurança,

  • eficiência operacional.

E nesse campo…
o IBM Z continua monstruoso.


☕ A VERDADE FINAL QUE O PADAWAN PRECISA OUVIR

O Mainframe não compete diretamente com:

  • notebook,

  • VPS,

  • servidor doméstico,

  • startup pequena.

Ele compete com:

  • caos operacional,

  • falha financeira,

  • indisponibilidade global,

  • colapso transacional.

E até hoje…
pouquíssimas arquiteturas conseguem entregar o que ele entrega ao mesmo tempo:

  • escala,

  • segurança,

  • consistência,

  • throughput,

  • eficiência energética,

  • disponibilidade absurda.

Por isso o Mainframe não desapareceu.

Porque o problema que ele resolve ainda existe.

E talvez…
agora mais do que nunca.

O Lobo Roxo da Faria Lima: COBOL, Nubank e o Dia em que uma Startup Entrou no Salão dos Bancos e Descobriu que os Gigantes Tinham um Problema Chamado Fricção

 

Bellacosa Mainframe e o lobo roxo da Faria Lima

☕ Um Café no Bellacosa Mainframe

O Lobo Roxo da Faria Lima: COBOL, Nubank e o Dia em que uma Startup Entrou no Salão dos Bancos e Descobriu que os Gigantes Tinham um Problema Chamado Fricção

💳 Como um cartão roxo, um aplicativo e uma arquitetura digital desafiaram Itaú, Bradesco, Santander, Banco do Brasil, Caixa e companhia — e o que um programador COBOL iniciante pode aprender com essa história antes de tentar reescrever o mundo em microsserviços

Imagine a cena.

Um enorme salão de operações financeiras.

Telas piscando.

Gráficos subindo e descendo.

Telefones tocando.

Executivos engravatados dizendo coisas como:

— Liquida isso antes do fechamento.

— Aumenta o limite da carteira.

— Quero essa posição zerada antes do almoço.

— Quanto temos de exposição?

No fundo da sala existe uma enorme porta de aço.

Nela está escrito:

CORE BANKING
AUTHORIZED PERSONNEL ONLY

Atrás daquela porta existem décadas de tecnologia bancária.

COBOL.

CICS.

Db2.

IMS.

MQ.

JCL.

VSAM.

RACF.

Batch noturno.

Arquivos gigantes.

Processamento de milhões de transações.

Sistemas que funcionavam quando muitos fundadores de fintechs ainda estavam aprendendo a andar.

Na mesa principal estão sentados os gigantes.

Banco do Brasil.

Caixa Econômica Federal.

Bradesco.

Itaú.

Santander.

Cada um com décadas — alguns com séculos — de história, capital, infraestrutura, clientes, agências, funcionários e sistemas.

Então entra alguém segurando um pequeno cartão roxo.

Nenhuma agência.

Nenhum prédio gigantesco.

Nenhuma tradição centenária.

Nenhum gerente esperando atrás de uma mesa de madeira.

Apenas um smartphone.

O pessoal da sala olha.

Um executivo pergunta:

— E você é quem?

A resposta:

— Nubank.

Silêncio.

Outro executivo ri.

— Banco?

— Mais ou menos.

— Quantas agências?

— Nenhuma.

— Quantos caixas?

— Nenhum.

— Então o que você tem?

O cartão roxo sobe lentamente.

— Um aplicativo.

Provavelmente alguém teria mandado o rapaz procurar a recepção.

E esse é justamente o começo da história.

Porque o Nubank não entrou no mercado bancário brasileiro tentando construir um banco tradicional um pouco melhor.

Ele entrou questionando uma premissa muito mais perigosa:

E se várias coisas que nós consideramos parte natural de um banco existirem apenas porque sempre foram feitas daquele jeito?

Para um programador COBOL iniciante, essa pergunta vale ouro.

Não porque COBOL seja velho.

Mas porque sistemas corporativos acumulam, ao longo das décadas, uma enorme quantidade de decisões.

Algumas são brilhantes.

Algumas continuam essenciais.

Algumas existem porque ninguém ousou perguntar por quê.

E algumas continuam ali simplesmente porque alterar aquilo custaria tanto que todo mundo prefere fingir que não percebeu.

Pegue o café.

Hoje vamos falar de bancos.

Mas, principalmente, vamos falar de sistemas.


Capítulo 1 — O mercado impossível

Imagine que você estivesse montando uma startup em 2013.

Alguém apresenta a ideia:

Vamos criar uma instituição financeira no Brasil.

Qualquer pessoa minimamente racional poderia responder:

— Excelente. E depois vamos fabricar aviões para competir com Boeing e Airbus?

O mercado brasileiro já possuía gigantes.

Banco do Brasil.

Caixa.

Bradesco.

Itaú.

Santander.

Bancos regionais.

Bancos médios.

Cooperativas.

Financeiras.

Administradoras de cartão.

Cada um com clientes, capital, tecnologia e décadas de conhecimento regulatório.

Era aparentemente um mercado horrível para entrar.

Só que existe uma diferença importante entre:

mercado competitivo

e:

mercado satisfatório para o consumidor

Essas coisas não são iguais.

Um mercado pode ter muitos concorrentes e, mesmo assim, oferecer experiências muito semelhantes.

Esse era um dos grandes pontos do sistema bancário tradicional.

O consumidor frequentemente encontrava:

tarifa
fila
agência
formulário
assinatura
telefone
gerente
burocracia
espera

O banco podia ser tecnologicamente sofisticadíssimo por trás.

Mas para o cliente?

Às vezes parecia 1987.

E aqui aparece uma primeira lição fundamental para quem está começando em COBOL.

Backend excelente não garante experiência excelente.

Você pode ter:

99,999% disponibilidade

no core.

Pode processar:

10 milhões de transações

durante a madrugada.

Pode ter:

RACF
CICS
DB2
IMS
GDG
SMF
WLM

funcionando perfeitamente.

Mas se o usuário precisar preencher três formulários, telefonar cinco vezes e esperar 40 minutos para resolver alguma coisa, ele não enxerga sua arquitetura maravilhosa.

Ele enxerga sofrimento.

O Nubank encontrou espaço justamente nessa distância.


Capítulo 2 — O inimigo não era o mainframe

Aqui existe um erro que aparece frequentemente quando se fala de fintech.

Alguém diz:

Fintech venceu porque banco tradicional usa mainframe.

Calma.

Não.

Muito pelo contrário.

Os mainframes dos grandes bancos são parte da razão pela qual essas instituições conseguem operar em enorme escala.

Um IBM Z pode processar volumes absurdos de transações com confiabilidade extraordinária.

COBOL continua executando grande parte da economia mundial porque resolve muito bem problemas transacionais.

Portanto:

MAINFRAME != PROBLEMA

O verdadeiro problema era frequentemente:

PROCESSO + ORGANIZAÇÃO + FRICÇÃO + HISTÓRIA

Veja a diferença.

O banco tradicional tinha algo conceitualmente parecido com:

CLIENTE
   |
   v
AGÊNCIA
   |
   v
GERENTE
   |
   v
SISTEMA DE ATENDIMENTO
   |
   v
MIDDLEWARE
   |
   v
CORE BANKING

O Nubank podia imaginar desde o início:

CLIENTE
   |
   v
SMARTPHONE
   |
   v
APLICAÇÃO
   |
   v
SERVIÇOS
   |
   v
PLATAFORMA FINANCEIRA

Não significa que o segundo modelo seja magicamente simples.

Há dezenas de problemas escondidos ali:

  • segurança;

  • KYC;

  • antifraude;

  • crédito;

  • liquidação;

  • bandeiras;

  • compliance;

  • regulação;

  • cobrança;

  • observabilidade;

  • contingência;

  • reconciliação.

Mas existe uma vantagem brutal:

o sistema nasceu pensando no canal digital como canal principal.

Isso é diferente de pegar um sistema construído durante décadas e acrescentar:

IF CHANNEL = MOBILE
    PERFORM DIGITAL-FLOW
END-IF.

Sim, COBOLzeiro.

O mundo inteiro eventualmente vira um IF.


Capítulo 3 — O smartphone virou agência bancária

Um dos fatores decisivos do sucesso do Nubank foi timing.

O smartphone estava deixando de ser luxo.

Estava virando infraestrutura social.

De repente milhões de pessoas carregavam no bolso:

tela
câmera
internet
GPS
autenticação
notificações
aplicativos

Tudo isso em um único dispositivo.

Antes, para construir presença nacional, um banco precisava de prédios.

Agências.

Funcionários.

Terminais.

Caixas eletrônicos.

Segurança.

Transporte de numerário.

Infraestrutura física.

O smartphone alterou radicalmente essa equação.

A agência podia ser:

+-------------------+
|                   |
|      📱           |
|                   |
+-------------------+

O cliente não precisava ir ao banco.

O banco passava a ir com o cliente.

Essa mudança parece óbvia hoje.

Mas quase toda inovação parece óbvia depois que alguém faz.

Easter egg nº 1

Existe uma frase famosa atribuída ao mundo da tecnologia:

A melhor interface é aquela que desaparece.

No caso bancário, ocorreu algo ainda mais estranho.

A agência inteira começou a desaparecer.


Capítulo 4 — O cartão roxo era um cavalo de Troia

Agora chegamos a uma das decisões mais inteligentes.

O Nubank não tentou inicialmente convencer o brasileiro a transferir toda a vida financeira.

Imagine a proposta:

Feche sua conta no banco onde recebe salário há quinze anos, transfira seus investimentos e venha para uma startup desconhecida.

Resposta natural:

RETURN-CODE = 12

Mas:

Quer experimentar um cartão sem anuidade controlado por aplicativo?

Muito mais fácil.

Esse é um princípio importantíssimo de produto.

Reduza o tamanho da primeira decisão.

O Nubank entrou com algo relativamente simples:

CARTÃO

Depois podia expandir.

É praticamente uma estratégia de:

LAND
AND
EXPAND

Primeiro:

cartão

Depois:

conta

Depois:

Pix

Depois:

empréstimos

Depois:

investimentos

Depois:

seguros

E assim sucessivamente.

O cartão foi quase um:

ENTRY PROGRAM

do ecossistema Nubank.

COBOLzeiros entenderão imediatamente.

Você não chama todo o sistema.

Você chama um ponto de entrada.


Capítulo 5 — O Nubank descobriu o poder do segundo banco

Esse detalhe é gigantesco.

O Nubank não precisava inicialmente substituir Itaú, Bradesco ou Banco do Brasil.

Ele podia coexistir.

Um cliente poderia ter:

SALÁRIO ---------> ITAÚ
POUPANÇA --------> CAIXA
FINANCIAMENTO ---> SANTANDER
CARTÃO ----------> NUBANK

Isso eliminava uma barreira enorme:

switching cost.

Trocar completamente de banco pode ser traumático.

Experimentar um segundo cartão não.

Então milhões de pessoas podiam simplesmente testar.

Se gostassem, aumentavam o relacionamento.

É quase como instalar um programa novo sem desinstalar o antigo.

INSTALL NUBANK
WITHOUT DELETE BANCO-ANTERIOR

A estratégia foi brilhante porque reduziu o medo do consumidor.


Capítulo 6 — UX virou arma competitiva

Durante décadas, bancos venderam sobretudo:

segurança
solidez
tradição
patrimônio
confiança

O Nubank adicionou outra palavra:

experiência

Aplicativo bonito.

Informações claras.

Notificações imediatas.

Controle do cartão.

Atendimento pelo próprio aplicativo.

Linguagem menos burocrática.

Parece pouco?

Não é.

Em software corporativo existe um fenômeno curioso.

Às vezes gastamos:

R$ 100 milhões

melhorando sistemas internos.

Mas uma mudança de três telas altera dramaticamente a percepção do usuário.

Isso é uma lição fundamental.

O cliente não interage com arquitetura.

Ele interage com interfaces.

Você pode ter por trás:

COBOL
Assembler
Java
C
DB2
Kafka
MQ
Cloud

O cliente não se importa.

Ele quer apertar:

PAGAR

e receber:

PAGO

Se der erro, aí todo mundo passa a descobrir sua arquitetura.

É como eletricidade.

Ninguém pergunta qual transformador alimenta a geladeira.

Até faltar luz.


Capítulo 7 — O cartão roxo virou símbolo

Branding também importou enormemente.

Bancos tradicionais frequentemente usavam comunicação séria.

Executivos.

Ternos.

Prédios.

Famílias felizes financiando casas.

O Nubank apareceu com:

ROXO

Uma escolha visual extremamente diferenciada.

O cartão virou objeto de conversa.

E isso gerou algo extraordinário:

pessoas começaram a falar voluntariamente sobre uma instituição financeira.

Pense no absurdo.

Imagine uma conversa em 2015:

— Cara, chegou meu cartão!

— Qual?

— Nubank.

— O roxinho?

Marketing perfeito.

O produto carregava a marca fisicamente dentro da carteira do cliente.

Cada vez que alguém pagava uma conta:

DISPLAY "NUBANK"

Capítulo 8 — O convite criou escassez

Nos primeiros tempos havia fila.

Convites.

Expectativa.

E isso cria um mecanismo psicológico curioso.

Se alguma coisa parece difícil de conseguir, ela parece mais desejável.

É o velho truque do mercado financeiro:

DEMANDA > OFERTA

Então acontecia:

— Você já tem Nubank?

— Ainda não.

— Posso te mandar convite.

Pronto.

O cliente virou canal de aquisição.

Hoje chamaríamos isso de:

REFERRAL

Mas na prática era algo ainda melhor:

marketing social.

A propaganda vinha de alguém conhecido.

Não de um comercial de televisão.


Capítulo 9 — O custo de crescimento mudou

Agora vamos para arquitetura e economia.

Banco tradicional cresceu historicamente construindo:

AGÊNCIA
 |
 +-- imóvel
 +-- funcionários
 +-- segurança
 +-- gerente
 +-- caixa
 +-- telecomunicação
 +-- manutenção
 +-- estrutura administrativa

Cada expansão geográfica significava infraestrutura física.

Um banco digital muda parcialmente a equação.

Novo cliente:

DOWNLOAD
   |
   v
CADASTRO
   |
   v
IDENTIFICAÇÃO
   |
   v
ANÁLISE
   |
   v
CONTA

Isso não significa custo zero.

Nunca significa custo zero.

Existem:

cloud
datacenter
fraude
atendimento
bandeira
processamento
compliance
capital
crédito
cobrança
segurança

Mas o custo marginal assume outra forma.

Essa diferença permite crescer muito rapidamente.

Se dez milhões de pessoas baixarem um aplicativo, você não precisa construir dez milhões de agências.

Seu problema muda.

Agora é:

SCALABILITY

E aí começa outra guerra.


Capítulo 10 — Escalar também dói

Startup tem uma palavra favorita:

scale

Todo mundo quer escalar.

Pouca gente fala da parte divertida.

Quando você escala, tudo que era pequeno vira grande.

Um erro de:

0,01%

parece irrelevante.

Até você ter cem milhões de operações.

Então:

100.000.000 * 0,0001 = 10.000

Dez mil problemas.

Bem-vindo ao mundo real.

COBOLzeiro, guarde essa lição:

sistemas financeiros não podem pensar apenas em funcionalidade; precisam pensar em volume.

Um programa que funciona perfeitamente com:

100 registros

pode virar desastre com:

100 milhões

É por isso que bancos adoram:

performance
capacity planning
WLM
SMF
RMF
batch window
index
partition

Escala transforma detalhes em incidentes.


Capítulo 11 — Dados: o combustível secreto

No começo, um banco tradicional possuía enorme vantagem.

Décadas de histórico.

Milhões de clientes.

Modelos de crédito.

Informações de comportamento.

O Nubank começou pequeno.

Mas conforme ganhou clientes passou a acumular dados.

Imagine:

valor da compra
horário
estabelecimento
pagamentos
atrasos
limites
movimentação
renda
comportamento
frequência

Com escala suficiente, isso vira matéria-prima para análise de risco.

E surge um ciclo extremamente poderoso:

MAIS CLIENTES
      |
      v
MAIS DADOS
      |
      v
MELHORES MODELOS
      |
      v
MELHOR RISCO
      |
      v
MAIS CRÉDITO
      |
      v
MAIS CLIENTES

Esse é um flywheel.

Uma roda que alimenta a si própria.

Para um programador COBOL isso pode parecer distante.

Não é.

Porque em algum ponto todos esses modelos precisam conversar com sistemas transacionais.

Pode existir uma IA sofisticadíssima decidindo:

LIMIT = 8500

Mas alguém precisa registrar isso.

Controlar.

Auditar.

Autorizar.

Persistir.

E eventualmente cobrar.

Nesse momento você encontra novamente:

CORE

Capítulo 12 — Pix mudou as regras do tabuleiro

Depois ocorreu outra transformação gigantesca.

Pix.

Antes, movimentar dinheiro entre bancos tinha mais fricção.

TED.

DOC.

Horários.

Tarifas.

Prazo.

O Pix reduziu dramaticamente isso.

De repente:

BANCO A
  |
 PIX
  |
  v
BANCO B

quase instantaneamente.

Isso teve uma consequência econômica importante:

reduziu o aprisionamento do cliente.

Se dinheiro circula facilmente, possuir conta em vários bancos fica muito menos complicado.

Você pode manter:

BANCO TRADICIONAL
+
FINTECH
+
CORRETORA

e movimentar recursos entre eles.

Para challengers como Nubank isso é excelente.

A infraestrutura nacional passa a reduzir parte da vantagem das redes tradicionais.

Easter egg nº 2

Para quem viveu TED e DOC:

Pix parece MOVE CORRESPONDING.

Só que alguém finalmente colocou:

SYNCHRONOUS

na operação.


Capítulo 13 — Open Finance e o fim do castelo fechado

Depois veio Open Finance.

Conceitualmente, a ideia é poderosa:

os dados financeiros pertencem ao cliente.

Com autorização, informações podem transitar entre instituições.

Isso reduz outro moat tradicional.

Antes:

BANCO
 |
 +-- possui histórico
 +-- conhece cliente
 +-- controla relacionamento

Agora potencialmente:

CLIENTE
 |
 +-- autoriza compartilhamento

Isso aumenta competição.

O banco deixa de ser simplesmente o proprietário da informação.

Vira guardião de dados cuja circulação pode ser autorizada.

É uma mudança filosófica enorme.


Capítulo 14 — Por que os gigantes não esmagaram o Nubank?

Chegamos à pergunta mais interessante.

Itaú tinha dinheiro.

Bradesco tinha dinheiro.

Santander tinha dinheiro.

Banco do Brasil tinha dinheiro.

Todos tinham equipes de TI gigantescas.

Então por que simplesmente não copiaram tudo?

Aqui aparece o famoso:

Innovator's Dilemma.

Imagine que você ganha bilhões com:

ANUIDADE
TARIFA
PACOTE
SERVIÇOS

Aparece alguém dizendo:

— Precisamos eliminar tarifas.

Seu diretor financeiro pergunta:

— Quanto isso custa?

— Alguns bilhões.

— E quanto ganhamos?

— Talvez no futuro evitemos perder clientes.

Excelente reunião.

😂

Para uma startup:

receita existente = 0

Ela pode destruir um modelo econômico porque não tem receita antiga para proteger.

Para uma empresa incumbente:

CANIBALIZAR PRODUTO

é uma decisão dolorosa.

Esse é um dos motivos pelos quais empresas pequenas conseguem ameaçar gigantes.

Elas não possuem passado.

O passado é ativo.

Mas também pode ser peso.


Capítulo 15 — Legado tecnológico versus legado organizacional

Outro ponto importantíssimo.

Quando ouvimos:

LEGADO

pensamos:

COBOL
MAINFRAME

Mas existe legado muito mais perigoso:

LEGADO ORGANIZACIONAL

Exemplo:

— Por que precisamos dessa aprovação?

— Porque sempre foi assim.

— Quem aprovava?

— Um departamento extinto em 2004.

— Então por que ainda aprovamos?

— Não sei.

Esse tipo de coisa existe em toda grande organização.

Veja:

legacy code
legacy process
legacy policy
legacy incentive
legacy hierarchy
legacy culture

Às vezes reescrever o sistema é fácil.

Difícil é reescrever a empresa.


Capítulo 16 — O Nubank mudou os concorrentes

Uma das maiores vitórias de uma inovação acontece quando os concorrentes passam a copiá-la.

Hoje bancos tradicionais oferecem:

app excelente
Pix
cartão virtual
controle digital
conta sem tarifa
atendimento digital
investimentos no app
biometria
notificações

Isso significa que o Nubank venceu todos?

Não.

Significa algo mais interessante:

ele alterou a referência do consumidor.

Antes o cliente comparava:

BANCO A vs BANCO B

Depois passou a comparar:

EXPERIÊNCIA DIGITAL A vs EXPERIÊNCIA DIGITAL B

Isso força todo mundo a melhorar.


Capítulo 17 — Os gigantes continuam gigantes

Não caia na narrativa simplista:

Fintech matou bancos tradicionais.

Não matou.

Os grandes bancos continuam tendo vantagens absurdas.

Corporate banking.

Agronegócio.

Financiamento imobiliário.

Crédito estruturado.

Câmbio.

Tesouraria.

Derivativos.

Seguros.

Gestão patrimonial.

Redes empresariais.

Capital.

Conhecimento regulatório.

Relacionamentos institucionais.

Infraestrutura.

Décadas de dados.

O mundo bancário é muito maior do que cartão de crédito.

Então a disputa não é:

NUBANK VS BANCO

É:

QUAL PARTE DA CADEIA FINANCEIRA
CADA UM CONSEGUE DOMINAR?

Muito mais interessante.


Capítulo 18 — O que um COBOLzeiro iniciante aprende com tudo isso?

Agora chegamos ao café.

Você começou COBOL e pensa:

— O que Nubank tem a ver comigo?

Tudo.

Passo 1 — Aprenda o core

Antes de criticar sistema legado, entenda-o.

Estude:

COBOL
JCL
CICS
DB2
VSAM
IMS
MQ
RACF

Entenda por que cada coisa existe.

Passo 2 — Pense em jornada

Não veja apenas:

PROGRAM A

Veja:

CLIENTE
   |
   v
CANAL
   |
   v
API
   |
   v
MIDDLEWARE
   |
   v
COBOL
   |
   v
DB2

O programa faz parte de uma experiência maior.

Passo 3 — Pergunte onde está a fricção

O gargalo pode não ser CPU.

Pode ser processo.

Pode ser autorização.

Pode ser formulário.

Pode ser arquitetura.

Pode ser gente.

Passo 4 — Não confunda modernização com reescrita

Modernizar pode significar:

expor API
automatizar deploy
melhorar observabilidade
integrar cloud
introduzir DevOps
reduzir etapas manuais

sem apagar o COBOL.

Passo 5 — Aprenda economia

Programador financeiro precisa entender:

receita
custo
risco
fraude
crédito
capital
margem
inadimplência

Seu código existe para sustentar negócio.

Passo 6 — Aprenda dados

Banco moderno é cada vez mais:

transação
+
dados
+
modelo
+
automação

Passo 7 — Nunca subestime UX

Um backend perfeito escondido atrás de uma experiência horrível continua sendo um produto ruim.


Capítulo 19 — O pequeno PERFORM que virou império

Existe algo quase poético na história do Nubank.

Ele não começou tentando resolver:

TODO O SISTEMA FINANCEIRO

Começou resolvendo:

UM PROBLEMA

Cartão.

Sem anuidade.

No smartphone.

Depois executou algo parecido com:

PERFORM EXPAND-PRODUCT
    UNTIL CUSTOMER-BASE = HUGE

Isso é uma lição de arquitetura e de carreira.

Quem começa COBOL às vezes tenta aprender tudo ao mesmo tempo:

COBOL
JCL
CICS
DB2
IMS
MQ
Assembler
Java
Python
Cloud
DevOps
AI

Calma.

Comece pelo cartão roxo.

Escolha seu primeiro problema.

Domine.

Depois expanda.


Capítulo 20 — O verdadeiro Lobo Roxo

No fim das contas, o Nubank não venceu simplesmente porque era digital.

Também não venceu porque bancos antigos eram incompetentes.

Muito menos porque COBOL estava ultrapassado.

Ele cresceu porque uma combinação rara aconteceu ao mesmo tempo:

SMARTPHONE
+
UX
+
BAIXA FRICÇÃO
+
MARCA
+
TIMING
+
DISTRIBUIÇÃO DIGITAL
+
DADOS
+
ESCALA
+
MUDANÇAS REGULATÓRIAS

O cartão roxo foi apenas a face visível.

Por trás dele existia uma tese poderosa:

a experiência bancária podia ser reconstruída colocando o cliente digital no centro.

E existe uma ironia deliciosa.

Os bancos tradicionais passaram décadas criando fortalezas tecnológicas incríveis.

Mainframes.

Redes.

Datacenters.

Sistemas de liquidação.

Processamento massivo.

Segurança.

Redundância.

O Nubank não precisou destruir a fortaleza.

Encontrou uma porta lateral.

Essa porta chamava-se:

EXPERIÊNCIA

Entrou por ali.

Depois que entrou, começou a construir sua própria fortaleza.


Epílogo — Wall Street encontra o CPD

Imagine novamente o salão.

Os grandes bancos continuam sentados.

Só que agora existe outra cadeira na mesa.

Roxa.

O veterano do mainframe olha para o jovem programador COBOL.

— Aprendeu alguma coisa?

O rapaz responde:

— Que startup mata legado?

O veterano dá um gole no café.

— Não.

— Que mainframe morreu?

— Também não.

— Então o quê?

Ele aponta para uma tela onde milhões de transações passam por segundo.

— Sistemas não perdem mercado porque são velhos.

Pausa.

Perdem mercado quando deixam de resolver aquilo que o cliente considera importante.

O novato fica pensando.

Na tela aparece:

TRANSACTION APPROVED

O veterano sorri.

— E outra coisa.

— O quê?

— Nunca confunda uma interface simples com um sistema simples.

Atrás do botão roxo existe um mundo.

Crédito.

Fraude.

Liquidação.

Compliance.

Segurança.

Auditoria.

Dados.

Regulação.

Resiliência.

E, em algum lugar escondido do planeta financeiro, provavelmente um programa escrito décadas atrás ainda está fazendo alguma coisa importantíssima.

Talvez seja COBOL.

Talvez ninguém saiba quem escreveu.

Talvez exista um comentário:

* DO NOT CHANGE THIS ROUTINE.

Sem nenhuma explicação.

O jovem pergunta:

— Posso apagar?

O veterano encara.

— Wall Street tem uma regra.

— Qual?

— Se você não sabe por que existe, não execute DELETE.

Fim do café.

E lembre-se:

na próxima vez que alguém mostrar um aplicativo moderno e disser:

“Isso substituiu o banco antigo.”

Pergunte:

E ONDE LIQUIDA?

Normalmente é aí que a conversa começa a ficar realmente interessante.

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