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

Translate

Mostrar mensagens com a etiqueta jcl. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta jcl. Mostrar todas as mensagens

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.

segunda-feira, 7 de setembro de 2026

Guilherme de Baskerville Entra no CPD — O Nome dos Pedreiros na Catedral de 80 Colunas

 

Um Café no Bellacosa Mainframe

Guilherme de Baskerville Entra no CPD — O Nome dos Pedreiros na Catedral de 80 Colunas

Ou: como cartões perfurados, datasets de 80 bytes, COBOL, PL/I, Assembler, Natural, XML, JSON, APIs e décadas de retrocompatibilidade transformaram programas legados em catedrais construídas por gerações de artesãos quase anônimos





Prólogo — O nome estava na pedra

Guilherme de Baskerville não começou examinando o código.

Isso surpreendeu o jovem programador.

Havia milhares de linhas COBOL diante deles, algumas tão antigas que ninguém presente no CPD sabia explicar completamente sua origem. O programa havia sobrevivido a reorganizações, mudanças de hardware, novos compiladores, novas moedas, novas legislações e incontáveis projetos de modernização.

— Mestre, não deveríamos procurar primeiro a PROCEDURE DIVISION?

Guilherme aproximou-se do terminal.

No alto do fonte havia algo aparentemente banal:

*****************************************************************
* J. PEREIRA
* 17/08/1983
* ALTERADA ROTINA DE FATURAMENTO
*****************************************************************
* M. SANTOS
* 04/02/1987
* INCLUIDO NOVO TIPO DE MOVIMENTO
*****************************************************************
* R. ALMEIDA
* 22/09/1994
* ADEQUACAO NOVA REGRA MONETARIA
*****************************************************************

Continuava.

Uma tela.

Duas.

Dez.

Dezenas de nomes.

Guilherme permaneceu em silêncio.

— O que procura? — perguntou o aprendiz.

— Não procuro — respondeu ele. — Estou prestando homenagem.



1. O programa legado possui uma memória

Quando encontramos um programa COBOL, PL/I, Natural ou Assembler com décadas de existência, frequentemente encontramos também algo que os manuais tratam simplesmente como change history.

Nome ou USER-ID.

Data.

Descrição da alteração.

Três ou quatro linhas cercadas por asteriscos.

*****************************************************************
* JCARLOS
* 14/06/1988
* CORRECAO CALCULO DE JUROS
*****************************************************************

Tecnicamente, aquilo é documentação.

Mas depois de quarenta anos transforma-se em algo diferente.

É memória institucional.

Talvez ninguém saiba mais quem foi JCARLOS.

Seu USER-ID provavelmente desapareceu há décadas.

O sistema de chamados usado naquela alteração talvez nem exista.

A documentação funcional pode ter sido perdida.

O departamento pode ter mudado de nome cinco vezes.

JCARLOS pode estar aposentado.

Pode morar do outro lado do mundo.

Pode ter falecido.

Mas alguma coisa permaneceu:

* JCARLOS
* 14/06/1988
* CORRECAO CALCULO DE JUROS

O programa lembra.



2. As assinaturas dos pedreiros

Nas antigas construções europeias podemos encontrar marcas deixadas por pedreiros e artesãos.

Isso oferece uma metáfora extraordinária para software legado.

Imagine uma catedral.

Um homem trabalha numa pedra.

Ele não projetou o edifício inteiro.

Não escolheu necessariamente onde ficaria a torre.

Não decidiu a doutrina representada nos vitrais.

Seu nome provavelmente nunca aparecerá num livro de história.

Mas aquela pedra passou pelas mãos dele.

Então deixa uma marca.

Séculos depois alguém a encontra.

No mainframe fazemos algo assustadoramente parecido:

*****************************************************************
* MFERREIRA
* 11/03/1991
* INCLUIDA VALIDACAO DO MOVIMENTO 07
*****************************************************************

Não significa:

Eu construí este sistema.

Significa:

Esta pedra passou pelas minhas mãos.

E isso muda completamente nossa maneira de olhar um fonte antigo.



3. Nenhum programador construiu a catedral

Um dos grandes erros quando falamos de software é imaginar um programa como criação de uma única pessoa.

Em sistemas corporativos longevos isso frequentemente não existe.

O programa pode ter nascido assim:

1981  JOAO
      criação

Depois:

1984  MARIA
      nova modalidade

Depois:

1987  CARLOS
      novo processamento

Depois:

1994  ANA
      mudança monetária

Depois:

1999  ROBERTO
      adequação Y2K

E continua:

2004
2008
2012
2017
2020
2026

Quando chegamos ao programa em 2026, não estamos diante do trabalho de João.

Estamos diante de:

João + Maria + Carlos + Ana + Roberto + dezenas ou centenas de pessoas.

A criatura nasceu, cresceu e foi modificada.

Algumas partes desapareceram.

Outras sobreviveram.

Outras foram reconstruídas.

O programa tornou-se uma obra coletiva.

Exatamente como uma catedral que atravessou gerações.



4. Guilherme faz a primeira pergunta

O jovem programador apontou para uma rotina.

— Isto está horrível. Podemos remover?

Guilherme respondeu:

— Por que ela existe?

— Não sei.

— Então ainda não sabemos se podemos removê-la.

Essa talvez seja uma das regras mais importantes para quem começa a trabalhar com legado.

Código estranho não significa automaticamente código inútil.

Às vezes é lixo.

Às vezes é dívida técnica.

Às vezes é uma gambiarra histórica.

Mas às vezes é a última manifestação de uma regra de negócio que ninguém mais documentou.

Você encontra:

IF WS-TIPO = 7
   PERFORM 8000-TRATA-ESPECIAL
END-IF

E pensa:

Que porcaria é essa?

Procura no cabeçalho:

*****************************************************************
* MROCHA
* 18/09/1989
* CORRECAO PROCESSAMENTO MOVIMENTO TIPO 7
*****************************************************************

Agora existe uma pista.

Não temos a resposta.

