☕ 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

terça-feira, 15 de setembro de 2026

🕶️ DIABOLIK NO MAINFRAME — Risk Scoring Humano

 

Bellacosa Mainframe e o risk scoring humano

☕ Um Café no Bellacosa Mainframe

🕶️ DIABOLIK NO MAINFRAME — Risk Scoring Humano

Quando o sistema deixa de perguntar “o que você fez?” e começa a perguntar “por que você deixou de se comportar como você mesmo?”

Há uma coisa que Diabolik entende melhor do que muitos sistemas antifraude.

A melhor maneira de atravessar uma porta protegida não é necessariamente arrombá-la.

É fazer com que a porta acredite que você deveria estar entrando por ela.

Máscara correta.

Documento correto.

Horário plausível.

Comportamento esperado.

Uma história suficientemente coerente.

Separadamente, cada detalhe parece normal.

E justamente aí começa nossa história.

Porque, em algum lugar dentro de uma enorme instituição financeira, existe um IBM Mainframe processando milhões de eventos e tentando responder a uma pergunta aparentemente simples:

este comportamento faz sentido para esta pessoa?

Bem-vindo ao Risk Scoring Humano.

E nosso guia será Diabolik.



🕶️ CAPÍTULO 1 — Diabolik não quer parecer Diabolik

Imagine um sistema antifraude bastante primitivo.

Sua lógica poderia ser parecida com:

IF TRANSACTION-AMOUNT > 10000
    MOVE 'HIGH-RISK' TO RISK-LEVEL
END-IF.

Funciona?

Às vezes.

Mas qualquer pessoa que conheça a regra aprende rapidamente que R$ 10.001 chama atenção e R$ 9.999 talvez não.

Esse é o problema das regras determinísticas isoladas.

Diabolik olha para isso e sorri.

Ele não precisa destruir a regra.

Precisa apenas parecer normal para ela.

Um sistema moderno precisa fazer outra pergunta:

R$ 9.999 é normal para quem está fazendo essa operação?

Para uma grande empresa, talvez seja banal.

Para uma conta que recebe R$ 1.800 por mês e nunca movimentou mais de R$ 3.000, pode ser extraordinário.

Portanto:

RISCO ≠ apenas EVENTO

Uma aproximação muito melhor seria:

RISCO =
    EVENTO
  + PESSOA
  + HISTÓRICO
  + CONTEXTO
  + RELACIONAMENTOS
  + TEMPO

É aqui que nasce o Risk Scoring Humano.



🎭 CAPÍTULO 2 — A melhor máscara é uma identidade verdadeira

Sistemas antigos frequentemente tentavam responder:

“Essa pessoa é criminosa?”

Sistemas modernos precisam responder algo mais sutil:

“Esse comportamento combina com essa identidade?”

Essa diferença é gigantesca.

João pode ser um cliente perfeitamente legítimo há quinze anos.

Recebe salário.

Paga supermercado.

Abastece o carro.

Paga escola.

Compra medicamentos.

Viaja uma vez por ano.

Seu comportamento produz uma espécie de impressão digital financeira.

Não precisamos conhecer João pessoalmente para perceber padrões.

JOÃO
│
├── salário mensal
├── supermercado
├── combustível
├── contas domésticas
├── escola
├── financiamento
└── viagens ocasionais

Nenhuma dessas informações isoladamente define João.

Mas juntas produzem seu baseline comportamental.

Agora imagine que alguma coisa muda.

Em uma semana:

JOÃO
│
├── recebe 8 transferências incomuns
├── acessa de novo dispositivo
├── muda telefone
├── realiza operação internacional
├── adiciona beneficiário
└── transfere praticamente todo o saldo

Talvez cada evento seja legítimo.

O problema é a combinação.

Diabolik conseguiu uma identidade verdadeira.

Mas ainda precisa aprender a ser João.



📸 CAPÍTULO 3 — O velho sistema guardava fotografias

Durante décadas, instituições trabalharam muito bem com fotografias cadastrais.

NOME
CPF
ENDEREÇO
RENDA
PROFISSÃO
IDADE
TELEFONE

É uma fotografia.

Ela responde:

Quem é Vagner?

Mas Risk Scoring moderno quer assistir ao filme.

08:03 login
08:04 consulta saldo
08:06 novo favorecido
08:07 alteração cadastral
08:11 transferência
08:13 segunda transferência
08:17 tentativa internacional

Agora temos comportamento.

E comportamento possui uma propriedade fascinante:

ele possui sequência.

Isso significa que:

A + B + C

pode ter significado completamente diferente de:

C + A + B

Exemplo:

troca telefone
→ cadastra dispositivo
→ transfere dinheiro

é diferente de:

transfere dinheiro
→ meses depois troca telefone

Os eventos são semelhantes.

A narrativa é diferente.



🎬 CAPÍTULO 4 — Risk Scoring transforma fotografia em filme

Vamos imaginar um cliente chamado Marco.

Durante 36 meses:

salário → conta
conta → despesas
conta → cartão
conta → investimento

Tudo relativamente previsível.

Então:

DIA 1
novo dispositivo

DIA 2
novo telefone

DIA 3
novo favorecido

DIA 3 + 4 minutos
transferência

DIA 3 + 7 minutos
segunda transferência

Um sistema baseado exclusivamente em valores pode não encontrar nada.

O Risk Engine comportamental observa:

DEVICE_RISK        +15
PROFILE_CHANGE     +10
NEW_BENEFICIARY    +20
VALUE_DEVIATION    +25
VELOCITY           +20
--------------------------------
RISK SCORE          90

Mas atenção.

Isso é apenas um exemplo didático.

Na vida real, scores podem ser produzidos por regras, modelos estatísticos, machine learning, modelos híbridos e sistemas especializados.

O conceito importante é:

sinais pequenos acumulam contexto.



🧮 CAPÍTULO 5 — O Risk Score entra em cena

Vamos criar nosso fictício:

BELLACOSA HUMAN RISK ENGINE — BHRE

Ele recebe eventos:

LOGIN
TRANSACTION
PROFILE_CHANGE
DEVICE_CHANGE
PASSWORD_RESET
BENEFICIARY_ADD
CARD_PURCHASE
PIX
TED
TRANSFER
ATM

Cada evento entra no motor.

No Mainframe poderíamos imaginar componentes como:

CICS
  ↓
COBOL
  ↓
Db2 / VSAM
  ↓
Risk Engine
  ↓
Decision

Para transações financeiras modernas, também poderíamos integrar APIs, mensageria e plataformas analíticas externas.

O mainframe não precisa fazer sozinho toda a ciência de dados.

Ele pode ser justamente o coração transacional que pergunta:

“Posso autorizar?”

E recebe:

APPROVE
REVIEW
CHALLENGE
DECLINE

💳 CAPÍTULO 6 — 200 OK não significa “é confiável”

Imagine:

CLIENTE
   ↓
APP
   ↓
API
   ↓
BANK
   ↓
MAINFRAME

A autenticação está correta.

Token correto.

Senha correta.

Dispositivo reconhecido.

Isso demonstra que determinadas credenciais foram aceitas.

Não demonstra necessariamente que a intenção seja legítima.

Essa distinção é fundamental:

AUTHENTICATION
      ≠
AUTHORIZATION
      ≠
TRUST

Diabolik adora quando confundimos essas três coisas.

Ele não precisa falsificar necessariamente tudo.

Talvez tenha acesso legítimo a uma credencial comprometida.

O sistema precisa analisar contexto.


🧠 CAPÍTULO 7 — Risk Scoring não deveria perguntar apenas “quem é você?”

Perguntas melhores:

Quem é você?

De onde costuma acessar?

Quando costuma acessar?

Quanto costuma movimentar?

Para quem costuma transferir?

Quais dispositivos utiliza?

Qual é sua velocidade normal de operações?

Que relacionamento possui com o destinatário?

Esse comportamento já aconteceu anteriormente?

Isso produz uma identidade dinâmica.

Chamaremos de:

Behavioral Identity.

Não é simplesmente CPF.

É uma combinação histórica de comportamentos.


🕸️ CAPÍTULO 8 — E então descobrimos o grafo

Diabolik consegue imitar Marco.

Excelente.

Mas existe um problema.

Ele precisa mandar o dinheiro para algum lugar.

Surge Maria.

MARCO → MARIA

Nada necessariamente estranho.

Mas Maria recebe também de:

JOÃO ──┐
PEDRO ─┤
ANA ───┼──→ MARIA
LUÍS ──┤
MARCO ─┘

Interessante.

Maria envia para Empresa X.

MARIA → EMPRESA X

Empresa X está relacionada a outras entidades.

Agora nossa análise deixa de olhar somente para transações.

Estamos construindo um:

GRAPH.


🕷️ CAPÍTULO 9 — O grafo destrói algumas máscaras

Uma pessoa pode alterar:

nome utilizado,

telefone,

conta,

empresa,

dispositivo,

endereço.

Mas relacionamentos podem revelar padrões.

Imagine:

PESSOA A
   │
   ├── telefone → PESSOA B
   │
   ├── endereço → EMPRESA C
   │
   ├── dispositivo → CONTA D
   │
   └── transferência → PESSOA E

Cada aresta adiciona contexto.

Agora descobrimos:

PESSOA E
   ↓
EMPRESA F
   ↓
CONTA G
   ↓
PESSOA B

Fechamos um ciclo.

É por isso que Graph Analytics é tão poderoso em fraude e AML.

Ele não pergunta apenas:

Quem recebeu dinheiro?

Pergunta:

Como essas entidades estão relacionadas?


🧩 CAPÍTULO 10 — Risk Scoring humano não significa julgar pessoas

Aqui existe uma distinção ética essencial.

Um sistema não deveria concluir:

“Essa pessoa é criminosa.”

Risk Scoring deve trabalhar com algo muito mais limitado:

“Esta operação apresenta características que justificam controles adicionais.”

Essa diferença protege clientes e instituição.

Score não deveria ser sentença.

Deveria ser sinal.

Por isso podemos ter:

LOW RISK
   ↓
PROCESS

MEDIUM RISK
   ↓
ADDITIONAL AUTHENTICATION

HIGH RISK
   ↓
MANUAL REVIEW

CRITICAL
   ↓
BLOCK / INVESTIGATION

Dependendo da política, legislação e natureza da operação.


🔎 CAPÍTULO 11 — O caso Gritzbach mostra outro tipo de Risk Scoring

Aqui podemos utilizar o caso apenas como analogia analítica, sem transformar acusações ainda controvertidas em fatos.

Segundo a reconstrução jornalística, Antônio Vinícius Lopes Gritzbach teria atravessado simultaneamente diferentes redes de relacionamento envolvendo integrantes do PCC, negócios, dinheiro, criptomoedas, autoridades e policiais. Ele posteriormente tornou-se colaborador do Ministério Público.

A questão interessante para nosso estudo não é tentar reproduzir qualquer “score do PCC”.

É observar algo universal:

pessoas também existem dentro de grafos de confiança.

Imagine abstratamente:

PESSOA
│
├── dinheiro
├── parceiros
├── clientes
├── fornecedores
├── instituições
├── autoridades
└── informações

Quando uma relação muda, outras podem ser afetadas.


⚖️ CAPÍTULO 12 — Trust Score é contextual

Essa é uma descoberta importantíssima.

Uma pessoa não possui universalmente:

TRUST = 72

Ela pode ser simultaneamente:

Banco A       → LOW RISK
Banco B       → UNKNOWN
Empresa C     → TRUSTED
Sistema D     → HIGH RISK

Porque risco depende de contexto.

O mesmo vale para comportamento.

Comprar R$ 8.000 em um restaurante pode ser extraordinário para mim.

Para uma empresa realizando jantar corporativo para 80 pessoas, talvez seja normal.

Portanto:

RISK = EVENT / CONTEXT

e não simplesmente:

RISK = EVENT

🧠 CAPÍTULO 13 — O programador COBOL precisa entender isso

Aqui chegamos ao ponto que frequentemente falta nas formações Mainframe.

O iniciante recebe:

01 WS-RISK-SCORE PIC 9(03).

E pensa:

É um campo numérico de três posições.

Não.

Talvez você esteja olhando para a conclusão de centenas de sinais.

Por trás daqueles três bytes conceituais podem existir:

histórico
perfil
device
geolocalização aproximada
velocity
valor
merchant
beneficiário
produto
canal
horário
relacionamentos
alertas anteriores

O programador Mainframe precisa compreender semântica de negócio, não somente PIC clauses.


💻 CAPÍTULO 14 — Vamos programar um pequeno exemplo

Imagine:

01 WS-RISK-SCORE       PIC 9(03) VALUE ZERO.
01 WS-NEW-DEVICE       PIC X.
01 WS-NEW-BENEFICIARY  PIC X.
01 WS-HIGH-AMOUNT      PIC X.
01 WS-PROFILE-CHANGE   PIC X.

Então:

IF WS-NEW-DEVICE = 'Y'
   ADD 15 TO WS-RISK-SCORE
END-IF

IF WS-NEW-BENEFICIARY = 'Y'
   ADD 20 TO WS-RISK-SCORE
END-IF

IF WS-HIGH-AMOUNT = 'Y'
   ADD 25 TO WS-RISK-SCORE
END-IF

IF WS-PROFILE-CHANGE = 'Y'
   ADD 10 TO WS-RISK-SCORE
END-IF.

Depois:

EVALUATE TRUE
   WHEN WS-RISK-SCORE >= 70
        MOVE 'REVIEW' TO WS-DECISION

   WHEN WS-RISK-SCORE >= 40
        MOVE 'CHALLENGE' TO WS-DECISION

   WHEN OTHER
        MOVE 'APPROVE' TO WS-DECISION
END-EVALUATE.

Didaticamente funciona.

Mas Diabolik imediatamente descobriria um problema.


😈 CAPÍTULO 15 — Diabolik aprende nossas regras

Se:

70 = REVIEW

ele tentará permanecer em:

69

Esse fenômeno é fundamental em sistemas antifraude.

Quando atacantes compreendem controles, adaptam comportamento.

Por isso sistemas precisam evoluir.

Podemos combinar:

RULES
+
STATISTICS
+
BEHAVIOR
+
MACHINE LEARNING
+
GRAPH ANALYTICS
+
HUMAN REVIEW

Nenhum componente precisa ser mágico.

O poder está na combinação.


⏱️ CAPÍTULO 16 — Velocity: Diabolik tem pressa

Um conceito maravilhoso para ensinar ao programador COBOL iniciante é velocity.

Imagine:

09:00 R$ 800
09:03 R$ 900
09:05 R$ 700
09:07 R$ 950
09:09 R$ 850

Nenhuma transação ultrapassa R$ 1.000.

Uma regra:

IF AMOUNT > 10000

não detecta nada.

Mas:

5 TRANSFERS
IN 9 MINUTES

é outro sinal.

Risk Scoring precisa compreender também:

quanto aconteceu em quanto tempo.


🕰️ CAPÍTULO 17 — O tempo transforma o grafo

Agora acrescentamos timestamps:

09:00 A → B
09:02 B → C
09:04 C → D
09:07 D → E

Temos um fluxo.

O grafo agora não mostra apenas:

A — B — C — D — E

Mostra movimento.

Chamamos conceitualmente isso de:

Temporal Graph.

Ele pode revelar mudanças que um grafo estático esconderia.


🏦 CAPÍTULO 18 — E onde entra o IBM Mainframe?

No lugar mais interessante possível.

No coração das operações.

Imagine uma arquitetura:

                 MOBILE
                    │
                 INTERNET
                    │
                    ▼
                 API LAYER
                    │
              z/OS Connect
                    │
                    ▼
┌─────────────────────────────────┐
│            IBM Z                │
│                                 │
│   CICS                          │
│     │                           │
│     ▼                           │
│   COBOL ───────► Db2            │
│     │                           │
│     ▼                           │
│   RISK REQUEST                  │
│     │                           │
└─────┼───────────────────────────┘
      │
      ▼
 ANALYTICS / GRAPH / ML
      │
      ▼
 RISK SCORE
      │
      ▼
 IBM Z
      │
      ▼
DECISION

E isso é importante:

modernização não significa necessariamente retirar o COBOL.

Pode significar permitir que COBOL converse com tecnologias especializadas.


⚡ CAPÍTULO 19 — Porque autorização não pode tomar café

Imagine cartão.

Cliente encosta na máquina.

TAP
 ↓
ACQUIRER
 ↓
NETWORK
 ↓
ISSUER
 ↓
AUTHORIZATION

O cliente está olhando para o terminal.

Não podemos dizer:

“Aguarde vinte minutos enquanto nosso algoritmo termina.”

A decisão precisa ocorrer rapidamente.

É exatamente aí que sistemas transacionais de alta disponibilidade continuam extremamente relevantes.

Risk Scoring precisa entrar no fluxo sem destruir SLA.


🔐 CAPÍTULO 20 — False Positive: quando prendemos o mordomo

Existe outro perigo.

Se o sistema ficar paranoico:

QUALQUER COISA DIFERENTE
        ↓
      BLOCK

teremos milhares de clientes legítimos irritados.

Chamamos isso de:

false positive.

O cliente viajou para Roma.

Compra jantar.

Sistema:

FRAUDE!

Cliente:

Estou com fome!

😄

Risk Scoring precisa equilibrar:

FRAUD LOSS
     ↕
CUSTOMER FRICTION

Bloquear tudo é fácil.

Autorizar corretamente é difícil.


🎯 CAPÍTULO 21 — Risk Score não é prova

Isso merece ficar gravado no monitor do programador:

RISK SCORE ≠ GUILT

Score 92 não significa:

“92% criminoso.”

Pode significar apenas que um modelo específico identificou uma combinação de sinais considerada de alto risco segundo sua própria calibração.

A interpretação depende do modelo.

Esse cuidado torna-se ainda mais importante quando falamos em Risk Scoring Humano.

Algoritmos podem produzir vieses.

Dados podem estar errados.

Cadastros podem estar desatualizados.

Relacionamentos podem ser coincidências.

Por isso decisões de grande impacto precisam de governança adequada.


🧪 CAPÍTULO 22 — Explainability: por que deu 92?

Imagine o analista recebendo:

RISK SCORE = 92

Ele pergunta:

Por quê?

Sistema:

Porque sim.

Inaceitável.

Precisamos de reason codes.

R01 NEW DEVICE
R07 NEW BENEFICIARY
R13 UNUSUAL AMOUNT
R22 HIGH VELOCITY
R31 GRAPH RELATION

Então:

SCORE 92

REASONS:
HIGH VELOCITY
NEW DEVICE
NEW BENEFICIARY
BEHAVIOR DEVIATION

Agora existe explicabilidade operacional.

E o COBOL pode desempenhar papel importantíssimo na integração desses reason codes ao fluxo transacional.


🗃️ CAPÍTULO 23 — Não jogue fora os dados antigos!

Aqui existe uma vantagem maravilhosa dos ambientes Mainframe.

Histórico.

Décadas de histórico podem existir.

Isso é ouro para análise comportamental — desde que seja utilizado com governança, finalidade legítima, qualidade e respeito às regras de proteção de dados.

Porque comportamento exige comparação:

HOJE
versus
ONTEM
versus
30 DIAS
versus
1 ANO

Um sistema que conhece apenas hoje não conhece comportamento.

Conhece eventos.


🕵️ CAPÍTULO 24 — Diabolik finalmente comete seu erro

Nosso Diabolik conseguiu:

credencial,

identidade,

dispositivo,

horário plausível,

valor plausível.

Ele parece perfeito.

Mas precisa transferir recursos.

O sistema observa:

DIABOLIK-AS-MARCO
        ↓
     CONTA X
        ↓
     CONTA Y
        ↓
     EMPRESA Z

E o Graph Engine percebe:

EMPRESA Z
   ↑
CONTA Q
   ↑
CASO ANTERIOR

A transação não era necessariamente anormal.