Temos uma evidência.

Guilherme de Baskerville certamente aprovaria a diferença.


5. O programa também possui camadas arqueológicas

Programas legados podem carregar algo ainda mais interessante.

Eles registram a própria evolução da informática.

Imagine um sistema criado no começo dos anos 1980.

Sua primeira versão pode ter sido essencialmente:

arquivo
   |
COBOL
   |
arquivo

Depois apareceu VSAM.

Depois Db2.

Depois CICS.

Depois MQ.

Então alguém precisou conectá-lo ao mundo distribuído.

Chegaram HTML e aplicações Web.

Depois XML.

SOAP.

Java.

JSON.

REST.

APIs.

Cloud.

Containers.

Eventos.

De repente temos:

                    MOBILE
                       |
                    HTTPS
                       |
                 API GATEWAY
                       |
                     JSON
                       |
                     REST
                       |
                z/OS CONNECT
                       |
                     CICS
                       |
                     COBOL
                  /    |    \
                Db2   VSAM   MQ
                              |
                         SISTEMA CLOUD

E em algum lugar no centro dessa arquitetura ainda existe:

       PERFORM 300-CALCULAR-JUROS

escrito originalmente quando ninguém possuía um smartphone.

Frankenstein?

Talvez.

Mas existe uma interpretação mais interessante.

Estratigrafia computacional.


6. Frankenstein entra na catedral

Chamamos esses sistemas de Frankenstein porque encontramos tecnologias de épocas completamente diferentes costuradas umas às outras.

Assembler.

COBOL.

PL/I.

Natural.

JCL.

VSAM.

IMS.

Db2.

CICS.

MQ.

HTML.

XML.

SOAP.

Java.

JSON.

REST.

Cloud.

Mas uma catedral construída durante séculos também pode apresentar estilos diferentes.

Uma parte pertence a determinada época.

Outra foi reconstruída.

Uma capela apareceu posteriormente.

Um órgão foi substituído.

Um vitral é muito mais recente.

Uma restauração contemporânea introduziu outra marca.

O historiador não olha imediatamente para aquilo e diz:

Que arquitetura inconsistente!

Ele pergunta:

O que aconteceu aqui?

Essa é a diferença entre simplesmente programar e fazer arqueologia de software.


7. O astronauta na catedral

Existe um caso delicioso na Catedral Nova de Salamanca.

Durante uma restauração realizada em 1992, foi acrescentada à ornamentação uma figura de astronauta.

A catedral começou a ser construída séculos antes da exploração espacial.

Mas ali está ele.

Um astronauta na pedra.

Não é medieval.

Não tenta fingir que é.

Ele registra a época da intervenção.

E nossos programas fazem exatamente isso.

Imagine:

*****************************************************************
* JPEREIRA
* 1983
* CRIACAO
*****************************************************************

*****************************************************************
* MROCHA
* 1995
* INTEGRACAO DB2
*****************************************************************

*****************************************************************
* CSOUZA
* 2003
* INTERFACE XML
*****************************************************************

*****************************************************************
* AFERREIRA
* 2018
* RETORNO JSON
*****************************************************************

*****************************************************************
* VBELLACOSA
* 2026
* INTEGRACAO API REST
*****************************************************************

REST é o astronauta esculpido na catedral COBOL.

Ele não precisa destruir aquilo que veio antes.

Ele demonstra que a construção chegou viva até outra época.


8. O mistério das 80 colunas

Então Guilherme encontrou outra pista.

RECFM=FB
LRECL=80

O jovem programador riu.

— Outra velharia.

Guilherme olhou para ele.

— Oitenta por quê?

Silêncio.

É exatamente aqui que muita gente conhece apenas um terço da história.

O cartão perfurado IBM que se tornou um símbolo da computação possuía 80 colunas. A própria IBM registra que o cartão de 80 colunas foi introduzido em 1928 e tornou-se extremamente disseminado no processamento de informações.

Depois olhamos para o formato tradicional do fonte COBOL:

1 - 6    Sequence Number Area
7        Indicator Area
8 - 11   Area A
12 - 72  Area B
73 - 80  Comment/Identification Area

A documentação atual da IBM ainda descreve explicitamente uma linha fonte COBOL de 80 caracteres, dividida nessas áreas.

Isso significa que aquele número aparentemente arbitrário possui ancestralidade.


9. O cartão desapareceu; sua sombra permaneceu

Essa é uma das coisas mais fascinantes da computação.

Uma limitação física pode transformar-se em convenção.

A convenção transforma-se em padrão.

O padrão influencia software.

O software cria dependências.

As dependências exigem compatibilidade.

Décadas depois a causa física desapareceu, mas seus descendentes permanecem.

Podemos representar assim:

CARTAO PERFURADO
       |
       v
  80 COLUNAS
       |
       v
FORMATO DE FONTE
       |
       v
 FERRAMENTAS
       |
       v
 DATASETS
       |
       v
 COMPATIBILIDADE
       |
       v
     2026

Inclusive documentação atual de ferramentas IBM continua reconhecendo áreas de numeração nas colunas 1–6 e 73–80 para fontes COBOL.

O cartão morreu.

A geometria sobreviveu.


10. O dataset de 80 bytes é uma rua romana

Imagine caminhar por uma cidade europeia.

Existe uma rua estranhamente curva.

Para um urbanista moderno, aquela curva parece irracional.

Até alguém explicar:

A estrada romana passava aqui.

A cidade desapareceu.

Impérios desapareceram.

Veículos mudaram.

Mas a rua continuou obedecendo a uma decisão tomada dois mil anos antes.

No mainframe:

LRECL=80

pode desempenhar papel semelhante.

Não significa que todo dataset de 80 bytes exista porque era cartão perfurado — seria uma simplificação histórica perigosa.

Significa que 80 tornou-se um número estruturalmente importante em um ecossistema profundamente influenciado pelo cartão e pelos formatos derivados dele.

Essa nuance importa.

O arqueólogo não inventa explicações.

Ele procura evidências.


11. A retrocompatibilidade é a argamassa

Agora chegamos à característica que permitiu que nossa catedral continuasse crescendo:

retrocompatibilidade.

A IBM fez algo extraordinariamente difícil ao longo da evolução do mainframe: preservar caminhos de continuidade enquanto hardware e software avançavam.

A própria IBM descreve os sistemas IBM Z atuais como descendentes diretos da linhagem System/360 e System/370 e afirma que muitas aplicações antigas puderam continuar funcionando em sistemas posteriores.

Isso não significa:

Qualquer programa de 1964 roda magicamente e sem qualquer consideração num z17 de 2026.

Seria falso.

Existem releases suportados, requisitos, PTFs, produtos, dependências, mudanças arquiteturais e processos de migração.

Por exemplo, a matriz atual do z17 estabelece explicitamente quais versões de z/OS são suportadas e quais exigem manutenção apropriada.

Retrocompatibilidade não é magia.

É engenharia.


12. A decisão caríssima de não demolir a cidade

Imagine se toda evolução tecnológica significasse:

NOVO HARDWARE
      |
      v
JOGUE FORA O SOFTWARE
      |
      v
REESCREVA TUDO

Para uma pequena aplicação talvez seja possível.

Agora imagine um banco.

Uma seguradora.

Uma companhia aérea.

Um governo.

Uma indústria.

Décadas de:

  • regras de negócio;

  • cálculos;

  • exceções;

  • layouts;

  • integrações;

  • arquivos;

  • programas;

  • transações;

  • conhecimento operacional.

A retrocompatibilidade protege algo muito maior que o executável.

Ela ajuda a preservar investimento e conhecimento acumulado.

A IBM inclusive descreve historicamente ciclos longos de hardware e caminhos de upgrade entre famílias como mecanismos de proteção do investimento e extensão da vida dos ativos.

Isso explica parte da longevidade dessas catedrais.


13. Manutenção também é construção

Existe uma injustiça profissional curiosa.

Quem cria algo novo é chamado de construtor.

Quem mantém algo antigo frequentemente é tratado como alguém que apenas “faz manutenção”.

Uma catedral demonstra o absurdo dessa distinção.

Sem manutenção:

o telhado infiltra.

A madeira apodrece.

A pedra racha.

O vitral quebra.

A torre fica instável.

Depois de séculos, não existe mais catedral.

Portanto, o restaurador também participa da construção da longevidade.

No software acontece o mesmo.

Quem resolveu o problema em 1991 ajudou o programa a chegar a 1992.

Quem resolveu Y2K ajudou-o a chegar a 2000.

Quem migrou o compilador ajudou-o a continuar.

Quem abriu uma API em 2026 talvez permita que a regra de negócio sobreviva por outra década.

Manter também é construir.


14. Modernização não precisa significar demolição

Aqui mora outra lição importante para o programador COBOL iniciante.

Modernizar não significa necessariamente:

DELETE COBOL.

Pode significar:

                APLICACAO MODERNA
                       |
                     REST
                       |
                     JSON
                       |
                  INTEGRACAO
                       |
                     CICS
                       |
                     COBOL
                       |
                      Db2

Uma parte continua.

Outra é substituída.

Uma interface nasce.

Uma rotina é refatorada.

Uma dependência desaparece.

Outra surge.

A catedral continua em funcionamento durante a reforma.

Isso é muito diferente de demolir o edifício e prometer que construiremos outro antes do próximo fechamento contábil.


15. Mas não transforme história em religião

Guilherme levantaria o dedo aqui.

Respeitar o legado não significa venerar todo código antigo.

Existe código ruim.

Existe redundância.

Existe rotina morta.

Existe tecnologia cujo custo de manutenção deixou de fazer sentido.

Existe vulnerabilidade.

Existe dívida técnica.

Existe arquitetura que precisa desaparecer.

A arqueologia serve justamente para evitar dois extremos:

Tudo antigo é lixo.

e:

Tudo antigo deve ser preservado.

O restaurador competente pergunta:

O que isto sustenta?

Por que existe?

Quem depende disso?

Qual risco existe em removê-lo?

Existe alternativa melhor?

Como provar que o comportamento continuará correto?

Só então pega o martelo.


16. O comentário pode ser a última testemunha

Agora imagine isto:

       IF WS-CODIGO = 47
          MOVE 'S' TO WS-TRATAMENTO
       END-IF

Ninguém sabe explicar.

Git?

O programa é décadas anterior à adoção de Git pela organização.

Ticket?

Desapareceu.

Documento?

Não encontrado.

Analista funcional?

Aposentou-se em 2007.

Então você sobe até o cabeçalho:

*****************************************************************
* ACOSTA
* 23/05/1993
* TRATAMENTO ESPECIAL CLIENTES CONVENIO 47
*****************************************************************

Não solucionamos o mistério.

Mas encontramos uma testemunha.

E talvez seja a última.

Por isso apagar comentários históricos indiscriminadamente durante uma “limpeza” pode equivaler a restaurar uma catedral lixando as inscrições das pedras.


17. O Frankenstein contém conhecimento

Voltemos ao nosso monstro:

Assembler
   |
COBOL
   |
CICS
   |
Db2
   |
MQ
   |
XML
   |
SOAP
   |
Java
   |
JSON
   |
REST
   |
Cloud

Parece absurdo.

Mas cada camada pode representar uma pergunta que a organização precisou responder:

Como processaremos isto?

Como armazenaremos isto?

Como permitiremos transações online?

Como integraremos sistemas?

Como falaremos com aplicações Web?

Como exporemos serviços?

Como integraremos cloud e mainframe?

O Frankenstein deixa então de ser apenas um acidente.

Transforma-se num mapa das necessidades empresariais através do tempo.


18. Easter egg — o sino toca RC=0000

Guilherme terminou sua investigação.

O JOB foi submetido.

O jovem programador observava SDSF.

Esperaram.

Então surgiu:

COND CODE 0000

— Mestre, terminou.

Guilherme sorriu.