O relacionamento era.

E finalmente encontramos aquilo que Diabolik não conseguiu falsificar perfeitamente:

o contexto.


🧠 CAPÍTULO 25 — A verdadeira evolução do antifraude

Primeira geração:

TRANSACTION RULES

Segunda:

TRANSACTION + PROFILE

Terceira:

TRANSACTION + PROFILE + BEHAVIOR

Quarta:

TRANSACTION
+
PROFILE
+
BEHAVIOR
+
DEVICE
+
NETWORK
+
GRAPH
+
TIME

E então entramos no território que chamo aqui de:

HUMAN RISK SCORING

Não porque estejamos julgando o ser humano.

Mas porque estamos tentando compreender o comportamento dentro de seu contexto humano e relacional.


🧑‍💻 CAPÍTULO 26 — O que o COBOLista iniciante deve aprender

Quando encontrar:

IF RISK-SCORE > 80

não continue lendo imediatamente.

Pergunte:

Quem calculou esse score?

Quais eventos participaram?

Qual janela temporal?

O score expira?

É transacional ou cadastral?

Quais reason codes existem?

O que acontece quando o serviço de risco está indisponível?

Essa última pergunta é especialmente Mainframe.

RISK ENGINE DOWN

E agora?

FAIL OPEN?

Autoriza?

FAIL CLOSED?

Recusa?

FALLBACK RULES?

Usa regras locais?

Essa decisão pode valer milhões.


🚨 CAPÍTULO 27 — 03:17

Nosso easter egg Bellacosa aparece.

03:17 da manhã.

O telefone toca.

War Room.

Fraud Decision Service latency: 4.8 seconds
Authorization queue increasing
Timeout rate: 17%

Alguém diz:

“Vamos bypassar o Risk Engine.”

Silêncio.

Porque isso resolveria performance.

Mas poderia abrir a porta.

Outro propõe:

“Vamos bloquear tudo.”

Também resolveria fraude.

E destruiria o negócio.

O verdadeiro engenheiro Mainframe pergunta:

Qual é o fallback aprovado?

Essa frase separa improvisação de engenharia.


☕ CAPÍTULO 28 — A lição de Diabolik

Durante toda a história procurávamos o homem de máscara preta.

Esse era nosso erro.

Diabolik nunca quis que víssemos a máscara.

Queria que víssemos:

CLIENTE NORMAL

Risk Scoring evoluiu justamente porque fraude sofisticada não precisa parecer fraude.

Pode parecer:

uma compra,

uma transferência,

um login,

uma empresa,

uma conta,

um cliente.

Tudo aparentemente legítimo.

Até observarmos:

QUEM
+
O QUÊ
+
QUANDO
+
ONDE
+
COMO
+
COM QUEM
+
QUANTAS VEZES
+
EM QUE SEQUÊNCIA

Então surge uma história.


🕶️ EPÍLOGO — O Mainframe não procura criminosos

Essa talvez seja a mensagem mais importante para o programador iniciante.

O IBM Mainframe não deveria funcionar como juiz.

O Risk Engine também não.

Eles processam sinais.

EVENT
   ↓
CONTEXT
   ↓
HISTORY
   ↓
RELATIONSHIP
   ↓
RISK
   ↓
DECISION
   ↓
EVIDENCE

E boas arquiteturas mantêm algo fundamental:

rastreabilidade.

Precisamos saber:

qual informação entrou,

qual regra executou,

qual modelo respondeu,

qual score retornou,

qual reason code apareceu,

qual decisão foi tomada,

quando aconteceu

e qual versão estava em produção.

Porque um dia alguém perguntará:

“Por que essa transação foi recusada?”

E PORQUE WS-RISK > 80 não será resposta suficiente.

Diabolik talvez consiga enganar uma regra.

Talvez consiga enganar uma câmera.

Talvez consiga uma identidade perfeita.

Talvez consiga inclusive parecer estatisticamente normal durante algum tempo.

Mas quanto mais dimensões independentes um sistema correlaciona — histórico, comportamento, dispositivo, velocidade, relacionamentos e tempo — mais difícil se torna sustentar uma identidade artificial coerente.

Essa é a batalha moderna.

Não é:

COBOL contra inteligência artificial.

É:

COBOL
+
CICS
+
Db2
+
APIs
+
EVENTS
+
RULES
+
ML
+
GRAPH ANALYTICS
+
HUMAN ANALYST

Cada tecnologia fazendo aquilo que sabe fazer melhor.

E no centro de tudo continua existindo aquela pergunta simples que começou nossa investigação:

“Isto é normal?”

Diabolik ajusta a gravata, olha para o terminal e sorri.

O terminal responde:

TRANSACTION........... VALID
IDENTITY.............. VALID
AUTHENTICATION........ VALID
AMOUNT................ NORMAL

BEHAVIOR.............. UNUSUAL
VELOCITY.............. UNUSUAL
GRAPH RELATION........ HIGH RISK

RISK SCORE............ 92
DECISION.............. REVIEW

Pela primeira vez, Diabolik para de sorrir.

O sistema não descobriu necessariamente quem ele é.

Descobriu algo muito mais interessante.

Ele não está se comportando como a pessoa que afirma ser.

Um Café no Bellacosa Mainframe

Onde até Diabolik descobre que enganar um IF é fácil. Difícil é enganar quarenta anos de histórico.



Para ir mais longe

https://eljefemidnightlunch.blogspot.com/2024/10/diabolik-no-mainframe-o-roubo-perfeito.html

🧟 Mainframe Evolution — O Pesadelo Open Source que Entrou na LPAR

 

Bellacosa Mainframe e o Mainframe Evolution

☕ Um Café no Bellacosa Mainframe

🧟 Mainframe Evolution — O Pesadelo Open Source que Entrou na LPAR

Segurança, observabilidade e escala no IBM Z, investigadas sob a ótica de Dylan Dog, o Investigador do Pesadelo



Há casos que chegam ao escritório de Dylan Dog embrulhados em jornais velhos, acompanhados por fotografias borradas e pelo depoimento de alguma testemunha dizendo ter visto uma criatura impossível atravessar a parede à meia-noite.

Este caso chegou de maneira ainda mais suspeita.

Em uma apresentação apareceu a frase:

Mainframe Evolution: Securing, Monitoring, and Scaling with Next-Gen Open Source

Dylan olhou para o papel.

Groucho olhou para Dylan.

— Chefe, acho que descobriram algo mais antigo que os vampiros.

— O quê?

— COBOL.

Silêncio.

Em algum lugar distante, uma fita magnética girou sozinha.

Bem-vindo a mais uma investigação do Bellacosa Mainframe.

Desta vez nosso cliente afirma que existe open source dentro do mainframe.

Para muitos programadores, isso parece perfeitamente normal em 2026.

Para outros, principalmente aqueles que ainda imaginam o mainframe como uma fortaleza isolada onde todos entram pelo TSO e qualquer alteração precisa de três formulários, dois CABs e o sangue de um analista de produção, a afirmação parece paranormal.

Dylan Dog foi chamado.

Vamos investigar.



🕵️ CAPÍTULO 1 — O cadáver que se recusava a morrer

A primeira coisa que chamou a atenção de Dylan foi a idade da vítima.

O mainframe já havia sido declarado morto tantas vezes que seu prontuário parecia uma coleção de obituários.

Client/server iria matá-lo.

Depois Unix.

Depois Windows.

Depois servidores x86.

Depois Java.

Depois a Web.

Depois cloud.

Depois containers.

Depois Kubernetes.

Agora inteligência artificial.

Dylan abriu o arquivo.

STATUS: EXECUTING.

— Estranho — comentou ele.

Muito estranho.

Talvez estivéssemos procurando o cadáver errado.

Porque o IBM Z moderno não é simplesmente um computador gigantesco escondido no porão executando programas COBOL escritos quando os Beatles ainda tocavam juntos.

Ele é uma plataforma capaz de reunir tecnologias de gerações muito diferentes.

Podemos encontrar algo parecido com:

                 IBM Z
                   │
        ┌──────────┼──────────┐
        │          │          │
       z/OS       Linux      z/VM
        │          │          │
      COBOL      Python    Virtualização
      CICS       Java
      IMS        Open Source
      Db2        Containers
      MQ

A primeira pista estava diante de Dylan.

Talvez evolução do mainframe não significasse substituição.

Significasse incorporação.



🧟 CAPÍTULO 2 — Frankenstein não precisava morrer

Existe uma velha tentação em tecnologia.

Quando encontramos algo antigo, imediatamente pensamos:

"Precisamos substituir isso."

Imagine um banco possuindo milhões de linhas COBOL responsáveis por contas, cartões, pagamentos, empréstimos e liquidação financeira.

Alguém entra na reunião e anuncia:

— Temos uma ideia revolucionária! Vamos reescrever tudo!

Dylan provavelmente perguntaria:

— Por quê?

Essa é uma excelente pergunta.

Modernização não significa obrigatoriamente:

COBOL
  ↓
Java

Muito menos:

MAINFRAME
   ↓
CLOUD

Podemos modernizar ao redor da aplicação:

               Git
                │
VS Code ───► COBOL ◄─── CI/CD
                │
             Testing
                │
          Security Scan
                │
              APIs
                │
         Observability

O programa continua COBOL.

A lógica continua executando no z/OS.

CICS continua administrando transações.

Db2 continua guardando dados.

RACF continua controlando acessos.

Mas a maneira como desenvolvemos, testamos, implantamos, observamos e integramos essas aplicações pode mudar radicalmente.

Nosso monstro de Frankenstein não precisava ser destruído.

Precisávamos apenas entender como ele funcionava.



🔐 CAPÍTULO 3 — SECURING: alguém abriu novas portas no castelo

Dylan chegou à primeira cena do crime.

Uma enorme fortaleza.

Sobre o portão estava escrito:

RACF

Nada particularmente assustador.

O mainframe conhece controle de acesso há décadas.

Usuários possuem identidades.

Recursos possuem regras.

Datasets podem ser protegidos.

Transações CICS podem ser protegidas.