— Não. Apenas tocou o sino.

— Sino?

— Toda catedral possui um.

E desde então o aprendiz nunca mais viu um RC=0000 da mesma maneira.


19. O dia em que a catedral fechar

Existe ainda uma cena que raramente imaginamos.

Algum dia um desses programas executará pela última vez.

Talvez depois de quarenta anos.

Talvez cinquenta.

O scheduler deixará de chamá-lo.

O dataset será arquivado.

O load module desaparecerá da biblioteca de produção.

Outro sistema assumirá sua função.

E finalmente teremos:

LAST EXECUTION
RC=0000

Nesse momento seria justo abrir o fonte uma última vez.

Subir até o início.

E ler.

*****************************************************************
* JOAO
* 1981
*****************************************************************

*****************************************************************
* MARIA
* 1985
*****************************************************************

*****************************************************************
* CARLOS
* 1992
*****************************************************************

...

*****************************************************************
* ULTIMO PROGRAMADOR
* 20XX
*****************************************************************

Talvez existam cem nomes.

Talvez duzentos.

Nenhum deles construiu sozinho aquela catedral.

Mas sem eles ela não teria chegado ao último processamento.


20. O programador iniciante precisa aprender a ler pedras

Quando você começar a trabalhar num programa legado, resista à tentação de ir imediatamente para:

PROCEDURE DIVISION.

Leia o cabeçalho.

Leia os comentários.

Observe datas.

Procure padrões.

Veja quando determinadas rotinas apareceram.

Pergunte por que existe determinado layout.

Investigue aquele LRECL=80.

Observe os copybooks.

Descubra quem produz os arquivos.

Descubra quem os consome.

Veja JCL.

Procure dependências CICS, Db2, MQ, VSAM.

Leia antes de julgar.

O primeiro dever do arqueólogo não é cavar.

É compreender o terreno.


Epílogo — O próximo nome

Antes de sair do CPD, Guilherme voltou ao início do programa.

Havia espaço para uma nova inscrição.

O jovem havia terminado sua primeira manutenção importante.

Digitou:

*****************************************************************
* NOVO PROGRAMADOR
* 07/09/2026
* ADEQUACAO DA INTERFACE PARA NOVO SERVICO
*****************************************************************

Ficou olhando.

Acima dele havia nomes de pessoas que trabalharam naquele programa antes mesmo de ele nascer.

— Estranho — disse. — Parece que meu nome não deveria estar junto dos deles.

Guilherme respondeu:

— Agora compreendeu.

— O quê?

— A catedral nunca foi deles.

O jovem esperou.

— Tampouco é sua.

E então veio a lição final:

Você apenas recebeu a chave por algum tempo.

Talvez seja essa a melhor definição de trabalhar com sistemas legados.

Não somos proprietários absolutos deles.

Somos seus guardiões temporários.

Recebemos programas construídos por pessoas que não conhecemos.

Encontramos suas assinaturas entre asteriscos.

Descobrimos decisões tomadas quando computadores, empresas e o próprio mundo eram diferentes.

Preservamos o que ainda possui valor.

Corrigimos aquilo que envelheceu.

Retiramos aquilo que se tornou perigoso.

E acrescentamos as tecnologias da nossa época.

O pedreiro deixou sua marca.

O escultor deixou sua criatura fantástica.

O restaurador deixou um astronauta.

O programador de 1983 deixou COBOL.

O de 2003 deixou XML.

O de 2026 deixou JSON e uma API.

Algum outro, no futuro, acrescentará algo cujo nome ainda nem conhecemos.

E talvez, antes de modificar o programa, ele suba algumas páginas e encontre:

*****************************************************************
* V. BELLACOSA
* 2026
* ...
*****************************************************************

Não saberá exatamente quem foi aquele homem.

Talvez procure.

Talvez não.

Mas durante alguns segundos saberá uma coisa:

outro artesão trabalhou naquela pedra antes dele.

E é isso que torna o legado tão diferente de simplesmente possuir código antigo.

O legado não é aquilo que ficou velho.

Legado é aquilo que alguém construiu bem o bastante para chegar até nós — e que nós cuidamos bem o bastante para entregar ao próximo.

Os cartões desapareceram.

As perfuradoras silenciaram.

Os terminais mudaram.

As máquinas foram substituídas.

As linguagens ganharam companheiras.

Vieram bancos relacionais, mensagens, Web, XML, JSON, APIs, cloud e IA.

Mas em algum dataset ainda encontramos:

RECFM=FB
LRECL=80

E em algum fonte ainda encontramos:

*****************************************************************
* NOME
* DATA
* O QUE FOI FEITO
*****************************************************************

São duas inscrições da mesma civilização.

Uma conta como construíamos.

A outra conta quem construiu.

E enquanto aquela catedral continuar processando transações, calculando valores, movimentando negócios e terminando suas madrugadas com:

RC=0000

o sino continuará tocando.

Para os usuários, será apenas mais um processamento concluído.

Para quem aprendeu a ler as pedras, porém, haverá ali algo muito maior:

cinquenta anos de engenheiros, analistas, operadores e programadores dizendo silenciosamente através do código:

Nós estivemos aqui.



O Manual da Guilda do Programador Mainframe — Do Rank F ao Rank S

 
Bellacosa Mainframe e o manual para um dev programador cobol iniciante nas artes secretas do mainframe

Um Café no Bellacosa Mainframe

O Manual da Guilda do Programador Mainframe — Do Rank F ao Rank S

Ou: como COBOL, JCL, Db2, CICS, RACF, dumps, documentação, café, S0C7, SQLCODE -911, ICH408I, Technical Debt, Deadline e o Demon Lord Boleto transformaram uma carreira de TI no RPG mais longo que você jamais instalou

Existe um momento inesquecível na vida de todo programador mainframe.

Você recebe seu primeiro USERID.

Alguém lhe entrega uma senha temporária.

Você acessa uma tela preta.

No alto aparece algo que parece ter sido construído numa civilização anterior à invenção do mouse.

Você olha aquilo.

Aquilo olha para você.

Parabéns.

Você acaba de entrar na:


GUILDA DOS PROGRAMADORES MAINFRAME

Seu Rank atual:

F

Sua classe:

Novato

Experiência:

0 XP

Equipamento:

  • um notebook corporativo;

  • um USERID recém-criado;

  • uma senha que expirará no pior momento possível;

  • três PDFs;

  • acesso limitado;

  • nenhum conhecimento sobre produção;

  • uma caneca de café.

Sua primeira quest aparece:

ALTERE UMA MENSAGEM NUM PROGRAMA COBOL.

Dificuldade estimada:

Dificuldade percebida pelo novato:

⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐

Você ainda não sabe, mas acabou de iniciar um dos RPGs profissionais mais longos existentes.

Não existe tela de Game Over.

Existe:

ABEND



1. Antes de começar: escolha sua classe

Nos RPGs tradicionais escolhemos Warrior, Mage, Cleric ou Rogue.

No Mainframe RPG também existem classes.

COBOL Developer — Warrior

Ataca problemas diretamente.

Sua arma principal é:

IF
   ...
ELSE
   ...
END-IF

Possui resistência extraordinária a sistemas com quarenta anos.

Fraqueza natural:

dados inválidos.


Db2 Specialist — Mage

Manipula entidades invisíveis chamadas tabelas, índices, packages e access paths.

Seu feitiço favorito:

SELECT

Seu feitiço proibido:

DELETE FROM TABELA;

sem WHERE.

Quando isso acontece, nem resurrection spell resolve facilmente.


CICS Specialist — Rogue

Extremamente rápido.

Trabalha em milissegundos.

Conhece transações, regions e resources.

Seu inimigo natural é alguém dizendo:

“CICS está lento.”

Sem fornecer nenhuma outra informação.


RACF Administrator — Paladin

Guardião das portas.

Decide quem entra.

Quem lê.

Quem altera.

Quem executa.

Seu poder supremo é dizer:

ACCESS DENIED.

Não importa se você é diretor, gerente, arquiteto ou primo do CEO.


System Programmer — Archmage

Classe misteriosa.

Habita regiões profundas do reino chamadas PARMLIB, PROCLIB e SYS1.

Fala palavras como:

IPL.

APF.

LPA.

SVC.

SMF.

WLM.

SMP/E.

Quando entra numa War Room, todos ficam um pouco mais tranquilos.

Ou mais preocupados.

Depende da expressão dele.



2. Rank F — O Novato

Você começa no Rank F.

Não sabe quase nada.

E isso é perfeitamente normal.

Seu primeiro grande aprendizado é descobrir que não saber não é um defeito inicial: é o estado padrão da profissão.

Quests do Rank F

  • acessar TSO/ISPF;

  • navegar entre datasets;

  • entender PDS e membros;

  • editar um programa COBOL;

  • compilar;

  • executar um JOB;

  • consultar SDSF;

  • descobrir por que o JOB não terminou;

  • aprender a diferença entre erro de compilação e ABEND;

  • entender que produção não é lugar para experiências criativas.

Equipamento inicial

Espada COBOL +1

Escudo JCL +1

Mapa ISPF +2

Poção Café +5 concentração

Pergaminho “Manual da Empresa” +10 confusão

Skill especial

ASK SENIOR

Cooldown:

depende do humor do senior.

É provavelmente a skill mais importante dessa fase.



3. O primeiro monstro: JCL ERROR

Você submete seu primeiro JOB.

Espera.

Nada.

Olha novamente.

Descobre uma mensagem.

O coração acelera.

Você pensa:

“Quebrei o mainframe.”

Não.

Provavelmente esqueceu uma vírgula.

Mas essa primeira batalha ensina uma regra fundamental:

Leia a mensagem de erro.

Parece óbvio.

Não é.

Programadores frequentemente passam vinte minutos imaginando teorias sofisticadas enquanto o sistema está dizendo exatamente o problema.

O aventureiro experiente aprende:

Primeiro leia o que o monstro escreveu.

Depois desembainhe a espada.



4. Rank E — Junior

Depois de algumas quests você sobe para Rank E.

Agora consegue fazer pequenas alterações sem supervisão constante.

Isso produz um fenômeno perigoso:

confiança.

Você começa a achar que entende o sistema.

O sistema percebe.

E envia seu primeiro boss.

S0C7


5. Boss #1 — S0C7, o Devorador de Dados

Você executa o programa.

Ele morre.

Na tela:

S0C7

O novato pergunta:

— O que significa?

O veterano responde:

— Data Exception.

Tradução RPG:

Você tentou tratar alguma coisa como número e aquilo discordou.

Talvez um campo numérico contenha dados inválidos.

Talvez exista problema de definição.

Talvez um movimento tenha colocado conteúdo inesperado numa área.

A batalha começa.

Armas contra S0C7

  • dump;

  • offset;

  • listing;

  • compile options;

  • análise dos dados;

  • conhecimento das PICs;

  • atenção.

XP recebido

+350 DEBUGGING

Achievement desbloqueado

“Meu primeiro ABEND.”

Todo programador mainframe deveria receber um badge por isso.


6. Rank D — Pleno em formação

Agora você começa a compreender que programa nenhum vive sozinho.

Seu COBOL conversa com:

Db2.

VSAM.

CICS.

MQ.

Arquivos.

Outros programas.

Jobs.

APIs.

Usuários.

E processos de negócio criados antes de você entrar na empresa.

Você acaba de desbloquear:

DEPENDENCY HELL

A dungeon aumentou.


7. A Party

Nenhum aventureiro sensato entra sozinho numa dungeon perigosa.

No mainframe também não deveria.

Sua party pode possuir:

COBOL Developer

Ataca o código.

DBA

Controla os dragões relacionais.

System Programmer

Manipula as forças fundamentais do z/OS.

Security Specialist

Possui as chaves do castelo.

Production Control

Conhece horários e dependências.

Business Analyst