Recursos do sistema podem ser protegidos.

Aplicações podem ser protegidas.

Então apareceu o open source.

Depois vieram APIs.

CLI.

VS Code.

Git.

Jenkins.

Zowe.

Containers.

OpenShift.

Linux.

Cloud.

Service accounts.

Automação.

De repente, nosso castelo ganhou dezenas de portas.

                    IBM Z
                      │
     ┌────────────────┼────────────────┐
     │                │                │
    API              CLI             IDE
     │                │                │
 Jenkins            Zowe            VS Code
     │
   CI/CD

Nenhuma dessas tecnologias é inerentemente um problema.

O problema aparece quando adicionamos conectividade sem adicionar governança.



👻 CAPÍTULO 4 — O fantasma das credenciais

Groucho apareceu segurando um papel.

— Dylan, encontrei a senha.

— Onde?

— No script.

Isso é exatamente o tipo de fantasma que ninguém quer encontrar.

Imagine:

USER=DEPLOY01
PASSWORD=SUPERSECRET123

dentro de um script versionado.

Ou um token esquecido em um arquivo de configuração.

Ou uma service account com privilégios maiores que o necessário.

Automação multiplica produtividade.

Mas também pode multiplicar erros.

Um humano pode cometer um erro uma vez.

Um pipeline consegue cometer o mesmo erro automaticamente quinhentas vezes antes do café.

Por isso modernização exige pensar em:

Identity
Authentication
Authorization
Certificates
TLS
Secrets
Tokens
Audit
Least Privilege
API Security
Logging

O velho princípio continua válido:

Quem é você, o que você pode fazer e quem registrará que você fez?

RACF não ficou obsoleto porque apareceu DevOps.

Na verdade, DevOps torna essas perguntas ainda mais importantes.



🧪 CAPÍTULO 5 — Zowe entra na investigação

Dylan encontrou outra inscrição:

ZOWE

Aqui encontramos uma das pontes mais interessantes entre o mainframe tradicional e ferramentas modernas.

Imagine nosso jovem programador COBOL.

Ele conhece:

Git
VS Code
Terminal
REST
JSON
CLI

Então alguém apresenta:

TSO
ISPF
SDSF
JCL
3270

Nada disso é ruim.

Mas existe uma curva de aprendizagem.

Uma proposta importante do Zowe é permitir interfaces familiares ao desenvolvedor moderno para interação com o ecossistema z/OS.

Simplificando bastante:

VS Code ──────┐
              │
CLI ──────────┤
              │
REST ─────────┼──► Zowe ───► z/OS
              │
Scripts ──────┤
              │
Automation ───┘

Isso não significa abolir ISPF.

Nem significa transformar z/OS em Linux.

Significa criar novas maneiras de conversar com a plataforma.

Dylan anotou:

O suspeito não destruiu a porta antiga. Construiu outra entrada.


👁️ CAPÍTULO 6 — MONITORING: o mainframe sempre esteve olhando

Aqui nossa investigação fica especialmente interessante.

O mundo distribuído descobriu recentemente uma palavra maravilhosa:

observability.

Logs!

Metrics!

Traces!

Dashboards!

Alertas!

Dylan quase sorriu.

Porque no porão do mainframe encontrou arquivos muito mais antigos:

SMF
RMF
SYSLOG
OPERLOG
WLM
CICS Statistics
Db2 Accounting
IMS Logs
MQ Statistics

O mainframe sempre produziu uma quantidade extraordinária de informações operacionais.

Então qual é a novidade?

Correlação.


🔎 CAPÍTULO 7 — O cliente não sabe o que é uma LPAR

Imagine Maria pagando R$100 usando o celular.

Para ela:

CELULAR
  ↓
PAGAMENTO

Simples.

Agora acompanhemos o que pode acontecer por trás:

Mobile App
    ↓
Internet
    ↓
API Gateway
    ↓
OpenShift
    ↓
Java
    ↓
MQ
    ↓
z/OS Connect
    ↓
CICS
    ↓
COBOL
    ↓
Db2

Maria liga:

— Meu pagamento demorou.

Ela não diz:

"Observei um aumento no response time da transaction class associada ao CICS."

Seria fantástico se dissesse.

Mas não diz.

Ela quer saber por que o botão demorou.

A empresa precisa investigar a transação inteira.

Esse é o grande salto entre simplesmente monitorar componentes e observar serviços distribuídos.


🔦 CAPÍTULO 8 — A lanterna chamada Trace ID

Dylan coloca uma etiqueta na vítima:

TRACE-ID: BELLACOSA-0317

Agora imagine essa identificação acompanhando a solicitação:

APP
 │
 │ 0317
 ▼
API
 │
 │ 0317
 ▼
OPENSHIFT
 │
 │ 0317
 ▼
MQ
 │
 │ 0317
 ▼
CICS
 │
 │ 0317
 ▼
COBOL
 │
 │ 0317
 ▼
DB2

Agora temos uma investigação de verdade.

Podemos descobrir:

APP            120 ms
API             80 ms
OPENSHIFT       90 ms
MQ              40 ms
CICS            70 ms
COBOL           20 ms
DB2           3.900 ms

A aplicação demorou aproximadamente 4,3 segundos.

E finalmente encontramos o suspeito.

Não era COBOL.

Era uma consulta no banco.

O pobre COBOL estava sendo acusado porque morava no bairro errado.


🩸 CAPÍTULO 9 — OpenTelemetry encontra SMF

Aqui existe uma possibilidade particularmente fascinante.

De um lado temos o universo tradicional:

SMF
RMF
WLM
CICS
Db2
IMS
MQ

Do outro:

OpenTelemetry
Prometheus
Grafana
Elastic
OpenSearch
Jaeger

Historicamente eles podem parecer dois mundos.

Mas uma aplicação empresarial moderna pode atravessar ambos.

Portanto, o verdadeiro objetivo passa a ser:

             BUSINESS TRANSACTION
                     │
       ┌─────────────┴─────────────┐
       │                           │
 DISTRIBUTED WORLD             MAINFRAME
       │                           │
 OpenTelemetry                   SMF
 Prometheus                      RMF
 Containers                      WLM
 Kubernetes                      CICS
 APIs                            Db2
       │                           │
       └─────────────┬─────────────┘
                     │
               OBSERVABILITY

Agora podemos começar a responder não apenas:

"A CPU está boa?"

Mas:

"Por que o cliente não conseguiu concluir a compra?"

Essa segunda pergunta vale dinheiro.


📈 CAPÍTULO 10 — SCALING: o monstro começou a crescer

Nosso terceiro mistério é escala.

Alguém poderia dizer:

— Finalmente Kubernetes ensinará mainframe a escalar!

Nesse momento talvez Dylan pedisse para Groucho retirar a pessoa da sala.

Mainframes foram construídos justamente para executar workloads enormes.

z/OS possui uma longa história de administração sofisticada de workloads.

Temos conceitos como:

LPAR
WLM
Parallel Sysplex
Coupling Facility
Capacity
Workload Management

O que mudou foi o ambiente ao redor.

Imagine:

               INTERNET
                   │
             LOAD BALANCER
                   │
          ┌────────┼────────┐
          │        │        │
         POD      POD      POD
          │        │        │
          └────────┼────────┘
                   │
                  MQ
                   │
                CICS
                   │
                COBOL
                   │
                 DB2

Kubernetes pode aumentar pods.

Ótimo.

Mas isso não significa capacidade infinita.


☠️ CAPÍTULO 11 — O horror do autoscaling cego

Aqui mora um monstro interessante.

Suponhamos:

3 PODS

O sistema detecta carga elevada.

Então:

3 → 6 → 12 → 24 → 48 PODS

Fantástico!

Exceto que todos atacam o mesmo backend.

48 PODS
   │
   │
   ▼
   MQ
   │
   ▼
  CICS
   │
   ▼
  DB2

Escalar frontend sem compreender backend pode simplesmente produzir um ataque DDoS patrocinado pela própria empresa.

Essa é uma das grandes lições de arquitetura híbrida.

Precisamos compreender:

  • throughput;

  • concorrência;

  • filas;

  • limites;

  • CPU;

  • I/O;

  • locks;

  • conexões;

  • response time;

  • prioridades;

  • capacidade do backend.

Escalabilidade não significa "crie mais coisas".

Significa administrar capacidade do sistema completo.


🐧 CAPÍTULO 12 — Há um pinguim no porão

Dylan ouviu um barulho.

Desceu mais um andar.

Encontrou Linux.

Sim, Linux no mainframe.

Essa confusão ainda existe:

MAINFRAME = z/OS

Não exatamente.

IBM Z pode hospedar diferentes ambientes e workloads.

Podemos pensar conceitualmente em:

IBM Z
 │
 ├── z/OS
 │    ├── COBOL
 │    ├── CICS
 │    ├── IMS
 │    └── Db2
 │
 ├── Linux on Z
 │    ├── Java
 │    ├── Python
 │    └── Open Source
 │
 └── Virtualização
      ├── z/VM
      └── outros ambientes suportados

Isso muda completamente a imagem mental de "computador antigo".

O hardware permanece centralizado e extremamente robusto.

O ecossistema de software, entretanto, tornou-se bastante heterogêneo.


🔧 CAPÍTULO 13 — DevOps encontra COBOL

Nosso programador iniciante agora recebe uma missão.

Modificar:

CUSTOMER.cbl

No fluxo tradicional poderia acontecer:

ISPF
 ↓
EDIT
 ↓
JCL
 ↓
COMPILE
 ↓
LINK
 ↓
TEST

Esse fluxo continua perfeitamente válido em muitos ambientes.

Mas podemos criar:

VS Code
   ↓
Git
   ↓
Commit
   ↓
Pull Request
   ↓
Automated Build
   ↓
Unit Test
   ↓
Security Scan
   ↓
Deploy
   ↓
Monitoring

Observe o detalhe.

Em nenhum momento fomos obrigados a escrever:

rm CUSTOMER.cbl

O COBOL continua lá.

Mudamos o software delivery lifecycle.

Essa diferença é fundamental.