Traduz a misteriosa linguagem dos usuários.

Support

Sabe onde os cadáveres estão enterrados.

A grande skill profissional aparece quando você percebe:

não precisa saber tudo; precisa saber quem sabe.

Isso vale mais XP do que decorar centenas de comandos.


8. Boss #2 — SQLCODE -911, o Senhor dos Locks

Você escreve SQL.

Testa.

Funciona.

Produção chega.

Então:

SQLCODE = -911

O monstro apareceu.

Rollback.

Deadlock.

Timeout.

Seu programa estava disputando recursos com outra coisa.

Você descobre que bancos de dados não são bibliotecas silenciosas.

São cidades.

Centenas ou milhares de transações querem acessar recursos simultaneamente.

Algumas leem.

Outras alteram.

Algumas seguram locks.

Outras esperam.

Até que Db2 olha para a situação e decide:

“Alguém precisa morrer.”

Parabéns.

Foi sua transação.

Skills necessárias

  • compreender COMMIT;

  • entender ROLLBACK;

  • conhecer locking;

  • investigar concorrência;

  • analisar tempo de transação;

  • compreender access paths;

  • conversar com DBA.

XP

+750 CONCURRENCY

Loot

Anel do COMMIT Frequente

Use com sabedoria.

Commit demais também pode trazer problemas.


9. Rank C — O profissional que começa a enxergar o sistema

Aqui ocorre uma transformação importante.

Você deixa de perguntar apenas:

“Onde está o erro?”

E começa a perguntar:

“Por que esse erro aconteceu?”

Essa mudança parece pequena.

Não é.

É a passagem de executor para analista.

O Rank F corrige o registro.

O Rank C pergunta quem gerou o registro errado.

O Rank F reinicia o JOB.

O Rank C pergunta por que ele falhou.

O Rank F libera espaço.

O Rank C pergunta por que o crescimento não foi previsto.

Você começa a combater causas, não apenas sintomas.


10. Boss #3 — ICH408I, o Guardião das Portas

Você executa alguma coisa.

Recebe:

ICH408I

Você tenta novamente.

ICH408I

Mais uma vez.

ICH408I

O RACF não muda de opinião porque você clicou três vezes.

Esse boss ensina uma das regras fundamentais de segurança:

autenticação não significa autorização.

Você conseguiu entrar no reino.

Isso não significa que pode abrir todas as portas.

Talvez seu USERID não tenha acesso.

Talvez o grupo esteja incorreto.

Talvez o perfil proteja o recurso.

Talvez você precise de READ.

UPDATE.

CONTROL.

ALTER.

E talvez você não devesse receber nenhum deles.

Arma recomendada

Não é:

“Me dê ALTER em tudo.”

A arma correta chama-se:

Least Privilege.

XP

+900 SECURITY

Achievement

“RACF disse não.”


11. Equipamentos raros

Com o tempo você começa a colecionar equipamentos.

Não são espadas.

São ferramentas.

Debugger

Item raro.

Permite observar o monstro antes que ele mate seu programa.

Git

Inventário dimensional.

Guarda versões anteriores das suas armas.

Pipeline CI/CD

Esteira mágica que transporta artefatos entre reinos.

Monitoramento

Olho de Sauron corporativo.

Idealmente usado para observar sistemas, não hobbits.

Logs

Pergaminhos proféticos.

Quase sempre possuem pistas.

Documentação

Item lendário.

Extremamente poderoso.

Raramente atualizado.


12. Rank B — Senior

Aqui surge uma coisa curiosa.

Você sabe muito mais.

Mas começa a dizer:

“Depende.”

O junior acha isso frustrante.

Ele pergunta:

— Qual é a melhor solução?

Senior:

— Depende.

— Qual banco devemos usar?

— Depende.

— Devemos fazer COMMIT aqui?

— Depende.

— Podemos colocar isso em produção?

O senior olha fixamente.

Depende muito.

Isso não é indecisão.

É percepção de contexto.

Quanto mais você aprende, mais percebe quantas variáveis existem.


13. Boss #4 — Deadline, o Senhor do Tempo

Nenhum treinamento prepara adequadamente para esse monstro.

Deadline possui habilidade especial:

TIME COMPRESSION

Projeto de seis meses.

Prazo:

três meses.

Depois:

dois.

Então alguém pergunta:

“Conseguimos entregar sexta?”

Você olha o calendário.

Hoje é quinta.

Ataques do Deadline

  • reunião de status;

  • daily adicional;

  • planilha vermelha;

  • “quick win”;

  • “só falta um detalhe”;

  • mudança de requisito;

  • reunião para discutir por que existem tantas reuniões.

Defesa

  • estimativa realista;

  • priorização;

  • gerenciamento de risco;

  • documentação;

  • comunicação;

  • coragem profissional para dizer:

“Não.”

Essa última é uma skill Rank A.


14. Boss #5 — Technical Debt, o Monstro que Alimentamos

Esse é diferente.

Ele não aparece repentinamente.

Nós o criamos.

Começa pequeno.

“Depois corrigimos.”

“É temporário.”

“Só para entrar em produção.”

“Na próxima release melhoramos.”

Cada frase adiciona HP ao monstro.

Cinco anos depois existe uma rotina de 8.000 linhas que ninguém quer tocar.

O comentário diz:

* TEMPORARIO - NAO REMOVER
* 2007

Estamos em 2026.

O temporário completou dezenove anos.

Pode votar.

😂

Technical Debt Level 80

Ataques:

  • manutenção cara;

  • regressões;

  • medo de mudança;

  • conhecimento concentrado;

  • documentação inexistente;

  • dependências misteriosas.

Fraqueza

Refactoring controlado.

Testes.

Documentação.

Automação.

Tempo.

Naturalmente, o Deadline Boss geralmente impede que você use essas armas.

Os dois trabalham juntos.


15. Rank A — Especialista

O especialista não é necessariamente quem conhece mais comandos.

É quem possui profundidade suficiente para compreender consequências.