🧠 CAPÍTULO 14 — O erro clássico: confundir modernização com linguagem

Dylan encontra finalmente uma testemunha.

— Eu vi tudo! Modernizaram o sistema!

— Como?

— Converteram COBOL para Java!

Dylan fecha o bloco de notas.

Isso pode ser modernização.

Mas não é a definição de modernização.

Um programa COBOL pode estar integrado a:

Git
CI/CD
Automated Tests
APIs
Modern IDE
Observability
Security Automation
AI Assistance

Enquanto um programa Java pode viver em:

FTP
manual deployment
no tests
hardcoded passwords
no monitoring
no documentation

Qual dos dois é realmente "legado"?

A linguagem não responde sozinha.

Processo, arquitetura, governança e manutenibilidade importam enormemente.


🕸️ CAPÍTULO 15 — O verdadeiro monstro é a complexidade

Depois de horas investigando, Dylan percebe algo.

Não existe apenas um assassino.

Existe uma teia.

                    USER
                      │
                     APP
                      │
                     API
                      │
                  KUBERNETES
                      │
                      MQ
                      │
               z/OS CONNECT
                      │
                    CICS
                      │
                    COBOL
                      │
                     DB2

Cada camada possui:

Security
Monitoring
Configuration
Capacity
Networking
Logging
Authentication
Authorization
Versioning
Dependencies

É aqui que open source pode ajudar muito.

Mas também é onde ele pode criar problemas se for adotado simplesmente porque "todo mundo usa".

Open source não elimina complexidade.

Às vezes ele democratiza ferramentas para administrá-la.

E às vezes adiciona outra camada.

Arquitetura continua exigindo engenharia.


🧰 CAPÍTULO 16 — O arsenal do Investigador do Pesadelo

Se Dylan Dog fosse engenheiro de plataforma IBM Z, sua mala talvez tivesse:

┌─────────────────────────────┐
│ DYLAN DOG TOOLBOX           │
├─────────────────────────────┤
│ RACF       → Security       │
│ SMF        → Evidence       │
│ RMF        → Performance    │
│ WLM        → Workloads      │
│ SDSF       → Operations     │
│ Zowe       → Integration    │
│ Git        → Versioning     │
│ CI/CD      → Automation     │
│ OTel       → Tracing        │
│ Grafana    → Visualization  │
│ Linux      → Open ecosystem │
└─────────────────────────────┘

Mas ferramentas não resolvem crimes sozinhas.

Precisamos saber que pergunta fazer.


🎓 CAPÍTULO 17 — O novo programador mainframe

Talvez esta seja a maior transformação.

Durante décadas uma trilha de formação poderia começar assim:

3270
 ↓
TSO
 ↓
ISPF
 ↓
JCL
 ↓
COBOL
 ↓
VSAM
 ↓
CICS
 ↓
DB2

Eu ainda ensinaria essa base.

Porque abstração sem fundamento produz profissionais que sabem apertar botões, mas não entendem o que acontece quando o botão falha.

Porém acrescentaria outra coluna:

MAINFRAME CLÁSSICO       ENGENHARIA MODERNA

TSO/ISPF                 VS Code
JCL                      Pipelines
COBOL                    Git
CICS                     APIs
Db2                      Observability
RACF                     IAM concepts
SDSF                     Automation
SMF                      Telemetry
USS                      Open Source

Não são inimigos.

São camadas de conhecimento.

O profissional interessante do futuro sabe atravessar essa ponte.


🧟 CAPÍTULO 18 — E a inteligência artificial?

Naturalmente nosso monstro mais recente aparece.

IA pode ajudar a:

explicar COBOL
gerar documentação
analisar dependências
sugerir testes
interpretar mensagens
auxiliar debugging
explicar JCL
produzir scripts
examinar código legado

Fantástico.

Mas existe uma regra Dylan Dog para isso:

Não confie no monstro apenas porque ele fala educadamente.

Código gerado precisa ser revisado.

JCL precisa ser entendido.

Sugestões precisam ser validadas.

Segurança precisa permanecer sob controle.

Imagine uma IA sugerindo:

PERMIT * CLASS(DATASET) ACCESS(ALTER)

e alguém respondendo:

"A inteligência artificial recomendou."

Nesse momento o verdadeiro terror começou.

IA deve aumentar a capacidade do engenheiro.

Não abolir julgamento técnico.


🕯️ CAPÍTULO 19 — O Easter Egg das 03:17

Às 03:17, todos os dashboards ficaram vermelhos.

CPU?

Normal.

Storage?

Normal.

CICS?

UP.

Db2?

UP.

MQ?

UP.

Kubernetes?

Healthy.

O operador escreveu:

03:17:22 - USERS REPORTING PAYMENT TIMEOUT

Dylan olhou para o dashboard.

Tudo verde.

Olhou novamente para o cliente.

Tudo quebrado.

E finalmente percebeu o verdadeiro pesadelo:

Todos monitoravam componentes. Ninguém monitorava a experiência completa.

O sistema poderia estar tecnicamente saudável enquanto o serviço estava funcionalmente morto.

Essa talvez seja a melhor explicação de por que observabilidade tornou-se tão importante.


🧩 CAPÍTULO 20 — Security + Monitoring + Scaling

Finalmente podemos retornar ao título:

Securing

Garantir que as novas portas abertas pela modernização não destruam décadas de controles.

Monitoring

Sair da visão isolada do componente e compreender a transação ponta a ponta.

Scaling

Fazer ambientes distribuídos e mainframe responderem à demanda sem simplesmente transferir o gargalo de uma camada para outra.

E existe um quarto elemento escondido:

Integrating

Porque todos os anteriores dependem dele.

            MAINFRAME EVOLUTION
                    │
     ┌──────────────┼──────────────┐
     │              │              │
 SECURITY      OBSERVABILITY     SCALE
     │              │              │
     └──────────────┼──────────────┘
                    │
              INTEGRATION
                    │
                OPEN SOURCE
                    │
              AUTOMATION
                    │
                 IBM Z

☕ EPÍLOGO — Dylan fecha o caso

O sol começava a nascer.

Groucho trouxe café.

Dylan fechou a pasta.

Na capa escreveu:

CASE CLOSED?

Depois riscou o ponto de interrogação.

E tornou a colocá-lo.

Porque sistemas nunca ficam realmente prontos.

Eles evoluem.

O ponto central de Mainframe Evolution: Securing, Monitoring, and Scaling with Next-Gen Open Source não precisa ser interpretado como uma guerra entre dois mundos.

Não é:

MAINFRAME
   VS
OPEN SOURCE

Também não é:

OLD
 ↓
DELETE
 ↓
NEW

É algo muito mais interessante:

       60+ ANOS DE ENGENHARIA
                │
                ▼
             IBM Z
                │
      ┌─────────┼─────────┐
      │         │         │
    z/OS      Linux    Open Source
      │         │         │
 COBOL/CICS    Apps      Tools
 Db2/IMS/MQ   Cloud     Automation
      │         │         │
      └─────────┼─────────┘
                │
              APIs
                │
              Git
                │
             CI/CD
                │
         Observability
                │
            Security
                │
               AI
                │
                ▼
       MODERN ENTERPRISE

E isso nos conduz a uma conclusão deliciosa para alguém que trabalha com mainframe.

Durante décadas perguntaram:

"Quando o mainframe vai morrer?"

Talvez a pergunta estivesse errada.

A pergunta mais interessante em 2026 é:

"Quantas tecnologias novas o mainframe ainda conseguirá absorver sem deixar de ser mainframe?"

Até agora, a resposta parece ser:

muitas.

Talvez seja exatamente isso que explique sua longevidade.

O mainframe não sobreviveu apesar das mudanças.

Em boa medida, sobreviveu porque aprendeu a incorporá-las.

Dylan Dog saiu do data center.

As luzes se apagaram.

Uma última mensagem apareceu no console:

IEF404I BELLACOSA - ENDED - TIME=04.17.00

Groucho olhou para a tela.

— Então o monstro morreu?

Dylan vestiu o casaco.

— Não.

— E agora?

Ao fundo, outra mensagem apareceu:

$HASP100 BELLACOSA ON READER

O JOB seguinte acabara de entrar.

Bellacosa Mainframe — porque no mainframe até os fantasmas têm retrocompatibilidade.



segunda-feira, 14 de setembro de 2026

💳 BELLACARD — Como seria um sistema de cartões de crédito dentro de um IBM Mainframe?

 

Bellacosa Mainframe e o processamento do cartão de credito

☕ Um Café no Bellacosa Mainframe

💳 BELLACARD — Como seria um sistema de cartões de crédito dentro de um IBM Mainframe?

Do “BIP!” da maquininha ao COBOL, CICS, Db2, MQ, JCL, RACF, criptografia, antifraude, clearing, settlement e bilhões de transações que ninguém percebe.

Imagine a cena.

Você entra numa cafeteria, pede um café, aproxima o cartão da maquininha e...

BIP!

TRANSAÇÃO APROVADA
R$ 17,50

Você guarda o cartão, pega o café e continua a vida.

Talvez tenham se passado dois segundos.

Para o consumidor, acabou.

Para um programador mainframe curioso, porém, aconteceu uma pequena maravilha tecnológica.

Aqueles poucos segundos podem envolver terminal de pagamento, adquirente, rede de cartões, banco emissor, sistemas de autorização, criptografia, verificação do cartão, consulta de limites, regras de segurança, sistemas antifraude, bancos de dados, logs, mensagens entre plataformas e uma resposta que precisa percorrer boa parte desse caminho no sentido contrário.

E ainda não acabou.

Mais tarde haverá processamento financeiro, clearing, settlement, conciliação, lançamento da compra, fechamento da fatura, eventual parcelamento, pagamento, contabilização, estorno, contestação e talvez até um chargeback.

A humilde compra do café abriu uma pequena saga computacional.

E é exatamente por isso que cartões de crédito são um excelente laboratório para entender por que mainframes existem.

Então coloque café na caneca.

Hoje construiremos mentalmente o:

💳 BELLACARD — Credit Card Processing System for z/OS



Não será o projeto real de nenhum banco ou bandeira. Será uma arquitetura didática para entendermos como tecnologias como COBOL, CICS, Db2, MQ, JCL/JES2, RACF, criptografia, SMF, WLM e Parallel Sysplex podem participar de um grande sistema financeiro.



🏪 Capítulo 1 — Tudo começa com R$ 100

Imagine uma compra:

CLIENTE:       JOÃO
VALOR:         R$ 100,00
ESTABELECIMENTO: CAFÉ DO MAINFRAME
FORMA:         CARTÃO

O cartão é apresentado.

A maquininha não conhece necessariamente o saldo da conta do cliente.

O estabelecimento também não.

A adquirente não é necessariamente quem concedeu o crédito.

Existe uma cadeia.

Simplificando:

CARDHOLDER
    │
    ▼
MERCHANT
    │
    ▼
ACQUIRER
    │
    ▼
CARD NETWORK
    │
    ▼
ISSUER

Visa e Mastercard, por exemplo, operam redes que conectam os participantes do ecossistema.

O banco emissor é quem conhece o cartão, sua situação, conta relacionada, limite e diversas regras necessárias para decidir se aquela operação pode prosseguir.

Portanto, eventualmente surge uma pergunta:

“Banco, você autoriza esta compra?”

É aí que nosso BELLACARD acorda.



📨 Capítulo 2 — Uma mensagem bate à porta

Imagine que recebamos uma representação simplificada da operação:

TRANSACTION TYPE : PURCHASE
CARD TOKEN        : 987654321
AMOUNT            : 100.00
CURRENCY          : BRL
MERCHANT ID       : 785932
MCC               : 5812
COUNTRY            : BRA
ENTRY MODE         : CONTACTLESS
DATE               : 20260914
TIME               : 031700

Sim.

03:17.

Quem acompanha o Bellacosa Mainframe sabe que esse horário nunca aparece por acidente.

😏

Nosso primeiro easter egg já foi registrado.

Em sistemas reais, mensagens de cartões podem utilizar padrões e protocolos próprios do setor, incluindo famílias baseadas em ISO 8583, além de APIs e formatos modernos dependendo da integração.

Para nosso iniciante COBOL, entretanto, vamos imaginar simplesmente um registro chegando ao mainframe.



🖥️ Capítulo 3 — CICS, atenda a porta!

Dentro do z/OS poderíamos possuir uma transação CICS:

AUTH

Sua missão:

processar uma solicitação de autorização.

Conceitualmente:

REQUEST
   │
   ▼
 CICS
   │
   ▼
AUTHORIZATION PROGRAM
   │
   ├── VALIDATE CARD
   ├── CHECK STATUS
   ├── CHECK LIMIT
   ├── CHECK RULES
   ├── CHECK RISK
   │
   ▼
APPROVE / DECLINE

Um pseudocódigo COBOL extremamente simplificado poderia parecer:

       PROCEDURE DIVISION.

           PERFORM VALIDATE-REQUEST
           PERFORM READ-CARD
           PERFORM CHECK-CARD-STATUS
           PERFORM CHECK-AVAILABLE-LIMIT
           PERFORM CHECK-RISK

           IF WS-AUTHORIZED
               PERFORM CREATE-AUTHORIZATION
               PERFORM RESERVE-LIMIT
               MOVE '00' TO WS-RESPONSE-CODE
           ELSE
               MOVE '05' TO WS-RESPONSE-CODE
           END-IF.

Não copie isso para instalar amanhã no banco. 😁

Estamos construindo um modelo didático.

O importante é compreender o fluxo.


💳 Capítulo 4 — O cartão existe?

Nossa primeira pergunta parece ridícula:

O cartão existe?

Mas sistemas robustos começam validando o básico.

Podemos possuir algo conceitualmente semelhante a:

CARD
---------------------------
CARD_ID
ACCOUNT_ID
CARD_TOKEN
STATUS
EXPIRATION_DATE
PRODUCT_CODE
BLOCK_CODE

O programa consulta:

SELECT STATUS,
       ACCOUNT_ID,
       EXPIRATION_DATE
FROM CARD
WHERE CARD_TOKEN = :WS-CARD-TOKEN

E descobre:

STATUS = ACTIVE

Ótimo.

Mas poderia encontrar:

BLOCKED
CANCELLED
EXPIRED
LOST
STOLEN

Nesse caso, dependendo das regras:

DECLINED

Observe algo importante para quem está aprendendo COBOL.

O programa não está simplesmente “fazendo contas”.

Ele está implementando regras de negócio.

Essa é uma das essências do COBOL empresarial.


🏦 Capítulo 5 — A conta e o limite

Encontramos a conta:

ACCOUNT_ID       = 100238
CREDIT_LIMIT     = 10000.00
AVAILABLE_LIMIT  = 5800.00
CURRENT_BALANCE  = 3400.00
PENDING_AUTH     = 800.00

A compra solicitada é:

100.00

Temos limite.

Mas cuidado.

Não deveríamos simplesmente fazer:

SUBTRACT 100 FROM AVAILABLE-LIMIT.

Por quê?

Porque provavelmente existem milhares de transações concorrentes.

Imagine duas compras quase simultâneas.

AVAILABLE LIMIT = R$ 500

COMPRA A = R$ 400
COMPRA B = R$ 400

Dois programas consultam:

R$ 500 disponível.

A conclui:

aprovado.

B conclui:

aprovado.

Parabéns.

Acabamos de autorizar R$ 800 usando R$ 500.

Bem-vindo ao maravilhoso universo da concorrência transacional.


🔒 Capítulo 6 — COMMIT e ROLLBACK não são frescura

Aqui começamos a compreender por que sistemas transacionais possuem mecanismos tão sofisticados.

Nossa operação poderia ser tratada como uma Unit of Work.

BEGIN UOW
    │
    ├── READ ACCOUNT
    │
    ├── CHECK LIMIT
    │
    ├── CREATE AUTHORIZATION
    │
    ├── RESERVE LIMIT
    │
    └── WRITE AUDIT
           │
           ▼
         COMMIT

Mas imagine:

CREATE AUTHORIZATION → OK
RESERVE LIMIT        → OK
WRITE SOMETHING      → ERROR

Não podemos deixar metade da operação concluída.

Precisamos de:

ROLLBACK

A ideia fundamental é:

Ou a unidade lógica de trabalho acontece de maneira consistente, ou voltamos ao estado apropriado.

Esse é um dos conceitos que um programador COBOL iniciante deveria tatuar mentalmente.

Em aplicações financeiras, inconsistência pode significar dinheiro.


🧠 Capítulo 7 — O limite existe, mas devemos autorizar?

Não necessariamente.

Imagine:

LIMITE DISPONÍVEL: R$ 20.000
COMPRA:            R$ 7.000

Matematicamente:

7000 < 20000

Então aprova?

Talvez.

Agora acrescente:

CLIENTE NORMALMENTE COMPRA: Brasil
HORÁRIO:                     03:17
VALOR MÉDIO:                 R$ 80
COMPRA ATUAL:                R$ 7.000
PAÍS:                        outro país
MERCHANT:                    desconhecido

🚨

Entra o Risk/Fraud Engine.


🚨 Capítulo 8 — O Sherlock Holmes das transações

O sistema antifraude pode observar dezenas ou centenas de sinais.

Por exemplo:

VALUE
TIME
COUNTRY
MERCHANT
MCC
DEVICE
TRANSACTION VELOCITY
HISTORICAL BEHAVIOR
AUTHENTICATION
PREVIOUS DECLINES
GEOGRAPHICAL PATTERNS

Imagine:

23:10 São Paulo
R$ 37,50

23:18 São Paulo
R$ 83,00

23:22 Tokyo
R$ 9.700

Não precisamos ser Hercule Poirot para levantar uma sobrancelha.

Nosso sistema poderia calcular:

RISK SCORE = 947

E possuir regras como:

000-300   LOW
301-700   MEDIUM
701-850   HIGH
851-1000  DECLINE/REVIEW

Atualmente esse ambiente pode combinar regras determinísticas, estatística, análise comportamental e machine learning.

Mas COBOL continua perfeitamente capaz de executar regras determinísticas essenciais.

IF WS-RISK-SCORE > 850
    MOVE 'N' TO WS-AUTHORIZED
END-IF.

Às vezes não precisamos de inteligência artificial.

Precisamos apenas de:

IF COISA-ABSURDA
   NÃO-FAÇA
END-IF

Uma tecnologia revolucionária conhecida desde tempos imemoriais como bom senso programado.


⚡ Capítulo 9 — Tudo isso precisa ser rápido

Esse é um requisito extraordinário.

O consumidor está esperando.

Ele não quer ver:

PROCESSANDO...

PROCESSANDO...

PROCESSANDO...

enquanto o sistema gera um relatório gerencial de 400 páginas.

Por isso workloads diferentes possuem prioridades diferentes.

Entra o WLM — Workload Manager.

Conceitualmente:

AUTHORIZATION     CRITICAL
PAYMENT           HIGH
CUSTOMER QUERY    HIGH
REPORTING         MEDIUM
ANALYTICS BATCH   LOWER

Quando existe competição por recursos, o sistema operacional precisa compreender que:

autorizar a compra do cliente é mais urgente do que imprimir o relatório do chefe.

Embora alguns chefes possam discordar.


📨 Capítulo 10 — MQ: nem todo mundo precisa esperar

Imagine que a compra foi aprovada.

Precisamos responder imediatamente.

Mas também queremos:

  • registrar eventos;

  • enviar notificação;

  • alimentar analytics;

  • avisar sistemas antifraude;

  • atualizar outros ambientes;

  • produzir informações para aplicações móveis.

Seria absurdo fazer o consumidor esperar tudo isso.

Então:

CICS AUTH
    │
    ├──────────────► RESPONSE
    │
    │
    └──────────────► MQ
                         │
               ┌─────────┼─────────┐
               ▼         ▼         ▼
             FRAUD    ANALYTICS   ALERT
                                   │
                                   ▼
                           "Compra aprovada"