Ele começa a enxergar sistemas como ecossistemas.

Uma alteração COBOL pode afetar Db2.

Db2 pode alterar tempo de resposta.

Tempo de resposta pode afetar CICS.

CICS pode afetar usuários.

Usuários podem afetar faturamento.

Faturamento pode afetar diretoria.

Diretoria pode afetar você.

Tudo está conectado.

Skill desbloqueada

SYSTEM THINKING +100


16. A Skill lendária: reconhecer padrões

Um jovem olha um incidente e vê:

ERROR

O especialista olha e pensa:

“Já vi algo parecido.”

Não exatamente aquilo.

Mas algo parecido.

Essa biblioteca mental foi construída durante milhares de horas.

Incidentes.

Projetos.

Erros.

Migrações.

Falhas.

Sucessos.

Madrugadas.

É uma espécie de machine learning biológico.

Dataset:

sua carreira.

Treinamento:

vinte anos.

Inference:

“Olha aquele job primeiro.”


17. O sorriso ninja

Então aparece uma ferramenta nova.

Nova release.

Interface redesenhada.

Cloud.

API.

IDE.

Pipeline.

Você nunca utilizou exatamente aquela versão.

Cliente pergunta:

— Você sabe fazer?

Você:

😎

— Sei.

Internamente:

🦋🦋🦋🦋

O que você realmente quis dizer foi:

“Conheço suficientemente bem esse tipo de problema para descobrir como essa versão resolveu mudar tudo.”

Isso não é necessariamente blefe.

É confiança na capacidade de aprender.

A skill chama-se:

RELEARN

Rank:

S


18. Rank S — Mestre da Guilda

Pouquíssimos chegam aqui no sentido verdadeiro.

Não é determinado por idade.

Nem apenas por certificações.

Rank S aparece quando conhecimento técnico, experiência, contexto, comunicação e capacidade de formar outras pessoas começam a trabalhar juntos.

O Mestre da Guilda não precisa resolver tudo pessoalmente.

Ele sabe organizar a batalha.

Pergunta:

— O que mudou?

— Quando começou?

— Qual impacto?

— Conseguimos reproduzir?

— Temos rollback?

— Quem conhece esse componente?

— Quais evidências temos?

Observe.

Nenhuma magia.

Somente método.


19. A árvore de Skills

Depois de muitos anos, uma árvore possível poderia parecer assim:

PROGRAMADOR MAINFRAME
│
├── COBOL
│   ├── Estruturas
│   ├── Arquivos
│   ├── Debugging
│   └── Performance
│
├── JCL
│   ├── JOB
│   ├── EXEC
│   ├── DD
│   └── Utilities
│
├── DATA
│   ├── VSAM
│   ├── Db2
│   └── IMS
│
├── ONLINE
│   └── CICS
│
├── INTEGRATION
│   ├── MQ
│   ├── APIs
│   └── z/OS Connect
│
├── SECURITY
│   └── RACF
│
├── DEVOPS
│   ├── Git
│   ├── CI/CD
│   └── Automation
│
└── VETERAN SKILLS
    ├── Debugging
    ├── Comunicação
    ├── Contexto
    ├── Mentoria
    ├── Pattern Recognition
    └── Relearn

A última árvore costuma ser a mais difícil.

Não existe curso de quatro horas para obter vinte anos de contexto.


20. Como ganhar XP de verdade

Nem todo XP vem de certificação.

Alguns dos maiores ganhos acontecem quando algo dá errado.

Quest: corrigir primeiro ABEND

+500 XP

Quest: resolver incidente em produção

+1.000 XP

Quest: admitir que sua alteração causou o incidente

+2.000 XP

Quest: documentar para ninguém repetir

+3.000 XP

Quest: ensinar um junior

+5.000 XP

Quest: impedir um incidente antes que aconteça

+10.000 XP

Curiosamente, essa última geralmente não recebe reconhecimento.

Porque nada aconteceu.

Esse é o paradoxo do bom profissional de infraestrutura.


21. Side quests

Durante sua carreira aparecem missões secundárias.

“Aprenda Python.”

“Conheça Cloud.”

“Faça certificação.”

“Estude APIs.”

“Aprenda Git.”

“Agora containers.”

“Agora IA.”

Você abre seu mapa.

Existem 847 quests pendentes.

E apenas 24 horas por dia.

Então desbloqueia uma habilidade fundamental:

SELECT QUEST

Não tente aprender tudo.

Escolha aquilo que aproxima você de algum objetivo.

Senão você passará a vida coletando XP sem terminar a campanha principal.


22. O item mais raro: Tempo

Dinheiro compra livros.

Cursos.

Computadores.

Certificações.

Mas existe um recurso que não pode ser farmado:

tempo.

Um curso gratuito de quarenta horas custa quarenta horas.

Talvez valha.

Talvez não.

O aventureiro Rank S aprende a perguntar:

“Este conhecimento vale o tempo necessário para adquiri-lo?”

Porque cada curso compete com trabalho, descanso, família, leitura, caminhada...

e anime.

Nunca esqueçamos o anime.


23. O chefão secreto: Síndrome do Impostor

Mesmo depois de milhares de XP aparece uma criatura invisível.

Ela sussurra:

“Você não sabe o suficiente.”

Tecnicamente ela está correta.

Ninguém sabe.

O problema está na conclusão seguinte:

“Portanto você não deveria estar aqui.”

Errado.

O especialista não é aquele que sabe tudo.

É aquele que desenvolveu métodos para lidar com aquilo que não sabe.

Essa distinção salva carreiras.


24. O Boss final

Depois de COBOL.

Depois de Db2.

Depois de CICS.

Depois de RACF.

Depois do S0C7.

Depois do -911.

Depois do ICH408I.

Depois do Deadline.

Depois do Technical Debt.

Você acredita estar preparado.

Então o céu escurece.

A música muda.

Surge uma criatura gigantesca.

HP:

Resistência:

100%

Respawn:

MENSAL

Nome:

BOLETO

O Demon Lord definitivo.