Aqui aparece uma das grandes ideias de arquitetura:

separe o caminho crítico das tarefas que podem acontecer assincronamente.

IBM MQ encaixa-se maravilhosamente nesse tipo de integração.


🧾 Capítulo 11 — APPROVED não significa “acabou”

Esse é provavelmente um dos conceitos mais interessantes do sistema.

A compra foi autorizada:

AUTHORIZATION

VALUE  = 100.00
STATUS = PENDING

Mas autorização e lançamento financeiro definitivo são coisas diferentes.

Posteriormente chegam informações financeiras que precisam ser conciliadas com aquela autorização.

Simplificando:

AUTHORIZATION
      │
      ▼
PRESENTMENT
      │
      ▼
MATCHING
      │
      ▼
POSTING

Finalmente:

POSTED TRANSACTION

Por que essa separação?

Porque o mundo real é bagunçado.


🏨 Capítulo 12 — O hotel de R$ 1.000 que virou R$ 873,42

Você chega a um hotel.

Pode ocorrer uma autorização inicial:

R$ 1.000

Sua conta final acaba sendo:

R$ 873,42

Agora nosso sistema precisa compreender que existe relacionamento entre as operações.

Situações semelhantes aparecem em:

  • hotéis;

  • locadoras;

  • restaurantes;

  • postos;

  • cancelamentos;

  • ajustes;

  • estornos.

Portanto:

AUTHORIZATION ≠ FINAL TRANSACTION

Esse é um daqueles detalhes que parecem insignificantes até você precisar construir o sistema.

Então tornam-se gigantescos.


📦 Capítulo 13 — E das profundezas surge o BATCH

Durante o dia, imagine:

CICS
CICS
CICS
CICS
CICS
CICS
CICS

Transações chegando continuamente.

Em paralelo ou em determinados ciclos, precisamos executar processamento massivo.

Entra:

JES2 + JCL + COBOL Batch

Poderíamos possuir uma cadeia didática:

RECEIVE CLEARING
       │
       ▼
VALIDATE
       │
       ▼
MATCH AUTHORIZATION
       │
       ▼
POST TRANSACTION
       │
       ▼
UPDATE ACCOUNT
       │
       ▼
BILLING
       │
       ▼
SETTLEMENT
       │
       ▼
RECONCILIATION

Um JCL fictício:

//BELCARD JOB ...
//STEP010 EXEC PGM=BCLR001
//STEP020 EXEC PGM=BVAL001
//STEP030 EXEC PGM=BMAT001
//STEP040 EXEC PGM=BPOS001
//STEP050 EXEC PGM=BBIL001
//STEP060 EXEC PGM=BSET001

Cada programa possui responsabilidade específica.

Isso permite restart, controle, auditoria e operacionalização muito melhores do que construir um monstro chamado:

FAZTUDO.CBL

com 187 mil linhas.

Embora algum arqueólogo de sistemas provavelmente já tenha encontrado algo parecido.


🧮 Capítulo 14 — A fábrica de faturas

Chegamos ao billing.

Para cada conta precisamos considerar:

SALDO ANTERIOR
+
COMPRAS
+
PARCELAS
+
ENCARGOS
+
JUROS
-
PAGAMENTOS
-
CRÉDITOS
-
ESTORNOS
=
NOVO SALDO

Em COBOL:

COMPUTE WS-NEW-BALANCE =
        WS-PREVIOUS-BALANCE
      + WS-PURCHASES
      + WS-INSTALLMENTS
      + WS-FEES
      + WS-INTEREST
      - WS-PAYMENTS
      - WS-CREDITS.

E aqui COBOL está em casa.

Valores decimais, regras empresariais, processamento de registros e grandes volumes de dados são precisamente o tipo de problema para o qual COBOL nasceu.


🇧🇷 Capítulo 15 — A entidade brasileira chamada PARCELAMENTO

Agora compramos:

R$ 1.200 em 12x

Nosso sistema registra:

PURCHASE_ID = 9838172
TOTAL       = 1200.00
QTY         = 12

E teremos:

01/12  100
02/12  100
03/12  100
...
12/12  100

Parece simples.

Até alguém perguntar:

“E se houver estorno na parcela 7?”

Ou:

“E se for estorno parcial?”

Ou:

“E se o cliente contestar a compra?”

Ou:

“E se houver renegociação?”

Ou:

“E se existir juros?”

Ou:

“E se o comerciante fizer refund?”

É assim que programas pequenos envelhecem e viram programas COBOL de 30 mil linhas.

Não necessariamente porque os programadores antigos eram malucos.

Frequentemente porque 30 anos de realidade foram sendo incorporados ao código.

Essa é uma lição importantíssima para quem entra hoje no mainframe.

Código legado muitas vezes é também:

regra de negócio fossilizada.

Não apague antes de descobrir por que existe.


🔐 Capítulo 16 — RACF: não, estagiário, você não pode consultar todos os cartões

Nosso BELLACARD contém informações extremamente sensíveis.

Precisamos controlar:

WHO
CAN DO WHAT
TO WHICH RESOURCE
UNDER WHICH CONDITIONS

RACF pode participar do controle de acesso ao ambiente z/OS.

Podemos proteger datasets, transações, usuários, grupos e diversos recursos.

Conceitualmente:

USER VAGNER
    │
    ├── AUTH → READ/EXECUTE
    ├── BILL → READ
    └── ADMIN → NO ACCESS

O princípio essencial é:

LEAST PRIVILEGE.

Um programa deve possuir apenas os acessos necessários.

Um operador também.

Um desenvolvedor também.

E definitivamente ninguém deveria possuir acesso porque:

“Vai que um dia eu precise.”


🔑 Capítulo 17 — E as chaves criptográficas?

Agora entramos em território ainda mais sensível.

Cartões envolvem criptografia, autenticação, tokens, PINs e material criptográfico.

A regra de ouro é:

chaves críticas não devem virar variáveis COBOL espalhadas pela aplicação.

Algo como:

01 SUPER-SECRET-KEY PIC X(32)
   VALUE 'MINHACHAVE123...'.

é praticamente uma carta de demissão escrita em COBOL.

😂

Ambientes financeiros utilizam infraestrutura criptográfica especializada e HSMs — Hardware Security Modules — para determinadas operações e proteção de chaves.

A aplicação solicita uma operação criptográfica.

O segredo permanece protegido.


🕵️ Capítulo 18 — “Eu não fiz essa compra.”

Três meses depois o cliente telefona:

Eu nunca fiz essa compra.

O sistema precisa reconstruir o passado.

Queremos saber:

QUANDO?
QUAL CARTÃO?
QUAL MERCHANT?
QUAL VALOR?
QUAL CANAL?
QUAL RESPOSTA?
QUAL SISTEMA?
QUAL REGRA?
QUAL RESULTADO?

Logs e trilhas de auditoria tornam-se fundamentais.

No universo z/OS, SMF e informações produzidas pelos subsistemas ajudam a construir observabilidade e auditoria.

Nosso sistema deveria conseguir reconstruir algo como:

03:17:00.103 REQUEST RECEIVED
03:17:00.108 CARD VALIDATED
03:17:00.112 STATUS ACTIVE
03:17:00.119 LIMIT OK
03:17:00.127 RISK SCORE 214
03:17:00.133 AUTH CREATED
03:17:00.139 LIMIT RESERVED
03:17:00.145 COMMIT
03:17:00.151 APPROVED

E aí descobrimos outra característica dos sistemas financeiros:

não basta fazer certo. Precisamos conseguir demonstrar posteriormente o que aconteceu.


🏰 Capítulo 19 — E se o mainframe cair?

Imagine milhões de pessoas tentando pagar almoço e recebendo:

HOST UNAVAILABLE

O problema deixa rapidamente de ser “um incidente de TI”.

Vira problema comercial, financeiro e reputacional.

Daí entram conceitos de alta disponibilidade e arquiteturas como Parallel Sysplex.

Didaticamente:

                 REQUESTS
                     │
                     ▼
               WORKLOAD ROUTING
                     │
          ┌──────────┴──────────┐
          ▼                     ▼
       z/OS A                 z/OS B
        CICS                   CICS
          │                     │
          └──────────┬──────────┘
                     ▼
                   Db2
               Data Sharing

Falhou um componente?

A arquitetura é desenhada para evitar que isso necessariamente signifique:

TODO MUNDO PARA.

É aqui que redundância, recuperação, data sharing, workload management, automação operacional e engenharia de resiliência deixam de ser palavras bonitas de PowerPoint.


🏙️ Capítulo 20 — As duas cidades do cartão

Eu gosto de imaginar o BELLACARD dividido em duas grandes cidades.

⚡ Cidade Online

Seu prefeito é o CICS.

Sua pergunta principal:

POSSO COMPRAR?

REQUEST
   │
   ▼
CICS
   │
   ▼
CARD
LIMIT
RISK
RULES
   │
   ▼
YES / NO

Velocidade, disponibilidade e consistência dominam essa cidade.


🏭 Cidade Financeira

Aqui vivem:

Db2 + COBOL Batch + JES2 + MQ + sistemas contábeis.

Sua pergunta é diferente:

O QUE ACONTECEU COM O DINHEIRO?

AUTHORIZATION
      ↓
TRANSACTION
      ↓
POSTING
      ↓
ACCOUNT
      ↓
STATEMENT
      ↓
PAYMENT
      ↓
ACCOUNTING
      ↓
RECONCILIATION

Aqui cada centavo precisa encontrar seu destino.


🧩 Capítulo 21 — Afinal, onde cada tecnologia entra?

Agora nosso iniciante consegue enxergar o tabuleiro inteiro.

COBOL
│
├── business rules
├── authorization
├── billing
├── posting
└── batch processing

CICS
│
├── online transactions
├── transaction management
└── units of work

Db2
│
├── accounts
├── cards
├── authorizations
├── transactions
└── statements

MQ
│
├── asynchronous messaging
├── events
├── integration
└── notifications

JCL/JES2
│
├── batch
├── billing
├── reconciliation
└── settlement processing