25. Boleto — Level 99

Você pode trocar de emprego.

Boleto acompanha.

Pode virar freelancer.

Ele encontra você.

Pode tornar-se consultor.

Ele escala junto.

Pode tirar férias.

Ele sabe onde você mora.

Sua habilidade suprema chama-se:

VENCIMENTO

Todo mês ele retorna.

Isso explica boa parte da economia da Guilda.

O aventureiro veterano pensa:

“Talvez eu pare de aceitar projetos.”

Boleto:

“Interessante.”

😂

E imediatamente aparece no LinkedIn:

COBOL/Db2 Senior Consultant — Immediate Start — 6 months.

O velho aventureiro olha para a espada pendurada na parede.

Suspira.

— Uma última quest.

Boleto sorri.

Ele já ouviu isso antes.


26. New Game+

Existe, porém, uma fase curiosa da carreira.

Depois de acumular conhecimento suficiente, você começa a ensinar.

E ensinar é uma espécie de:

NEW GAME+

Você retorna às primeiras dungeons.

Só que agora acompanha novos aventureiros.

O junior pergunta:

— O que é S0C7?

Você sorri.

Lembra do seu primeiro.

Explica.

Ele resolve.

Ganha XP.

E alguma coisa interessante acontece.

Você também ganha.

Porque ensinar força a organizar aquilo que anos de experiência deixaram intuitivo.

Talvez essa seja uma das formas mais bonitas de veterania.

Transformar cicatrizes em mapas para quem vem depois.


27. Easter Egg — o verdadeiro Rank S

Existe um segredo escondido neste manual.

Rank S não significa:

Super Senior.

Significa:

Sobrevivente.

Sobreviveu às mudanças.

Às releases.

Aos projetos.

Aos incidentes.

Às tecnologias “que acabariam com o mainframe”.

Às reorganizações.

Às ferramentas revolucionárias.

Às interfaces redesenhadas.

Às certificações.

Ao Ceifeiro Silencioso.

Ao Deadline.

Ao Technical Debt.

E, até agora...

ao Boleto.

Mas sobretudo sobreviveu sem perder completamente uma coisa:

curiosidade.

Porque quando a curiosidade morre, estudar vira apenas obrigação.

E uma carreira tecnológica sem vontade de descobrir coisas novas transforma cada atualização numa punição.


28. A regra de ouro da Guilda

Se eu tivesse que entregar somente uma regra ao programador começando hoje, seria:

Aprenda fundamentos profundamente e ferramentas suficientemente.

Ferramentas mudam.

Interfaces mudam.

Versões desaparecem.

Menus migram.

Produtos são renomeados.

Mas compreender transações, dados, concorrência, segurança, arquitetura, debugging e sistemas continuará permitindo que você reconheça os mesmos monstros usando roupas diferentes.

O goblin de 1998 pode aparecer em 2027 com Kubernetes, API REST e inteligência artificial.

Continua sendo goblin.

Só ganhou marketing.


Epílogo — A próxima quest

03:17.

Telefone toca.

Produção está parada.

Um jovem Rank F olha assustado para o terminal.

Ao lado dele existe um veterano Rank S.

— O que faço?

O veterano coloca a caneca de café sobre a mesa.

— Primeiro, não faça nada.

— Como assim?

— Leia.

Eles olham os logs.

O jovem encontra uma mensagem:

ICH408I

— RACF?

O veterano sorri.

— Talvez.

— Você não sabe?

— Ainda não.

O jovem estranha.

Aquele homem possui décadas de experiência.

Como pode responder “não sei”?

O veterano continua:

— Vamos descobrir.

Nesse instante o jovem aprende uma coisa muito maior do que RACF.

Descobre o verdadeiro significado de experiência.

Não é possuir todas as respostas.

É não precisar fingir que possui.

É saber investigar.

Saber testar.

Saber pedir ajuda.

Saber voltar atrás.

Saber diferenciar evidência de palpite.

Saber quando agir.

E, talvez ainda mais importante...

saber quando não agir.

Alguns minutos depois encontram a causa.

04:02.

Produção retorna.

O jovem sorri.

QUEST COMPLETE

+1.000 XP

SKILL UNLOCKED: INCIDENT ANALYSIS

Ele pergunta:

— Um dia chego ao Rank S?

O veterano pega novamente o café.

— Se continuar estudando.

— Só isso?

— Não.

— Trabalhando?

— Também.

— Então como?

O veterano olha para a enorme sala de máquinas.

COBOL continuará executando.

Db2 continuará protegendo dados.

CICS continuará processando transações.

RACF continuará dizendo não.

S0C7 continuará encontrando campos impossíveis.

SQLCODE -911 continuará lembrando que ninguém trabalha sozinho.

Deadline continuará correndo.

Technical Debt continuará crescendo escondido.

Novas ferramentas chegarão.

Interfaces serão redesenhadas.

E o Boleto...

Bem.

O Boleto jamais será descontinuado.

Ele coloca a mão no ombro do novato.

— Continue entrando nas dungeons.

— Mesmo com medo?

O veterano abre o famoso sorriso ninja.

😎

— Principalmente quando houver algumas borboletas.

O jovem olha novamente para o terminal.

No canto inferior aparece:

READY

A próxima quest já está esperando.

Um Café no Bellacosa Mainframe

Mesmos sistemas. Novas histórias. Sempre um bom café.

Ficha final do personagem

Classe: Programador Mainframe
Rank inicial: F
Rank máximo: S
Arma: Conhecimento
Escudo: Experiência
Poção: Café
Mapa: Documentação
Party: Equipe
Skill lendária: Reaprender
Fraqueza: “É só uma alteraçãozinha”
Boss recorrente: Deadline
Boss ancestral: Technical Debt
Demon Lord: Boleto
Achievement final: Ainda curioso depois de décadas
Próxima missão: READY >

Para saber mais

https://eljefemidnightlunch.blogspot.com/2026/09/a-guilda-dos-aventureiros-mainframe-por.html



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