RACF
│
└── access control

CRYPTO/HSM
│
└── sensitive cryptographic operations

SMF/MONITORING
│
├── auditing
└── observability

WLM
│
└── workload priorities

PARALLEL SYSPLEX
│
└── availability/scalability

Percebe a diferença?

Agora COBOL, CICS, Db2, MQ e JCL deixaram de ser matérias isoladas de um curso.

Cada tecnologia apareceu porque tínhamos um problema para resolver.

É assim que eu gosto de ensinar mainframe.


🎓 Capítulo 22 — Construindo o BELLACARD como projeto educacional

Eu transformaria essa arquitetura numa trilha prática.

O aluno começa pequeno.

Nível 1 — COBOL

Criar:

CUSTOMER
CARD
ACCOUNT

Depois:

PURCHASE
PAYMENT
LIMIT

Finalmente:

STATEMENT

Nível 2 — Arquivos

Guardar clientes e contas.

Começar sequencialmente.

Depois introduzir VSAM.

Agora o aluno entende por que acesso indexado importa.


Nível 3 — Db2

Migramos para:

CUSTOMER
ACCOUNT
CARD
AUTHORIZATION
TRANSACTION
PAYMENT
STATEMENT

Aprendemos:

SELECT
INSERT
UPDATE
DELETE
COMMIT
ROLLBACK

Não como comandos aleatórios de SQL.

Mas porque nosso banco precisa deles.


Nível 4 — CICS

Criamos:

AUTH = Authorization
ACCT = Account Inquiry
PAYM = Payment
BLCK = Block Card

Agora nosso COBOL deixou de ser apenas batch.

Temos um pequeno sistema transacional.


Nível 5 — MQ

A compra aprovada produz:

CARD.PURCHASE.APPROVED

Outro consumidor recebe.

Depois outro.

Aprendemos arquitetura assíncrona.


Nível 6 — Batch

Criamos:

POSTING
BILLING
PAYMENT PROCESSING
STATEMENT GENERATION
RECONCILIATION

Finalmente o aluno entende por que empresas ainda executam workloads batch gigantescos.


Nível 7 — Segurança

Introduzimos:

RACF
AUDIT
CRYPTOGRAPHY
TOKENIZATION

Agora nosso brinquedo começa a parecer uma plataforma empresarial.


Nível 8 — Operação

Provocamos problemas.

DB2 TIMEOUT
MQ QUEUE FULL
CICS ABEND
JOB RC=12
DATASET FULL
AUTHORIZATION LATENCY

E perguntamos:

O que o suporte N2 faria?

Depois:

E o N3?

Agora nasceu uma pequena War Room BELLACARD.


🔥 Capítulo 23 — O exercício mais importante: quebrar o sistema

Eu faria questão de criar erros propositalmente.

Por exemplo:

AVAILABLE LIMIT = 500

Disparamos simultaneamente:

PURCHASE A = 400
PURCHASE B = 400

Se ambas forem aprovadas incorretamente, descobrimos uma falha de concorrência.

Outro teste:

INSERT AUTHORIZATION = SUCCESS
UPDATE LIMIT         = FAILURE

O sistema ficou inconsistente?

Se sim:

faltou tratar corretamente a unidade de trabalho.

Outro:

MQ unavailable

A autorização precisa parar?

Talvez não.

Essa pergunta ensina arquitetura melhor que vinte slides.


👻 Capítulo 24 — O fantasma das 03:17

Chegamos ao easter egg.

Todos os dias exatamente às:

03:17

o BELLACARD começa a apresentar:

AUTH RESPONSE TIME
120ms
180ms
350ms
900ms
2.1s

Nenhum erro.

CPU normal.

Db2 aparentemente normal.

MQ normal.

CICS sem ABEND.

Mas a latência explode durante sete minutos.

Nosso programador iniciante recebe seu primeiro chamado:

INCIDENT #0317

SEVERITY: HIGH
DESCRIPTION:
Intermittent authorization latency.

Começa a investigação.

RMF.

SMF.

CICS statistics.

Db2 accounting.

WLM.

JES2.

Até descobrir...

Um antigo job chamado:

//MONSTR17 JOB

executado diariamente às 03:17, realizando uma consulta monstruosa contra tabelas utilizadas pelo sistema online.

O programa foi criado em 1997.

O comentário no topo:

      * DO NOT REMOVE.
      * BUSINESS REQUIREMENT.
      * JSMITH - 1997-04-13

Ninguém sabe quem é JSMITH.

Ninguém sabe qual era o requisito.

Mas todos têm medo de remover.

🤣

Bem-vindo ao mainframe corporativo.


🧠 Curiosidade — O verdadeiro patrimônio não é apenas o código

Esse é talvez o conhecimento mais importante de todo o artigo.

Quando alguém encontra um programa COBOL com milhares de linhas, pode pensar:

“Que coisa velha.”

Mas aquele programa pode conter décadas de:

  • regras;

  • exceções;

  • regulamentações;

  • incidentes;

  • fraudes descobertas;

  • produtos descontinuados;

  • produtos ainda ativos;

  • acordos comerciais;

  • tratamentos especiais;

  • correções;

  • conhecimento empresarial.

É quase arqueologia.

Um comentário de 1997 pode explicar por que determinada operação de 2026 ainda funciona.

Por isso modernização responsável começa com:

compreender antes de substituir.


🏛️ Capítulo 25 — O mainframe como cidade invisível

Voltamos finalmente à cafeteria.

Você aproximou o cartão.

BIP!

Apareceu:

APROVADO

Você levou seu café.

Talvez nunca pense novamente naquela transação.

Mas atrás daquele pequeno momento poderia existir conceitualmente uma cidade inteira:

                   💳 CARD
                      │
                      ▼
                 POS / APP
                      │
                      ▼
                  ACQUIRER
                      │
                      ▼
               CARD NETWORK
                      │
                      ▼
╔══════════════════════════════════════╗
║               IBM Z                  ║
║                                      ║
║              CICS                    ║
║                │                     ║
║       ┌────────┼────────┐            ║
║       ▼        ▼        ▼            ║
║     CARD     LIMIT     RISK          ║
║       │        │        │            ║
║       └────────┼────────┘            ║
║                ▼                     ║
║               Db2                    ║
║                │                     ║
║               MQ                     ║
║                                      ║
║   COBOL • JCL • JES2 • RACF • SMF   ║
║        WLM • CRYPTO • SYSPLEX        ║
╚══════════════════════════════════════╝
                      │
                      ▼
                   APPROVED

O consumidor viu:

APROVADO.

O mainframer vê:

arquitetura.


☕ Conclusão — o BIP que esconde uma catedral

Talvez essa seja uma das melhores maneiras de explicar mainframe para alguém que está começando.

Não comece dizendo:

“COBOL possui DIVISION, SECTION e PARAGRAPH.”

Comece dizendo:

“Você acabou de passar um cartão. Quer descobrir o que pode existir atrás daquele BIP?”

Então COBOL ganha propósito.

CICS ganha propósito.

Db2 ganha propósito.

MQ ganha propósito.

JCL ganha propósito.

RACF ganha propósito.

SMF ganha propósito.

WLM ganha propósito.

Parallel Sysplex ganha propósito.

O iniciante deixa de decorar siglas e começa a compreender problemas.

E tecnologia empresarial é exatamente isso:

uma coleção de soluções para problemas que ficaram grandes demais para serem resolvidos de qualquer jeito.

Da próxima vez que aproximar seu cartão e ouvir:

BIP!

talvez você enxergue algo diferente.

Não apenas uma compra.

Mas uma mensagem atravessando redes, chegando a sistemas que verificam identidade, estado, crédito e risco; uma unidade de trabalho sendo protegida; registros sendo preservados; eventos sendo produzidos; sistemas financeiros preparando o que acontecerá depois.

Tudo isso para devolver uma pequena palavra:

       ┌────────────────────────┐
       │                        │
       │       APPROVED         │
       │                        │
       │         RC=00          │
       │                        │
       └────────────────────────┘

E talvez exista, em algum canto de algum sistema que ninguém ousa desligar, um programa COBOL escrito décadas atrás, trabalhando silenciosamente para que seu café seja pago.

Sem aplausos.

Sem interface bonita.

Sem ninguém perceber.

Como tantas outras coisas no mainframe.

Porque a melhor infraestrutura é aquela que desaparece atrás do serviço que presta.

E enquanto o mundo vê apenas o BIP, nós sabemos que atrás dele pode existir uma verdadeira catedral transacional construída byte por byte, regra por regra e geração por geração de programadores.

Um Café no Bellacosa Mainframe

Onde até uma compra de R$ 17,50 pode acabar em CICS, Db2, COBOL e uma War Room às 03:17.



☕ Um Café no Bellacosa Mainframe

🕵️ The Mentalist no Mainframe — O Caso dos R$ 100 que Atravessaram um Sistema de Cartões

Entenda como uma compra de R$ 100 atravessa POS, adquirente, bandeira, emissor, autorização, plafond, clearing, settlement, cobrança, contabilidade e reconciliação em um ambiente bancário e mainframe.

💳 Como funciona uma transação de cartão de crédito?

Uma compra aparentemente simples percorre diversos participantes e sistemas. O cliente apresenta o cartão ao estabelecimento, a maquininha envia a transação ao adquirente, a rede encaminha a solicitação ao emissor e o banco verifica cartão, conta, produto, plafond, regras e risco antes de autorizar ou recusar.

Depois da autorização, a transação ainda pode passar por reversal, clearing, settlement, faturamento, cobrança, contabilização, reconciliação, disputa e chargeback.

Principais assuntos: IBM Mainframe, IBM Z, COBOL, CICS, Db2, cartões de crédito, POS, adquirente, emissor, autorização, plafond, clearing, settlement, tarifas, cobrança, contabilidade e reconciliação.

🔎 Ler o artigo original: The Mentalist no Mainframe

Bellacosa Mainframe — conteúdo educacional sobre IBM Z, COBOL, CICS, sistemas bancários e processamento de cartões.

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