☕ 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

sexta-feira, 3 de julho de 2026

Dr. Strangelove, Watson e a Máquina que se Recusava a Morrer

 

Bellacosa Mainframe o mercado da informatica é muito louco

☕ Um Café no Bellacosa Mainframe

Dr. Strangelove, Watson e a Máquina que se Recusava a Morrer

💣 Como System/360, COBOL, watsonx, LinuxONE, IA, burocracia corporativa e uma aposta de US$ 5 bilhões explicam por que às vezes o maior risco de uma empresa é ter medo de arriscar

“Gentlemen, you can’t fight in here! This is the War Room!”

Se você começou a estudar COBOL recentemente, provavelmente alguém já lhe contou uma das três histórias oficiais do planeta Mainframe:

  1. COBOL é velho.

  2. Mainframe é velho.

  3. A IBM é aquela empresa muito antiga que fabrica computadores enormes que bancos inexplicavelmente ainda usam.

Parabéns.

Você acabou de receber aproximadamente o mesmo nível de precisão histórica de alguém explicando a Segunda Guerra Mundial dizendo:

“Foi uma briga grande que aconteceu antes da internet.”

Pegue seu café.

Hoje entraremos na War Room do Bellacosa Mainframe.

Na parede existe um mapa-múndi iluminado.

Em algum lugar um executivo segura uma pasta escrita:

CONFIDENTIAL — STRATEGIC TRANSFORMATION

Outro executivo pergunta se precisamos criar um Steering Committee para decidir quem participará do Steering Committee.

Enquanto isso, no subsolo, um programa COBOL escrito em 1978 processa R$ 4 bilhões antes do almoço e não parece particularmente impressionado.

Nosso assunto começa com uma pergunta simples:

Como uma empresa decide apostar seu próprio futuro?

Mas logo essa pergunta nos levará a Thomas Watson, IBM System/360, canibalização tecnológica, burocracia, Watson AI, Watson Health, watsonx, LinuxONE, IBM Z, Spyre, IA generativa e finalmente ao pobre programador COBOL iniciante tentando compreender por que um programa criado antes de ele nascer continua funcionando.

E, ao melhor estilo Dr. Strangelove, descobriremos que talvez o problema nunca tenha sido a bomba.

Talvez o problema seja descobrir quem tem autorização para apertar o botão.



☕ CAPÍTULO 1 — Antes do COBOL havia executivos malucos o suficiente para apostar a companhia

Quando estudamos tecnologia antiga, cometemos um erro clássico.

Olhamos para trás sabendo quem venceu.

Você vê o IBM System/360 e pensa:

“Claro que deu certo.”

Não.

Em 1964 ninguém recebeu do futuro um WhatsApp dizendo:

Thomas, relaxa. Vai funcionar. Abraços, 2026.

A IBM descreve o System/360 como uma aposta de aproximadamente US$ 5 bilhões, realizada ao longo de quatro anos, considerada um verdadeiro bet-the-business gamble. (IBM)

Cinco bilhões de dólares dos anos 1960.

Não era:

POC
↓
MVP
↓
piloto
↓
feedback
↓
release incremental

Era praticamente:

IBM
 |
 +---- dinheiro
 |
 +---- engenheiros
 |
 +---- fábricas
 |
 +---- reputação
 |
 +---- clientes
 |
 +---- carreira dos executivos
 |
 └----> SYSTEM/360
          |
          +---- se funcionar: futuro
          |
          └---- se falhar: procure emprego

Isso muda completamente nossa leitura da história.

Thomas J. Watson Jr. não sabia que estava construindo uma lenda.

Ele sabia que estava construindo um risco gigantesco.



🧠 CAPÍTULO 2 — O que havia de revolucionário no System/360?

Programador COBOL iniciante, atenção aqui.

Essa parte ajuda a entender praticamente todo o DNA do mainframe moderno.

Antes do System/360, fabricantes frequentemente criavam famílias de computadores bastante diferentes entre si.

Você comprava uma máquina pequena.

Sua empresa crescia.

Precisava de uma máquina maior.

Fantástico.

Só havia um pequeno problema.

Seu software poderia precisar ser profundamente alterado ou reescrito.

Imagine comprar um notebook novo e descobrir:

“Excelente máquina, senhor. Infelizmente todos os seus programas precisarão ser reprogramados.”

Não parece uma experiência de usuário particularmente elegante.

O System/360 atacou justamente essa fragmentação.

A proposta era criar uma família compatível de computadores, cobrindo diferentes níveis de capacidade dentro de uma arquitetura comum. A IBM descreve essa compatibilidade como uma das mudanças centrais introduzidas pelo System/360. (IBM)

Para o cliente isso significava algo extraordinário:

empresa pequena
      ↓
System/360 menor
      ↓
empresa cresce
      ↓
System/360 maior
      ↓
software continua relevante

Observe a ideia.

Não estamos mais vendendo apenas computadores.

Estamos vendendo uma arquitetura.

Essa distinção parece pequena.

Mudou a indústria.



💣 CAPÍTULO 3 — Dr. Strangelove explica canibalização

Agora imagine a reunião.

— Senhor Watson, temos vários computadores vendendo muito bem.

— Excelente.

— E vamos desenvolver uma família nova que poderá substituir esses produtos?

— Sim.

— Mesmo que eles sejam lucrativos?

— Sim.

— Então vamos concorrer conosco mesmos?

— Exatamente.

Nesse momento Dr. Strangelove levanta lentamente da cadeira.

Willkommen à canibalização tecnológica.

Canibalização significa criar um produto que ameaça parte da receita de outro produto da própria empresa.

Empresas adoram inovação até descobrirem que a inovação pretende mexer no faturamento existente.

Imagine:

PRODUTO A

Receita: $$$$$$$$
Clientes: muitos
Executivos: felizes
Bonificações: felizes

                 ↓

PRODUTO B

Tecnologia melhor
Potencial enorme
Receita inicial: $
Clientes: poucos
Executivos do produto A: subitamente preocupados

Do ponto de vista da empresa inteira, B talvez seja o futuro.

Do ponto de vista do diretor responsável por A:

B é Godzilla chegando em Tóquio.

E aqui começamos a compreender por que inovação em grandes empresas é um problema político, não apenas técnico.



🏢 CAPÍTULO 4 — O organograma também compila

Imagine uma empresa com um sistema chamado:

CUSTOMER-MASTER

Existe um gerente.

Acima dele existe um diretor.

Acima do diretor existe um vice-presidente.

Abaixo deles:

CUSTOMER-MASTER
      |
      +-- Development
      |
      +-- Support
      |
      +-- Sales
      |
      +-- Architecture
      |
      +-- Operations
      |
      +-- Budget
      |
      +-- 387 PowerPoints

Então aparece alguém dizendo:

“Tenho uma nova arquitetura capaz de substituir quase tudo isso.”

Tecnicamente:

fantástico.

Politicamente:

SOC7 organizacional.

Porque tecnologia distribui poder.

Produtos criam departamentos.

Departamentos criam cargos.

Cargos criam orçamento.

Orçamento cria influência.

Influência cria estruturas que começam a defender sua própria existência.

Portanto existe uma regra Bellacosa de arquitetura corporativa:

Todo software suficientemente antigo acaba ganhando um organograma.

E organogramas possuem uma característica peculiar:

raramente aceitam DELETE sem CONFIRM.



🩺 CAPÍTULO 5 — Management não é exatamente Leadership

Agora chegamos ao coração da discussão.

Um bom gerente pode perguntar:

Como reduzimos o custo desta operação em 4%?

Excelente pergunta.

Um líder estratégico pode perguntar:

Esta operação deveria existir daqui a dez anos?

Essa pergunta é muito mais perigosa.

Porque management tende a otimizar aquilo que existe.

Leadership precisa ocasionalmente decidir que aquilo que existe não deveria continuar existindo da mesma maneira.

Pense num programa COBOL.

Você recebe:

01 WS-TAXA PIC 9(03)V99.

Pode melhorar o código ao redor.

Documentar.

Criar testes.

Refatorar.

Otimizar SQL.

Tudo ótimo.

Mas talvez a pergunta estrutural seja:

Por que calculamos essa taxa aqui?

Essa pergunta pode revelar que toda a lógica deveria estar em outro domínio.

Leadership organizacional funciona parecido.



🧨 CAPÍTULO 6 — O projeto raramente morre com um tiro

Hollywood imagina decisões corporativas assim:

— PROJETO CANCELADO!

Na prática:

— Excelente ideia.

— Vamos analisar.

— Precisamos envolver stakeholders.

— Architecture precisa revisar.

— Finance precisa calcular ROI.

— Legal quer conversar.

— Risk solicita documentação.

— Security quer threat model.

— Procurement precisa verificar fornecedores.

— Precisamos criar governance.

— Vamos montar um working group.

— O working group recomenda um steering committee.

— O steering committee solicita nova análise.

Seis meses depois:

PROJECT STATUS
--------------
ON HOLD

Ninguém matou o projeto.

Ele faleceu calmamente cercado pela família.

Causa mortis:

burocratic latency.

Esse fenômeno é importante porque grandes empresas podem produzir decisões individualmente razoáveis que coletivamente geram resultados absurdos.

Security estava certo.

Finance estava certo.

Legal estava certo.

Architecture estava certo.

Procurement estava certo.

Todos estavam certos.

E o concorrente lançou o produto.



🧠 CAPÍTULO 7 — Thomas Watson Jr. não liderava uma startup

Existe uma tentação perigosa de imaginar a velha IBM como um pequeno laboratório romântico cheio de cientistas fumando cachimbo.

Nada disso.

Era uma organização gigantesca.

Watson Jr. aprofundou fortemente a posição da IBM em computação e pesquisa. A própria IBM destaca sua decisão de criar em 1956 uma divisão independente de pesquisa reportando à alta administração. (IBM)

Portanto o argumento não pode ser:

“IBM antiga inovava porque não tinha burocracia.”

Tinha.

O ponto interessante é outro:

a estratégia possuía autoridade suficiente para atravessar a burocracia.

Isso muda tudo.

Burocracia pode ser necessária.

Em bancos, saúde, seguros, telecomunicações e governo, processos existem porque erros custam muito.

O problema começa quando:

GOVERNANCE > DECISION

Governança deveria ajudar a empresa a decidir corretamente.

Não impedir a empresa de decidir.



🧪 CAPÍTULO 8 — Watson entra no Jeopardy!

Pulamos algumas décadas.

Chegamos à inteligência artificial.

IBM Watson ficou mundialmente famoso quando demonstrou uma capacidade impressionante em linguagem natural e recuperação de informação.

Tecnologicamente, aquilo ajudou a colocar IA novamente no imaginário empresarial.

Então apareceu um perigo conhecido.

O marketing começou a construir expectativas gigantescas.

Existe um abismo entre:

“Esta tecnologia consegue executar uma demonstração extraordinária.”

e:

“Esta tecnologia pode resolver genericamente problemas empresariais extremamente complexos.”

Pense no COBOL.

Um programa que calcula juros perfeitamente não significa que ele também consegue:

  • detectar fraude;

  • emitir cartão;

  • controlar estoque;

  • validar CPF;

  • administrar seguro;

  • calcular aposentadoria.

A tecnologia pode ser boa.

A generalização é que pode ser perigosa.



🏥 CAPÍTULO 9 — Watson Health e a dívida da expectativa

Saúde é um excelente exemplo.

Parece intuitivo pensar:

muitos artigos médicos
+
IA
=
diagnóstico fantástico

Só que medicina possui:

  • dados incompletos;

  • linguagem ambígua;

  • protocolos diferentes;

  • populações diferentes;

  • resultados probabilísticos;

  • prontuários inconsistentes;

  • responsabilidade clínica;

  • regulamentação;

  • conhecimento em constante mudança.

Transformar tecnologia impressionante numa plataforma clínica universal é enormemente mais difícil que uma demonstração controlada.

Em 2022, IBM anunciou a venda a Francisco Partners de determinados ativos de dados e analytics ligados ao Watson Health. (IBM Newsroom)

Isso não significa:

“Watson era uma fraude.”

Essa seria uma conclusão simplista.

Significa que existe diferença entre:

TECHNOLOGY SUCCESS

e:

BUSINESS MODEL SUCCESS

e ainda outra diferença:

BUSINESS MODEL SUCCESS

versus:

PLATFORM SUCCESS

Programadores precisam aprender isso cedo.

Código funcionando é apenas uma camada do problema.



💳 CAPÍTULO 10 — Technical Debt ganhou um irmão: Expectation Debt

Você provavelmente ouvirá muito sobre technical debt.

É a dívida técnica acumulada quando fazemos atalhos.

Mas existe outra dívida:

expectation debt.

Ela aparece assim:

CAPACIDADE REAL = 7

MARKETING = 47

O cliente compra expectativa 47.

Recebe tecnologia 7.

Mesmo que 7 seja excelente, a percepção será:

“Falhou.”

Isso é devastador.

Há produtos tecnicamente bons destruídos por expectativas impossíveis.

Uma regra importante:

Nunca venda amanhã como se estivesse disponível ontem.

Mainframe sobreviveu décadas em parte porque sua reputação empresarial é construída sobre previsibilidade.

Quando alguém promete 99,999..., existe engenheiro passando noites garantindo que aquela vírgula não seja poesia.


🤖 CAPÍTULO 11 — Então apareceu watsonx

Em 2023, IBM apresentou watsonx como uma plataforma empresarial de IA e dados. Originalmente, a estrutura foi apresentada em torno de componentes como watsonx.ai, watsonx.data e watsonx.governance, abordando desenvolvimento de modelos, dados e governança. (IBM Newsroom)

Aqui precisamos separar marketing de arquitetura.

watsonx não é simplesmente:

Watson + X

embora o departamento internacional de piadas corporativas agradeça a oportunidade.

Existe uma mudança conceitual importante.

Watson frequentemente era percebido como:

IBM possui uma IA capaz de resolver seu problema.

watsonx aproxima-se mais de:

IBM oferece componentes para você construir, operar e governar IA empresarial.

Isso é muito diferente.

Observe:

WATSON

problema
   ↓
IA IBM
   ↓
resposta

Agora:

WATSONX

modelos
   +
dados
   +
governança
   +
integração
   +
infraestrutura
   ↓
solução empresarial

Arquitetonicamente, isso talvez seja até mais coerente com o DNA histórico da IBM.


🏗 CAPÍTULO 12 — IBM geralmente é brilhante quando transforma tecnologia em infraestrutura

Esse ponto é fundamental.

System/360 não ganhou porque fazia uma demonstração bonita.

Ganhou porque criou uma arquitetura.

IBM historicamente é muito forte quando pega uma tecnologia complicada e pergunta:

Como transformamos isso em infraestrutura empresarial utilizável durante décadas?

Esse é exatamente o tipo de pergunta que interessa ao mundo COBOL.

COBOL não venceu porque era sexy.

COBOL venceu porque resolveu problemas empresariais.

Db2 não existe para impressionar pessoas no churrasco.

CICS não costuma aparecer em videoclipes.

IMS dificilmente ganhará influenciadores fazendo unboxing.

Entretanto:

SELECT
TRANSFER
COMMIT

precisa funcionar.

Às 03:17.

No domingo.

Durante fechamento.

Com metade da empresa dormindo.

Essa é outra filosofia de tecnologia.


🐧 CAPÍTULO 13 — O elefante Linux dentro do mainframe

Agora chegamos ao LinuxONE.

E aqui o programador iniciante costuma ter uma revelação.

— Bellacosa, Linux no mainframe?

Sim.

Respire.

O mundo não acabou.

LinuxONE é uma plataforma IBM baseada na arquitetura de sistemas empresariais da companhia para executar workloads Linux e open source. A geração LinuxONE 5 usa Telum II e pode ser expandida com aceleradores Spyre para aplicações envolvendo IA generativa e diferentes arquiteturas de modelos. (IBM)

Isso destrói uma caricatura muito comum:

MAINFRAME = COBOL

Não.

Mais correto:

MAINFRAME
  |
  +-- COBOL
  +-- Java
  +-- C/C++
  +-- Python
  +-- Linux
  +-- Containers
  +-- APIs
  +-- Databases
  +-- AI

COBOL é extremamente importante.

Mas mainframe é arquitetura, não linguagem.


🧠 CAPÍTULO 14 — LinuxONE talvez sofra de um problema de categoria mental

Diga:

“Mainframe Linux.”

Muitas pessoas imaginam:

computador velho rodando coisa nova.

Agora diga:

“plataforma Linux empresarial para consolidação massiva, alta disponibilidade, segurança, containers, dados e IA.”

A arquitetura não mudou.

Mudou a âncora cognitiva.

Isso é marketing estratégico.

Compare:

MAINFRAME QUE RODA LINUX

com:

ENTERPRISE LINUX PLATFORM

As duas descrições podem apontar para tecnologias semelhantes.

Mas uma olha para trás.

A outra olha para frente.

É por isso que a discussão sobre liderança importa até para você que está estudando PERFORM UNTIL.

Quem define a categoria define como o mercado enxerga a tecnologia.


🚀 CAPÍTULO 15 — Spyre entra na sala

Eis uma parte particularmente interessante da história contemporânea.

IBM Spyre é um acelerador destinado a inferência de IA em plataformas IBM Z e LinuxONE. A documentação atual da IBM o descreve como um acelerador PCIe voltado a ampliar capacidades de inferência, incluindo IA generativa; IBM também o posiciona para casos de IA generativa e agentic AI em LinuxONE 5. (IBM)

Por que isso é interessante?

Porque empresas possuem dados extremamente importantes em:

Db2
VSAM
IMS
SAP
Oracle
Core Banking
CICS

Tradicionalmente podemos imaginar:

TRANSAÇÃO
    ↓
extrair dados
    ↓
mover
    ↓
transformar
    ↓
enviar
    ↓
IA externa
    ↓
resultado

Mas outra filosofia seria:

TRANSAÇÃO
    ↓
DADOS
    ↓
INFERÊNCIA PRÓXIMA
    ↓
DECISÃO

Essa diferença pode ser gigantesca em latência, segurança, movimentação de dados e arquitetura.


💳 CAPÍTULO 16 — Imagine um programa COBOL detectando fraude

Você está começando COBOL.

Seu programa possui:

IF WS-VALOR > 10000
    PERFORM ANALISA-TRANSACAO
END-IF

Abordagem clássica:

regras fixas.

valor > limite?
país diferente?
horário estranho?
cartão novo?

Agora imagine complementar essa lógica com inferência.

COBOL
   ↓
TRANSAÇÃO
   ↓
modelo de fraude
   ↓
score
   ↓
COBOL
   ↓
aprova / revisa / bloqueia

O COBOL não precisa desaparecer.

Ele pode continuar controlando a transação.

A IA vira um novo componente da arquitetura.

Esta é uma dica importantíssima:

Modernização não significa necessariamente substituição.

Às vezes modernizar significa:

LEGADO
+
NOVO COMPONENTE
=
SISTEMA MODERNO

🦖 CAPÍTULO 17 — “Legacy” é uma palavra perigosamente mal utilizada

Quando alguém diz:

“Legacy system.”

Pergunte:

“Legacy em qual sentido?”

Velho?

Crítico?

Difícil de substituir?

Estável?

Lucrativo?

Bem compreendido?

Mal documentado?

Um programa escrito em 1988 pode ser tecnicamente antigo.

Mas se processa corretamente milhões de operações por dia, possui décadas de regras empresariais e custa menos que sua substituição, talvez ele não seja simplesmente “lixo velho”.

Ele pode ser:

capital intelectual executável.

Imagine:

IF CLIENTE-TIPO = 'A'
   AND OPERACAO = '37'
   AND DATA-CONTRATO < 19980101
       PERFORM REGRA-ANTIGA.

O programador jovem pensa:

“Que porcaria.”

O programador experiente pergunta:

“Por que contratos anteriores a 1998 possuem tratamento diferente?”

Depois de três semanas alguém encontra uma legislação extinta cuja regra ainda se aplica aos contratos históricos.

Parabéns.

Aquela linha estranha era direito empresarial fossilizado dentro de software.


🏛 CAPÍTULO 18 — Eis a ironia magnífica da IA

Durante vinte anos ouvimos:

“O problema são os sistemas legados.”

Agora chega IA e pergunta:

“Onde estão os dados empresariais confiáveis, históricos e transacionais?”

Silêncio.

DBA olha para o mainframe.

Programador COBOL olha para o Db2.

Operador olha para CICS.

Mainframe responde:

“Bom dia.”

😂

O que parecia passivo pode virar ativo.

Modelos de IA estão se tornando mais acessíveis.

Mas modelos sem contexto empresarial são apenas modelos.

A vantagem competitiva pode estar nos dados.

E gigantescos volumes desses dados continuam próximos de sistemas centrais.


🛰 CAPÍTULO 19 — Talvez o futuro não seja “mainframe versus cloud”

Essa guerra é preguiçosa.

MAINFRAME
VERSUS
CLOUD

Parece cartaz de luta livre.

A realidade empresarial é muito mais interessante:

                 CLIENTE
                    |
                 API
                    |
              OpenShift
             /         \
        CLOUD         ON-PREM
          |              |
       serviços       LinuxONE
                         |
                        Z
                         |
                    CICS/Db2
                         |
                       COBOL

Isso é hybrid cloud de verdade.

Não significa colocar tudo na cloud.

Nem deixar tudo no mainframe.

Significa colocar cada workload onde faz sentido.

A arquitetura adulta não pergunta:

“Qual tecnologia vence?”

Pergunta:

“Qual combinação minimiza risco e maximiza valor?”


🧠 CAPÍTULO 20 — O COBOLzeiro iniciante precisa aprender arquitetura antes de decorar verbo

Você aprenderá:

MOVE
COMPUTE
PERFORM
EVALUATE
READ
WRITE
REWRITE
CALL

Ótimo.

Mas não pare aí.

Pergunte sempre:

Passo 1 — De onde vem o dado?

VSAM?

Db2?

IMS?

MQ?

API?

Passo 2 — Quem chama meu programa?

JCL?

CICS?

Outro COBOL?

Java?

Scheduler?

Passo 3 — Para onde vai o resultado?

Arquivo?

Tabela?

Fila?

API?

Relatório?

Passo 4 — Qual é a unidade de recuperação?

Se falhar aqui:

ROLLBACK?

Restart?

Checkpoint?

Passo 5 — Quem depende disso?

Outro job?

CICS transaction?

Fechamento contábil?

PIX?

Cartão?

Passo 6 — Qual regra empresarial está escondida no código?

Isso transforma você de:

digitador COBOL

em:

engenheiro de sistemas.


🕵️ CAPÍTULO 21 — Dica Bellacosa: nunca ataque código antigo antes de interrogá-lo

Você encontra:

IF WS-CODIGO NOT = ZERO
    NEXT SENTENCE
ELSE
    PERFORM 9000-TRATA
END-IF.

Sua reação:

“Vou modernizar isso.”

Devagar, jovem Padawan.

Primeiro investigue:

  1. Quem chama?

  2. Existem testes?

  3. O ponto final altera escopo?

  4. GO TO envolvido?

  5. Qual compiler option?

  6. Existe copybook?

  7. O programa é chamado dinamicamente?

  8. Existem registros históricos dependentes?

  9. Qual retorno esperado?

  10. Existe processamento de exceção downstream?

Em mainframe, curiosidade vale mais que arrogância.

Easter egg: procure nos fontes por comentários como:

* DO NOT REMOVE

Nenhum arqueólogo sente mais medo ao abrir uma tumba do que um COBOLzeiro lendo isso.


📈 CAPÍTULO 22 — “Mas a IBM moderna está morta?”

Não.

Essa simplificação também seria errada.

Em 2025, a IBM reportou receita anual de aproximadamente US$ 67,5 bilhões, crescimento de 6% em moeda constante e free cash flow de US$ 14,7 bilhões. Ao final do ano, a companhia informou que seu book of business acumulado relacionado a IA generativa havia ultrapassado US$ 12,5 bilhões. (IBM Newsroom)

Portanto a crítica à IBM contemporânea precisa ser sofisticada.

Não:

“A IBM não consegue inovar.”

Isso não é sustentado pelos fatos.

IBM continua investindo em:

  • Z;

  • LinuxONE;

  • IA;

  • Research;

  • quantum;

  • Red Hat;

  • hybrid cloud;

  • software;

  • segurança.

A pergunta mais interessante é:

Consegue transformar todas essas peças numa visão tecnológica única tão poderosa quanto System/360 representou em sua época?

Essa é outra conversa.


🧩 CAPÍTULO 23 — O quebra-cabeça IBM contemporâneo

Olhe as peças:

IBM Z
   +
LinuxONE
   +
Red Hat
   +
OpenShift
   +
watsonx
   +
Spyre
   +
Db2
   +
Research
   +
Quantum
   +
Consulting

Isso não parece uma empresa sem tecnologia.

Parece uma empresa com tecnologia demais para explicar em uma única frase.

E aí surge um desafio estratégico.

System/360 tinha uma mensagem conceitual muito forte:

uma família compatível de computadores.

Agora tente resumir a IBM moderna em oito palavras.

Hybrid Cloud and AI?

Correto.

Mas ainda abstrato.

Uma visão estratégica forte precisa fazer o engenheiro, vendedor, cliente e investidor visualizarem o mesmo futuro.


💣 CAPÍTULO 24 — O verdadeiro Doomsday Device é não escolher

No filme Dr. Strangelove, existe uma máquina do juízo final construída para impedir ataques.

Há apenas um pequeno problema.

A lógica da máquina depende de o adversário saber que ela existe.

Dr. Strangelove praticamente enlouquece:

Qual é o propósito de uma máquina do juízo final secreta?

No mundo corporativo acontece algo semelhante.

Você pode possuir:

  • chips extraordinários;

  • mainframes extraordinários;

  • pesquisadores extraordinários;

  • IA extraordinária;

  • software extraordinário.

Mas se ninguém entende como essas peças formam uma tese:

qual é o propósito estratégico do arsenal?

Tecnologia precisa de arquitetura.

Arquitetura precisa de estratégia.

Estratégia precisa de escolha.

Escolha precisa de liderança.


🧨 CAPÍTULO 25 — A pergunta Watsoniana

Talvez a pergunta mais brutal que um CEO possa responder seja:

Qual produto lucrativo estamos dispostos a canibalizar para criar nosso próximo negócio?

Porque inovar onde nada está ameaçado é fácil.

Difícil é dizer:

“Essa receita existe hoje, mas acreditamos que outra arquitetura será melhor amanhã.”

Isso é System/360.

Watson Jr. comprometendo bilhões antes de saber o resultado.

Nós vemos:

1964
   ↓
SUCESSO

Ele via:

1964
   ↓
?????????

Essa diferença chama-se:

hindsight bias.


🎲 CAPÍTULO 26 — Teoria dos jogos dentro da empresa

Outro conceito importante para o COBOLzeiro.

Imagine dois executivos:

Diretor A: controla produto antigo.

Diretor B: controla produto novo.

Para a IBM:

Produto novo vencedor = ótimo.

Para A:

Produto novo vencedor = talvez perca poder.

Portanto o comportamento racional individual pode divergir do comportamento ideal para a organização.

Isso é um problema clássico de incentivos.

Aplicado a software:

Empresa quer:
simplificar arquitetura.

Equipe quer:
preservar sistema que domina.

Não necessariamente por maldade.

Pessoas respondem a incentivos.

Por isso transformações tecnológicas falham frequentemente mesmo quando todos concordam teoricamente com elas.


📜 CAPÍTULO 27 — Uma lição que COBOL ensina sobre liderança

COBOL possui uma característica curiosa:

é explícito.

IF SALDO < ZERO
   PERFORM COBRA-TARIFA
END-IF

Pode ser verboso.

Mas sabemos quem decidiu o quê.

Organizações modernas às vezes fazem o contrário.

IF PROJETO-FALHAR
    RESPONSABILIDADE = NINGUEM
END-IF

😂

Quando autoridade está fragmentada demais, ninguém consegue dizer sim.

Mas todos conseguem impedir.

Chamemos isso de:

PIC X(01) VALUE 'N'.


🚨 CAPÍTULO 28 — War Room: exercício para o iniciante

Imagine que você trabalha num banco.

Existe:

PROGRAMA: CRD001
IDADE: 31 anos
LINGUAGEM: COBOL
BANCO: Db2
ONLINE: CICS
VOLUME: 12 milhões transações/dia

Diretor aparece:

“Precisamos colocar IA.”

Erro número 1:

reescrever tudo.

Erro número 2:

enviar todas as transações para um chatbot.

Erro número 3:

criar 47 microsserviços porque alguém assistiu uma palestra.

O caminho inteligente começa assim.

ETAPA 1 — Entenda o fluxo

Terminal/API
    ↓
CICS
    ↓
CRD001
    ↓
Db2

ETAPA 2 — Identifique onde IA agrega valor

Talvez:

detecção de fraude

ETAPA 3 — Preserve processamento determinístico

COBOL continua fazendo:

validação
limites
regras legais
contabilização
commit

ETAPA 4 — Acrescente inferência

TRANSAÇÃO
   ↓
MODELO
   ↓
FRAUD-SCORE

ETAPA 5 — COBOL decide

EVALUATE TRUE
   WHEN FRAUD-SCORE > 900
      PERFORM BLOQUEIA
   WHEN FRAUD-SCORE > 700
      PERFORM REVISA
   WHEN OTHER
      PERFORM APROVA
END-EVALUATE

Agora temos modernização.

Não religião tecnológica.


🔬 CAPÍTULO 29 — O programador COBOL moderno precisa conhecer mais que COBOL

Sua trilha deveria progressivamente incluir:

COBOL
 |
 +-- JCL
 |
 +-- VSAM
 |
 +-- Db2
 |
 +-- CICS
 |
 +-- RACF
 |
 +-- MQ
 |
 +-- APIs
 |
 +-- z/OS Connect
 |
 +-- Git
 |
 +-- pipelines
 |
 +-- Linux
 |
 +-- containers
 |
 +-- observabilidade
 |
 └-- AI

Não precisa dominar tudo amanhã.

Mas precisa saber que tudo isso existe.

O mainframe moderno não é uma ilha.

É um aeroporto internacional.

COBOL é uma companhia aérea gigantesca operando nele.


🥚 EASTER EGG — O programa de 1978

Imagine um fonte:

      *---------------------------------------------*
      * CUSTOMER SETTLEMENT PROCESS                 *
      * AUTHOR: A. JOHNSON                          *
      * DATE:   12/SEP/1978                         *
      *---------------------------------------------*

O senhor Johnson escreveu aquilo.

Usando terminal que hoje estaria num museu.

Provavelmente nunca viu:

  • smartphone;

  • Kubernetes;

  • ChatGPT;

  • Linux;

  • GitHub;

  • Wi-Fi;

  • SSD;

  • JSON.

Talvez tenha se aposentado em 1997.

O programa continua rodando.

Em 2026 chega um desenvolvedor recém-formado.

Abre o código.

Diz:

“Nossa, isso é muito velho.”

O programa olha silenciosamente.

Já enterrou:

  • sete frameworks JavaScript;

  • quatro arquiteturas client/server;

  • três gerações de middleware;

  • SOAP;

  • CORBA;

  • Silverlight;

  • Flash;

  • dois datacenters;

  • onze diretores de tecnologia.

Então volta a processar arquivo.

MAXCC=0000

🧠 CAPÍTULO 30 — THINK

A palavra THINK possui raízes profundas na cultura histórica da IBM. A própria história corporativa relaciona Watson e posteriormente Watson Jr. a essa filosofia de pensar como instrumento prático para melhorar o negócio e enfrentar problemas grandes. (IBM)

O importante é entender o significado.

THINK não é:

pense eternamente.

THINK é:

questione pressupostos.

Para você, programador COBOL:

Por que esse arquivo existe?

Por que este job roda às 02:00?

Por que DISP=OLD?

Por que temos REDEFINES aqui?

Por que existe esta regra desde 1994?

Por que movemos estes dados para fora do mainframe?

Por que esta aplicação precisa ser reescrita?

Qual problema estamos realmente tentando resolver?

Essas perguntas valem ouro.


☢️ CAPÍTULO 31 — A síndrome do “vamos modernizar tudo”

Entre na War Room.

General Turgidson aponta para um mapa.

— Temos 14 milhões de linhas COBOL.

Executivo:

— Precisamos migrar tudo.

Bellacosa:

— Por quê?

Silêncio.

Executivo:

— Porque é legado.

— Está falhando?

— Não.

— Está caro?

— Não calculamos.

— Clientes reclamam?

— Não.

— Existe limitação tecnológica?

— Não sabemos.

— Então qual problema estamos resolvendo?

Outro silêncio.

Em algum canto Dr. Strangelove tenta impedir o próprio braço de fazer uma saudação indevida.

😂

Modernização deveria começar com um problema.

Nunca com um slogan.


🛠 CAPÍTULO 32 — Checklist mental Bellacosa para qualquer modernização

Antes de reescrever um COBOL, responda:

1. O sistema funciona?

2. Qual é o custo real?

3. Qual risco reduziremos?

4. Qual capacidade nova precisamos?

5. Podemos adicionar essa capacidade sem substituir tudo?

6. Onde estão as regras empresariais?

7. Existem testes suficientes?

8. Quem conhece o comportamento atual?

9. Qual estratégia de rollback?

10. Como provaremos equivalência funcional?

Se ninguém consegue responder, não existe projeto de modernização.

Existe uma aventura.

E aventura em produção costuma terminar no telefone.


💡 CAPÍTULO 33 — Cinco lições para levar para sua carreira COBOL

1. Arquitetura vive mais que produto

System/360 nasceu em 1964.

Suas ideias arquitetônicas deixaram descendentes que atravessaram décadas.

Aprenda arquitetura.


2. Compatibilidade possui valor econômico

Código antigo não sobrevive apenas porque empresas têm preguiça.

Sobrevive porque migração custa dinheiro e cria risco.


3. Estabilidade é uma feature

Dev jovem:

“Mas não mudou em quinze anos!”

Operações:

“Exatamente.”


4. Modernização não significa substituição

Talvez seu programa COBOL possa consumir API, produzir eventos, integrar IA ou participar de uma arquitetura híbrida.


5. Pergunte “por quê?” antes de perguntar “como?”

Essa é talvez a habilidade mais Watsoniana de todas.


🚀 CAPÍTULO 34 — O possível futuro

Imagine:

                     CLIENTES
                        |
                       API
                        |
                 z/OS Connect
                        |
              +---------+---------+
              |                   |
            CICS              OpenShift
              |                   |
            COBOL               Linux
              |                   |
             Db2               watsonx
              |                   |
              +---------+---------+
                        |
                     AI MODEL
                        |
                     SPYRE

Nenhuma dessas tecnologias precisa necessariamente destruir as outras.

Esse talvez seja o grande erro da discussão “legado versus moderno”.

O futuro provavelmente será:

legado + moderno + aquilo que ainda nem recebeu buzzword.


🎬 EPÍLOGO — Dr. Strangelove encontra o JCL

03:42 da madrugada.

War Room.

Um telão mostra:

JOB SETTLE01
STATUS: RUNNING

General pergunta:

— Esse é o sistema novo de inteligência artificial?

Operador responde:

— Não, senhor.

— Blockchain?

— Não.

— Kubernetes?

— Não.

— Quantum?

— Não.

— Agentic AI?

— Não.

— Então o que é?

Operador aproxima os óculos.

— COBOL.

Silêncio.

STEP010  RC=0000
STEP020  RC=0000
STEP030  RC=0000

Dr. Strangelove olha fascinado.

— Mein Gott... há quanto tempo funciona?

— Desde 1978.

— E ninguém substituiu?

— Tentaram.

— Quantas vezes?

— O senhor quer a resposta técnica ou a resposta que cabe no PowerPoint?



Thomas Watson Jr. apostou bilhões para construir uma arquitetura que poderia tornar produtos existentes obsoletos. System/360 tornou-se um dos grandes pontos de inflexão da história da computação. (IBM)

Décadas depois, a IBM continua possuindo engenheiros, pesquisa, hardware, software, Linux, mainframe, IA e tecnologias capazes de produzir novas combinações extraordinárias.

A discussão nunca deveria ser simplesmente:

“IBM antiga boa, IBM moderna ruim.”

Isso seria nostalgia barata.

A pergunta realmente valiosa é:

Uma organização gigantesca ainda consegue concentrar pessoas, dinheiro, autoridade e reputação em uma única aposta antes de possuir garantia de que ela funcionará?

Essa pergunta vale para IBM.

Vale para Microsoft.

Vale para Google.

Vale para bancos.

Vale para qualquer empresa.

E, curiosamente, vale para sua carreira.

Você pode passar os próximos vinte anos apenas mantendo programas.

Ou pode aprender por que eles existem.

Pode decorar COBOL.

Ou entender o sistema.

Pode tratar mainframe como tecnologia de 1964.

Ou perceber que aquela plataforma sobreviveu justamente porque continuou incorporando coisas que não existiam quando nasceu.

Talvez esse seja o verdadeiro legado dos Watson.

Não uma máquina.

Não um logo.

Não um slogan.

Mas a ideia quase irresponsável de que uma empresa de tecnologia precisa, ocasionalmente, estar preparada para construir aquilo que ameaça aquilo que ela já construiu.

Na parede da nossa War Room imaginária, portanto, colocaremos uma placa.

Não:

INNOVATE.

Muito genérico.

Não:

TRANSFORMATION.

RH já reservou essa palavra.

Não:

AI-POWERED HYBRID CLOUD DIGITAL-FIRST COGNITIVE ENTERPRISE.

A placa seria muito pequena.

Coloque apenas:

THINK.

E embaixo, numa fonte menor, reservado exclusivamente ao programador COBOL que chegou até aqui:

//SYSOUT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*

Porque podemos filosofar sobre liderança, inovação, Watson, IA e o futuro da computação durante duas horas.

Mas quando produção cair às 03:17...

eu quero o dump.

https://eljefemidnightlunch.blogspot.com/2026/08/a-causa-de-r-300-milhoes-e-o-if-do.html

https://eljefemidnightlunch.blogspot.com/2026/08/o-golpe-de-mestre-algoritmico-teoria.html

Programando COBOL no GitHub com VS Code Sem Mainframe. Sem Compilar. Apenas Aprendendo como um Desenvolvedor Moderno.

 


Bellacosa Mainframe usando o vs code para programar cobol numa ide moderna

☕ Um Café no Bellacosa Mainframe

Programando COBOL no GitHub com VS Code

Sem Mainframe. Sem Compilar. Apenas Aprendendo como um Desenvolvedor Moderno.

"Todo Jedi começa treinando com um sabre de luz desligado. Todo desenvolvedor Mainframe também pode começar sem um z/OS."


Antes de começarmos...

Existe um mito enorme no mundo Mainframe.

"Para aprender COBOL preciso de um IBM Z."

Não.

Outro mito:

"Para editar programas COBOL preciso de um emulador."

Também não.

Outro:

"Preciso instalar um compilador."

Ainda não.

Hoje vamos aprender exatamente como milhares de desenvolvedores modernos trabalham quando estão estudando, revisando código ou preparando alterações para um projeto.

Você vai usar apenas:

  • GitHub

  • Visual Studio Code

  • IBM Z Open Editor

  • Git

Nada mais.

Nenhum z/OS.

Nenhum TSO.

Nenhum ISPF.

Nenhuma licença IBM.

E, ainda assim, estará utilizando praticamente o mesmo editor utilizado por desenvolvedores COBOL profissionais.

Pegue seu café.

Vamos montar nosso laboratório.


Bellacosa Mainframe passo a passo na instalacao

A grande mudança de mentalidade

Imagine um mecânico.

Ele não liga um caminhão para trocar o volante.

Primeiro ele trabalha na peça.

Depois instala.

No Mainframe acontece exatamente igual.

Você pode editar, estudar, revisar e versionar milhares de programas COBOL sem sequer possuir acesso ao IBM Z.

O Mainframe só entra quando chega a hora de:

  • compilar

  • executar

  • testar online

  • acessar DB2

  • acessar CICS

  • executar JCL

Até lá...

Tudo pode ser feito localmente.


Nossa arquitetura

Imagine esta jornada.

GitHub
     │
git clone
     │
VS Code
     │
IBM Z Open Editor
     │
Editar COBOL
     │
Git Commit
     │
Git Push
     │
GitHub

Perceba.

O Mainframe nem apareceu.


O que vamos instalar

Nosso kit Bellacosa Mainframe será composto por:

✅ Visual Studio Code

✅ Git

✅ IBM Z Open Editor

✅ GitHub Pull Requests

✅ Error Lens

✅ Material Icon Theme

✅ Markdown All in One

✅ Code Spell Checker

✅ Todo Tree

✅ Peacock

Opcionalmente:

  • GitLens

  • Better Comments

  • YAML

  • XML

  • Rainbow CSV

  • Hex Editor

  • REST Client

Você perceberá que quase tudo é gratuito.


Passo 1 — Instale o Git

Sem Git...

não existe GitHub.

Baixe:

https://git-scm.com

Durante a instalação aceite praticamente tudo.

Depois abra um terminal.

Digite:

git --version

Se aparecer algo parecido com:

git version 2.51

Parabéns.

Seu sabre de luz foi montado.


Passo 2 — Instale o VS Code

Baixe em

https://code.visualstudio.com

Instale normalmente.

Abra.

Você verá uma tela praticamente vazia.

É aqui que a mágica acontece.


Passo 3 — Faça login no GitHub

No canto inferior esquerdo existe o ícone da conta.

Clique.

Escolha:

Sign In with GitHub

O navegador abrirá.

Autorize.

Volte ao VS Code.

Pronto.

Agora seu VS Code conversa diretamente com o GitHub.


Passo 4 — Instale o IBM Z Open Editor

Abra Extensions.

Pesquise:

IBM Z Open Editor

Instale.

Este plugin entende COBOL.

Ele conhece:

  • DIVISION

  • SECTION

  • PARAGRAPH

  • COPY

  • EXEC SQL

  • EXEC CICS

  • comentários

  • copybooks

É praticamente um ISPF moderno.


O que ele faz?

Quando você abre:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

Ele já entende que aquilo é COBOL.

Você ganha:

✔ Colorização

✔ Outline

✔ Auto Complete

✔ Navegação

✔ Hover

✔ Referências

✔ Folding

✔ Sintaxe

Tudo gratuitamente.


Passo 5 — Instale GitHub Pull Requests

Esse plugin é fantástico.

Ele permite:

  • abrir Pull Requests

  • revisar código

  • comentar linhas

  • aprovar alterações

Sem sair do VS Code.


Passo 6 — Material Icon Theme

Pequeno detalhe.

Grande diferença.

Agora:

📄 COBOL

📄 COPYBOOK

📄 JCL

📄 REXX

ganham ícones.

Seu projeto fica muito mais agradável.


Passo 7 — Error Lens

Esse plugin faz algo simples.

Mostra erros diretamente na linha.

Sem precisar olhar outro painel.

Economiza muito tempo.


Passo 8 — Better Comments

Imagine:

*> TODO

vira verde.

*> WARNING

fica amarelo.

*> BUG

fica vermelho.

Seu código passa a conversar com você.


Passo 9 — Todo Tree

Agora imagine possuir 3.000 programas.

Você procura:

TODO

Ele encontra todos.

Fantástico para projetos enormes.


Passo 10 — Clone seu GitHub

No terminal:

git clone https://github.com/seuusuario/IBMLearnCOBOL.git

ou simplesmente:

No VS Code:

Clone Repository

Cole a URL.

Pronto.


Estrutura típica

COBOL/
    HELLO.CBL
    CLIENTE.CBL
COPY/
    CLIENTE.CPY
JCL/
    COMPILA.JCL
REXX/
README.md

Tudo organizado.


Abrindo o projeto

Arquivo

Open Folder

Escolha:

IBMLearnCOBOL

Agora tudo aparece na lateral.

Exatamente como Java.

Exatamente como Python.


Editando um programa

Abra:

HELLO.CBL

Modifique:

DISPLAY "HELLO WORLD".

para

DISPLAY "HELLO BELLACOSA MAINFRAME".

Salve.

Só isso.


Observe o Git

Na lateral existe:

Source Control

Aparecerá:

M HELLO.CBL

M significa:

Modified.


Veja a diferença

Clique no arquivo.

O VS Code mostra:

esquerda

arquivo antigo

direita

arquivo novo.

Em verde:

linhas adicionadas.

Em vermelho:

linhas removidas.

É maravilhoso.


Criando um Commit

Na caixa superior escreva:

Alterado texto do HELLO WORLD

Clique:

Commit

Pronto.


Fazendo Push

Agora clique:

Sync

ou

Push

O Git envia tudo para o GitHub.

Seu código agora está online.


Histórico

Clique:

Timeline

Você verá:

  • quem alterou

  • quando

  • qual commit

  • diferença

É uma máquina do tempo.


GitLens

Se instalar GitLens...

fica ainda melhor.

Você passa o mouse.

Ele mostra:

Vagner Bellacosa

14 dias atrás

Commit:

Correção cálculo IRRF

Parece mágica.


Trabalhando com Branches

Nunca altere diretamente a Main.

Crie:

feature/curso-cobol

bugfix/cliente

feature/json

feature/db2

Isso é padrão de mercado.


Commits bons

Ruim:

teste

Ruim:

aaaa

Ruim:

mudança

Bom:

Inclui validação do CPF

Corrige cálculo de juros

Refatora rotina de leitura VSAM

Atualiza documentação

Organização Bellacosa

COBOL
COPY
JCL
BMS
DBRM
SQL
DOCS
LABS
QUIZZES

Tudo separado.

Tudo fácil.


Markdown

Documente tudo.

README.

Arquitetura.

Fluxo.

Exemplos.

O VS Code possui preview fantástico.


Dica de Ouro

Ative:

Auto Save

Você nunca esquecerá de salvar.


Outra dica

Use:

Minimap.

Você enxerga programas COBOL gigantes.


Outra

Breadcrumbs.

Você sabe exatamente:

DIVISION

SECTION

PARAGRAPH

onde está.


Outra

Outline.

Clique:

CALCULA-TOTAL

Vai direto para o parágrafo.

Adeus Page Down.


Outra

CTRL+P

Digite:

cliente

Abre CLIENTE.CBL imediatamente.


Outra

CTRL+SHIFT+O

Lista todos os parágrafos.

Fantástico.


Outra

CTRL+SHIFT+F

Procura em TODOS os programas.

Imagine localizar:

EXEC SQL

em 12.000 fontes.

Leva segundos.


Easter Egg nº 1

Troque o tema.

Experimente:

IBM Carbon Theme

ou

One Dark Pro.

Seu COBOL fica lindíssimo.


Easter Egg nº 2

Instale Peacock.

Cada Workspace ganha uma cor.

Nunca mais confundirá produção e laboratório.


Easter Egg nº 3

Digite:

>Preferences: Open Keyboard Shortcuts

Personalize tudo.


Easter Egg nº 4

Use emojis nos commits.

✨ Novo programa

🐞 Corrige bug

📚 Atualiza documentação

♻ Refatoração

🚀 Nova funcionalidade

Easter Egg nº 5

Use Copilot apenas para sugerir código.

Nunca aceite sem entender.

O bom desenvolvedor continua pensando.


Quando chegar o Mainframe...

Nada muda.

Você apenas instala:

IBM Zowe Explorer.

Então passa a acessar:

PDS

PDSE

USS

JES

Jobs

Datasets

O editor continua exatamente o mesmo.

É como aprender a dirigir em um simulador e depois entrar no carro real: os comandos principais permanecem familiares.


O verdadeiro objetivo

Aprender COBOL nunca foi decorar comandos do ISPF.

O objetivo é entender:

  • lógica de negócio;

  • arquitetura de sistemas;

  • qualidade de código;

  • versionamento;

  • colaboração;

  • documentação.

Essas habilidades acompanham você em qualquer plataforma.


Conclusão

Durante décadas, muitos imaginaram que o desenvolvimento Mainframe dependia de telas verdes, terminais 3270 e comandos memorizados. Hoje, essa realidade mudou. O Visual Studio Code, aliado ao IBM Z Open Editor e ao GitHub, oferece uma experiência moderna, produtiva e acessível para estudar, revisar e evoluir programas COBOL sem a necessidade imediata de um ambiente z/OS.

Ao dominar Git, commits bem escritos, branches, documentação em Markdown e a organização de projetos, você desenvolve competências valorizadas em qualquer equipe de engenharia de software. Quando chegar o momento de conectar-se a um IBM Z com o Zowe Explorer, a curva de aprendizado será muito menor, pois o editor, os atalhos e o fluxo de trabalho continuarão praticamente os mesmos.

Você não está abandonando o Mainframe tradicional. Está adicionando ferramentas modernas à sua caixa de ferramentas. Como costumo dizer no Bellacosa Mainframe: o terminal pode mudar, mas a excelência em engenharia de software continua sendo a mesma.

quinta-feira, 2 de julho de 2026

Capítulo 2 — A Década dos Buzzwords

Bellacosa Mainframe invente um nome um jargao e mate o mainframe

☕ Um Café no Bellacosa Mainframe

Capítulo 2 — A Década dos Buzzwords

Quando Bastava Inventar um Nome Bonito para Declarar a Morte do Mainframe

Uma análise histórica e bem-humorada dos buzzwords dos anos 1990, como Client/Server, Downsizing, Open Systems, RISC e Windows NT, que prometiam substituir o mainframe enquanto COBOL, CICS, Db2, JCL, z/OS e IBM Z continuavam evoluindo.

Por

A Década dos Buzzwords e as previsões sobre a morte do mainframe 

"Toda geração acredita ter inventado a computação. Toda geração descobre, alguns anos depois, que ainda existe um COBOL pagando salários."
— Bellacosa Mainframe


Bem-vindo aos anos 90

Se você é um Padawan COBOL e nasceu depois dos anos 2000, talvez seja difícil imaginar o clima que existia na indústria de tecnologia durante a década de 1990.

Hoje estamos acostumados a ouvir expressões como:

  • IA Generativa

  • LLM

  • Agentic AI

  • RAG

  • MCP

  • AI Native

  • Platform Engineering

  • Data Mesh

  • Cloud Native

Mas, naquela época, esses nomes ainda nem existiam.

Em compensação...

Os corredores das empresas eram inundados por outra coleção de palavras mágicas.

Client/Server.

Open Systems.

Downsizing.

Distributed Computing.

Workgroups.

LAN Computing.

Enterprise Networking.

Network Computing.

Object-Oriented.

Visual Programming.

Windows NT.

RISC.

Cada uma dessas expressões era apresentada como a solução definitiva para todos os problemas da computação corporativa.

Se um fabricante queria vender um servidor...

Colocava "Open" no nome.

Se queria vender uma ferramenta...

Chamava de "Client/Server".

Se queria convencer o diretor financeiro...

Prometia "Downsizing".

Se queria impressionar investidores...

Falava em "Distributed Computing".

Era a época em que o marketing tecnológico descobriu que uma boa buzzword podia vender mais do que um bom benchmark.


A religião do Client/Server

Nenhum termo foi tão poderoso quanto Client/Server.

Hoje ele parece apenas uma arquitetura comum.

Mas, no início dos anos 90, era quase uma religião.

Consultores viajavam o mundo inteiro mostrando diagramas semelhantes.

          [PC]
            |
          [Servidor]

Depois olhavam para um desenho de um mainframe.

          [IBM Mainframe]

E diziam:

— Está vendo?

Esse modelo é antigo.

Centralizado.

Monolítico.

O futuro é distribuído.

A ideia parecia excelente.

Dividir a carga.

Comprar servidores menores.

Dar autonomia às áreas.

Substituir um computador gigantesco por centenas de máquinas menores.

Na teoria...

Tudo fazia sentido.

Na prática...

As empresas descobriram algo curioso.

Um servidor pequeno é barato.

Quinhentos servidores pequenos...

Nem tanto.


Downsizing: a promessa de economizar milhões

Outra palavra extremamente popular era Downsizing.

O discurso era sedutor.

"Por que comprar um computador enorme quando podemos comprar dezenas de computadores baratos?"

A lógica parecia impecável.

O problema era um pequeno detalhe.

Ninguém havia calculado o custo de administrar centenas de computadores.

De repente apareceram problemas novos.

Mais backups.

Mais discos.

Mais sistemas operacionais.

Mais patches.

Mais licenças.

Mais administradores.

Mais falhas.

Mais consumo de energia.

Mais refrigeração.

Mais monitoramento.

Mais suporte.

O CPD não desapareceu.

Ele apenas ficou espalhado por vários racks.


Open Systems

Outra expressão quase obrigatória era:

Open Systems

Era impossível abrir uma revista técnica sem encontrar esse termo.

O curioso é que poucas pessoas conseguiam definir exatamente o que significava.

Na prática, "Open" podia significar qualquer coisa.

UNIX.

POSIX.

TCP/IP.

X/Open.

Padrões.

Interoperabilidade.

Ou simplesmente...

Marketing.

Parecia existir uma regra informal:

Se o produto fosse chamado de "Open", automaticamente ficava moderno.

Enquanto isso...

O IBM já executava protocolos abertos, TCP/IP, UNIX (AIX), SNA, APPC e diversas tecnologias de interoperabilidade, embora raramente recebesse esse crédito.


O medo do "grande computador"

Havia também um componente psicológico.

Mainframes eram enormes.

Caros.

Impressionantes.

Ficavam em salas refrigeradas.

Tinham operadores.

Consoles.

Fitas magnéticas.

Grandes discos.

Para muitos executivos, aquilo parecia representar uma tecnologia "do passado".

Os servidores menores transmitiam outra sensação.

Modernidade.

Agilidade.

Liberdade.

Só havia um problema.

A física não liga para marketing.

Nem a teoria das filas.

Nem a consistência transacional.

Nem o CAPEX.

Nem o OPEX.

Nem a Lei de Amdahl.


O nascimento da guerra comercial

Pouca gente comenta isso.

Mas boa parte daquela narrativa foi impulsionada por uma disputa extremamente agressiva entre fabricantes.

IBM.

DEC.

Sun Microsystems.

HP.

Compaq.

Silicon Graphics.

Data General.

Tandem.

Se uma empresa conseguisse convencer o mercado de que o mainframe estava morrendo...

Automaticamente venderia mais servidores.

Não havia nada de ilegal nisso.

Era competição.

Mas muitas análises técnicas começaram a misturar engenharia com marketing.

E essa mistura quase nunca produz boas previsões.


A guerra das arquiteturas

Outro grande "vilão" da época era o processador CISC.

Segundo muitos especialistas, o futuro pertencia aos processadores RISC.

As apresentações eram quase sempre iguais.

RISC era simples.

Elegante.

Rápido.

CISC era complexo.

Antigo.

Lento.

O detalhe curioso?

Enquanto essa discussão acontecia, os engenheiros da IBM continuavam evoluindo silenciosamente sua arquitetura, introduzindo novas gerações de processadores, cache, canais de I/O e mecanismos sofisticados de paralelismo.

No mundo real...

O cliente queria saber apenas uma coisa.

"Meu banco continua funcionando?"


Quando o PowerPoint venceu a engenharia

Existe uma piada antiga entre arquitetos.

"Quanto mais bonito o slide, maior a chance de esconder um benchmark incompleto."

Nos anos 90 isso acontecia frequentemente.

Os gráficos mostravam:

⬆️ Crescimento dos PCs.

⬆️ Crescimento das LANs.

⬆️ Crescimento do UNIX.

⬇️ Queda do preço dos servidores.

E então aparecia a conclusão inevitável:

"O mainframe acabou."

Só que os gráficos raramente mostravam:

  • disponibilidade;

  • MTBF;

  • MTTR;

  • throughput;

  • custo operacional ao longo de dez anos;

  • consistência transacional;

  • segurança;

  • auditoria;

  • produtividade por administrador;

  • custo de migração.

Era como comparar um caminhão com uma motocicleta apenas pelo preço de compra.


O Padawan COBOL observa tudo isso...

Imagine nosso Padawan viajando no tempo.

Ele entra em uma feira de tecnologia de 1993.

Escuta uma palestra.

"COBOL acabou."

Ele sorri.

Passa em outro estande.

"CICS morreu."

Ele continua andando.

Mais adiante.

"Db2 será substituído."

Ele pega um café.

Mais um corredor.

"O futuro é sem mainframe."

Ele olha discretamente para o relógio.

Naquele exato momento...

Milhões de cartões de crédito estão sendo autorizados.

Bilhões de dólares estão sendo transferidos.

Companhias aéreas continuam emitindo passagens.

Governos processam impostos.

Seguradoras calculam riscos.

Tudo em plataformas que, segundo os palestrantes, já deveriam estar mortas.

Nosso Padawan apenas pensa:

"Esse defunto trabalha bastante..."


Buzzwords envelhecem. Engenharia permanece.

Existe uma diferença fundamental entre uma moda e uma arquitetura.

A moda vende expectativa.

A arquitetura entrega resultado.

Durante mais de cinquenta anos, dezenas de buzzwords apareceram prometendo substituir completamente o mainframe.

Algumas realmente trouxeram avanços importantes.

Outras desapareceram tão rapidamente quanto surgiram.

A computação distribuída venceu?

Sim.

Cloud existe?

Claro.

Containers revolucionaram o desenvolvimento?

Sem dúvida.

Mas nenhuma dessas tecnologias eliminou automaticamente a necessidade de plataformas transacionais altamente confiáveis.

Elas passaram a coexistir.

E o IBM Z evoluiu para integrar-se a esse novo ecossistema.


A primeira lição para um Padawan COBOL

Quando você ouvir alguém afirmar que uma tecnologia "vai morrer em dois anos", faça três perguntas simples:

  1. Quem está dizendo isso?

  2. Quem ganha dinheiro se isso acontecer?

  3. Os maiores bancos do mundo concordam?

Se a terceira resposta for "não"...

Talvez seja apenas mais uma buzzword.


O verdadeiro inimigo nunca foi o mainframe

O maior erro da década de 1990 não foi apostar em novas arquiteturas.

Elas eram necessárias e transformaram a indústria.

O erro foi acreditar que inovação exige destruição completa do que veio antes.

A história mostrou exatamente o contrário.

Os sistemas corporativos evoluíram por integração, não por substituição.

O IBM Z incorporou Linux, Java, APIs REST, OpenShift, DevOps, Zowe, watsonx, IA embarcada, COBOL moderno, Db2 13 e CICS TS, enquanto as arquiteturas distribuídas amadureceram ao seu redor.

O resultado não foi a vitória de um lado sobre o outro.

Foi um ecossistema híbrido, onde cada tecnologia ocupa o espaço em que entrega mais valor.

E talvez essa seja a maior ironia da década dos buzzwords:

Enquanto muitos gastavam energia tentando enterrar o mainframe, os engenheiros da IBM estavam ocupados fazendo algo muito menos chamativo...

Preparando a próxima geração.

Bellacosa Mainframe e a serie Funeral que nunca aconteceu


C:\BELLACOSA\COBOL\FUNERAL_QUE_NUNCA_ACONTECEU.HTML
★ BELLACOSA MAINFRAME APRESENTA ★

A MORTE DO COBOL

O Funeral que Nunca Aconteceu

Uma investigação histórica em 14 capítulos sobre as previsões, reportagens, buzzwords e profetas que anunciaram repetidamente o fim do COBOL — enquanto bilhões de transações continuavam sendo processadas silenciosamente.

SISTEMA ONLINE — 14 CAPÍTULOS DISPONÍVEIS
DIRETÓRIO DE CAPÍTULOS

README.TXT

Esta série investiga uma das narrativas mais repetidas da história da tecnologia: a suposta morte do COBOL. Durante décadas, revistas, jornais, consultorias e especialistas anunciaram seu desaparecimento. Entretanto, o COBOL permaneceu processando bancos, seguradoras, governos, cartões, pagamentos e sistemas críticos.

Os títulos e links acima são elementos HTML reais, permitindo que mecanismos de busca encontrem e rastreiem todos os capítulos. Os iframes funcionam apenas como previews visuais.

C:\> RUN BELLACOSA.EXE /COBOL /HISTORY /NO-FUNERAL _

★ BELLACOSA MAINFRAME ★ COBOL ★ IBM Z ★ HISTÓRIA DA COMPUTAÇÃO ★

Melhor visualizado em qualquer navegador com café disponível.

 


As 16 Recomendações da IBM que Todo Programador COBOL Padawan Deveria Conhecer

 

Bellacosa Mainframe e 16 recomendacoes Jedi para seu programa COBOL século XXI

☕ Um Café no Bellacosa Mainframe

As 16 Recomendações da IBM que Todo Programador COBOL Padawan Deveria Conhecer

Da Era dos Cartões Perfurados ao IBM Z Moderno: Como Escrever COBOL Preparado para os Próximos 30 Anos

"A maior diferença entre um Programador COBOL Júnior e um Arquiteto Mainframe não está em quantos comandos ele conhece, mas em entender por que a linguagem evoluiu."

Existe uma frase muito comum entre desenvolvedores iniciantes:

"Sempre fizemos assim."

Ela parece inofensiva.

Mas, no mundo Mainframe, ela pode esconder décadas de dívida técnica.

Muitos sistemas COBOL que ainda executam hoje foram escritos quando:

  • o IBM System/360 ainda era novidade;

  • cartões perfurados eram utilizados;

  • memória era medida em kilobytes;

  • não existia Internet;

  • não existia Java;

  • não existia JSON;

  • ninguém imaginava APIs REST.

Mesmo assim, esses sistemas continuam processando bilhões de dólares diariamente.

Então surge uma pergunta inevitável:

Se eles funcionam tão bem, por que a IBM continua evoluindo o COBOL?

A resposta é simples.

Porque o mundo mudou.

O hardware mudou.

Os processadores IBM Z mudaram.

O Language Environment (LE) mudou.

As aplicações passaram a conversar com Java, Python, Node.js, microsserviços, OpenShift, APIs REST e serviços em nuvem.

O COBOL também precisou evoluir.

E é exatamente isso que veremos neste café.


A filosofia da IBM

Existe um detalhe curioso.

A IBM raramente muda uma linguagem apenas porque existe uma novidade tecnológica.

Ela muda quando existe ganho real.

Os princípios normalmente são:

  • mais segurança

  • mais desempenho

  • menos CPU

  • menos manutenção

  • melhor integração

  • melhor diagnóstico

  • maior reutilização

Sempre que surgir uma recomendação da IBM, pergunte:

"Qual problema essa mudança resolveu?"

Essa pergunta transforma um Padawan em um profissional que entende arquitetura.


1. STOP RUN → GOBACK

Provavelmente a recomendação mais conhecida.

Durante décadas escrevíamos:

STOP RUN.

Hoje, novos projetos costumam utilizar:

GOBACK.

Por quê?

Imagine um restaurante.

Você pede um café.

O garçom leva até sua mesa.

Quando termina de beber, o correto é devolver a xícara ao garçom.

Não faz sentido fechar o restaurante inteiro.

Foi exatamente isso que aconteceu com o COBOL.

Nos anos 60 o programa era praticamente o dono da execução.

Hoje ele normalmente é apenas um componente.

Pode ser chamado por:

  • outro COBOL

  • CICS

  • IMS

  • Java

  • API REST

  • MQ

  • z/OS Connect

Se um módulo chamado executar STOP RUN...

Toda a Run Unit termina.

Com GOBACK...

O controle simplesmente retorna ao chamador.

Dica Bellacosa

Sempre imagine:

"Meu programa está prestando um serviço."

Quem chamou deve decidir quando terminar a aplicação.


2. NUMCHECK

Todo programador já viu um S0C7.

Normalmente ele aparece na madrugada.

Em produção.

Na sexta-feira.

O motivo quase sempre é simples.

Dados inválidos.

Exemplo:

MOVE "ABC" TO WS-VALOR.
ADD 10 TO WS-VALOR.

Visualmente parece correto.

Na prática...

Explode.

NUMCHECK faz o compilador inserir verificações para identificar esse tipo de problema antes que ele vire um incidente.

Curiosidade

Muitos S0C7 não nascem onde ocorrem.

O dado inválido pode ter sido gravado horas antes por outro programa.


3. SSRANGE

Imagine um armário com 100 gavetas.

Você tenta abrir a gaveta 101.

Ela simplesmente não existe.

Sem SSRANGE...

Seu programa pode acessar memória indevida.

Com SSRANGE...

O erro é detectado imediatamente.

Exemplo:

01 TABELA.
   05 ITEM OCCURS 100 TIMES.

MOVE "X" TO ITEM(101).

Esse erro pode permanecer escondido durante anos.

Até que um dia...

Produção.


Curiosidade

Grande parte dos erros difíceis de reproduzir está relacionada ao acesso indevido de memória.

SSRANGE ajuda justamente nisso.


4. TEST

Quantos DISPLAY você já encontrou em produção?

DISPLAY "CHEGUEI AQUI".

DISPLAY SQLCODE.

DISPLAY WS-CLIENTE.

Eles ajudam?

Sim.

Mas apenas temporariamente.

Hoje existem ferramentas de Debug muito mais completas.

Com TEST, o programa pode ser analisado sem transformar o código em uma árvore de DISPLAY.


5. Unicode

Durante décadas tudo era EBCDIC.

Hoje recebemos:

  • JSON

  • XML

  • APIs

  • Web

  • Smartphones

  • Emojis

  • Idiomas internacionais

O COBOL moderno suporta Unicode.

Isso significa muito mais integração.

Imagine um banco atendendo clientes no Japão, Brasil e Alemanha.

Tudo utilizando a mesma aplicação.


Curiosidade

Muitos desenvolvedores COBOL nunca perceberam que o Enterprise COBOL moderno possui excelente suporte a Unicode.


6. JSON PARSE

Há alguns anos montar JSON significava algo parecido com isto:

STRING "{"

...

"}"

Muito código.

Muito risco.

Muito difícil de manter.

Hoje basta utilizar:

JSON GENERATE.

Ou

JSON PARSE.

O compilador faz praticamente todo o trabalho.


Isso muda completamente a modernização

Imagine integrar COBOL com:

  • React

  • Angular

  • Flutter

  • Java

  • Python

JSON virou a linguagem universal.


7. XML PARSE

O mesmo aconteceu com XML.

Antes era comum utilizar:

UNSTRING.

INSPECT.

STRING.

Hoje o compilador entende XML nativamente.

Menos código.

Menos bugs.

Mais produtividade.


8. RENT

Talvez uma das opções menos conhecidas pelos iniciantes.

RENT significa:

Reentrant.

Ou seja...

O programa pode ser executado simultaneamente por diversos usuários.

Imagine um banco.

Cinco mil clientes consultando saldo.

O mesmo programa atende todos.

Isso só funciona porque ele foi escrito corretamente.


Dica

Sempre evite gravar informações temporárias em áreas compartilhadas.


9. DYNAM

No passado quase tudo era ligado durante o Link-Edit.

Hoje queremos mais flexibilidade.

CALL dinâmico permite substituir módulos sem reconstruir toda a aplicação.

É um grande aliado em ambientes modernos.


10. EVALUATE

Existe um momento na vida de todo Padawan em que ele escreve isto:

IF
ELSE
IF
ELSE
IF
ELSE

Depois de alguns meses...

Nem ele entende mais.

EVALUATE resolve exatamente isso.

Exemplo:

EVALUATE WS-TIPO

WHEN 1

WHEN 2

WHEN 3

WHEN OTHER

END-EVALUATE

Muito mais limpo.


11. END-IF

Antigamente muitos programas dependiam de ponto final e NEXT SENTENCE.

Isso gerava ambiguidades.

Hoje escrevemos:

IF ...

END-IF

O compilador entende exatamente onde cada bloco termina.


12. Intrinsic Functions

Durante muitos anos criávamos rotinas para tudo.

Hoje o compilador já oferece dezenas de funções.

Exemplos:

FUNCTION CURRENT-DATE

FUNCTION LENGTH

FUNCTION TRIM

FUNCTION LOWER-CASE

FUNCTION UPPER-CASE

Além de deixar o código mais elegante, elas costumam ser mais eficientes.


13. Evitar ALTER

ALTER era considerado brilhante.

Na década de 70.

Hoje virou pesadelo.

Ele altera dinamicamente o fluxo do programa.

Resultado:

  • difícil de entender;

  • difícil de depurar;

  • difícil de otimizar.

Por isso praticamente desapareceu dos novos projetos.


14. Reduzir GO TO

Existe um mito.

GO TO não é proibido.

Mas o excesso dele transforma um programa em um labirinto.

Imagine tentar seguir uma história cuja página seguinte muda aleatoriamente.

É exatamente essa sensação.

PERFORM e EVALUATE tornam o fluxo muito mais claro.


15. Migrar para Enterprise COBOL 6.x

Essa talvez seja a maior evolução dos últimos anos.

O compilador moderno entende muito melhor os processadores IBM Z atuais.

Isso significa:

  • menos CPU;

  • otimizações automáticas;

  • melhores diagnósticos;

  • suporte ampliado a JSON e XML;

  • novas funções intrínsecas.

Em muitos casos, apenas recompilar um programa com ajustes adequados já produz ganhos perceptíveis de desempenho.


16. Pensar em Integração

Esta talvez seja a maior mudança cultural.

Antes escrevíamos programas Batch.

Hoje escrevemos serviços corporativos.

Um programa COBOL pode atender:

  • Mobile Banking

  • Internet Banking

  • PIX

  • APIs REST

  • Java

  • Python

  • Node.js

  • OpenShift

  • Mensageria MQ

O código precisa nascer preparado para esse mundo.


O impacto nos programas antigos

A boa notícia é que a IBM sempre valorizou compatibilidade. Muitos programas escritos há décadas ainda compilam e executam nas versões atuais do Enterprise COBOL.

Isso, porém, não significa que estejam aproveitando os recursos modernos.

É comum encontrar aplicações com:

  • STOP RUN em todos os módulos;

  • dezenas de GO TO;

  • ALTER;

  • manipulação manual de XML e JSON;

  • ausência de verificações de dados;

  • poucas opções de diagnóstico.

Esses programas continuam funcionando, mas tendem a ser mais difíceis de manter, testar e integrar.

Modernizar não significa reescrever tudo. Em muitos casos, basta evoluir gradualmente: substituir comandos antigos, ativar opções do compilador, introduzir funções intrínsecas e organizar melhor o código.


A evolução de um Programador COBOL

Todo desenvolvedor passa por etapas.

Padawan

Aprende a sintaxe.

Consegue compilar.

Resolve problemas.

Programador

Começa a reutilizar código.

Escreve módulos.

Documenta interfaces.

Desenvolvedor Sênior

Pensa em desempenho.

CPU.

Memória.

Escalabilidade.

Arquiteto

Pensa no sistema inteiro.

Integração.

Disponibilidade.

Evolução.

Governança.

Perceba que, à medida que você cresce, a linguagem deixa de ser o foco principal. O importante passa a ser a qualidade das decisões.


O Mainframe moderno

Existe um mito antigo de que o Mainframe "parou no tempo".

Nada poderia estar mais distante da realidade.

Hoje um IBM Z pode:

  • expor APIs REST;

  • consumir serviços externos;

  • executar aplicações Java;

  • trabalhar com contêineres;

  • integrar-se ao OpenShift;

  • processar JSON e XML;

  • utilizar DevOps, Git e pipelines CI/CD;

  • compartilhar dados em tempo real com aplicações distribuídas.

O COBOL moderno acompanha essa evolução. As recomendações da IBM existem justamente para que o código continue relevante nesse novo cenário.


Conclusão

Existe uma frase que resume toda essa evolução:

"O melhor código não é aquele que apenas funciona hoje; é aquele que continuará funcionando, sendo compreendido e evoluído daqui a vinte anos."

As recomendações da IBM não representam uma ruptura com o passado. Elas representam a continuidade de uma filosofia que sempre guiou o Mainframe: estabilidade, desempenho, confiabilidade e evolução gradual.

Trocar STOP RUN por GOBACK, utilizar NUMCHECK, adotar SSRANGE nos testes, explorar JSON PARSE, JSON GENERATE, XML PARSE, RENT, funções intrínsecas e estruturas mais legíveis não é seguir uma moda. É escrever código preparado para um ambiente onde COBOL conversa diariamente com APIs, microsserviços, aplicações móveis e plataformas em nuvem.

Como Programador COBOL Padawan, seu objetivo não deve ser apenas aprender comandos. Deve ser entender por que eles existem, quando utilizá-los e como eles ajudam a construir sistemas capazes de sobreviver por décadas.

No Bellacosa Mainframe, costumamos dizer que a verdadeira modernização não começa com uma nova tecnologia. Ela começa quando o desenvolvedor muda sua forma de pensar. O compilador evolui, o hardware evolui, o IBM Z evolui — e o profissional que acompanha essa jornada deixa de apenas escrever programas para construir soluções que atravessam gerações.


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

 

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


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

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

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

Vamos analisar como um arquiteto de Mainframe faria.


A origem do STOP RUN

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

O fluxo era simples:

JCL
 │
 ▼
Programa COBOL
 │
STOP RUN
 │
 ▼
MVS

Naquela época:

  • não existiam APIs REST;

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

  • praticamente não existiam subprogramas complexos;

  • o programa começava e terminava.

O STOP RUN fazia exatamente isso:

"Acabei. Pode encerrar tudo."


O surgimento do GOBACK

Com o crescimento dos sistemas apareceram:

  • subprogramas

  • bibliotecas

  • módulos reutilizáveis

  • CICS

  • IMS

  • DB2

  • Language Environment (LE)

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

Exemplo:

JCL

  MAIN01

     │

 CALL CLIENTE

     │

 CALL CALCJURO

     │

 CALL VALIDA

Imagine se CALCJURO executasse:

STOP RUN

O que aconteceria?

Toda a aplicação terminaria imediatamente.

Não apenas o módulo.

Todo o Run Unit.

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


A grande diferença

STOP RUN

Programa

↓

encerra TODA a Run Unit

↓

retorna ao sistema operacional

GOBACK

Programa

↓

retorna para quem chamou

↓

continua a execução

Se o programa for o principal:

GOBACK

↓

faz praticamente o mesmo trabalho do STOP RUN

A IBM afirma isso explicitamente:

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


Exemplo prático

Programa principal

MAIN
CALL "A"

DISPLAY "FIM"

STOP RUN

Programa A

DISPLAY "A"

STOP RUN

Resultado

A

O DISPLAY "FIM"

nunca acontece.


Agora usando GOBACK

Programa A

DISPLAY "A"

GOBACK

Resultado

A

FIM

Porque voltou para o MAIN.


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

Não porque ele esteja errado.

Mas porque ele cria risco.

Imagine um programa hoje.

Batch

↓

Framework

↓

Biblioteca

↓

Serviço

↓

Seu Programa

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

Se usar

STOP RUN

você encerra toda a aplicação.

Se usar

GOBACK

o programa simplesmente devolve o controle.

Muito mais seguro.


O princípio da reutilização

Hoje escrevemos programas para serem reutilizados.

Um módulo pode ser chamado por:

  • Batch

  • CICS

  • IMS

  • API REST

  • MQ

  • Java

  • z/OS Connect

  • outro COBOL

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

Ele apenas faz seu trabalho.

Depois devolve o controle.

Isso é exatamente o comportamento do GOBACK.


O impacto no Language Environment (LE)

Aqui está uma das razões mais importantes.

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

O LE controla:

  • memória

  • pilha

  • heap

  • tratamento de exceções

  • inicialização

  • reutilização do runtime

Quando ocorre

STOP RUN

o LE encerra o Run Unit.

Quando ocorre

GOBACK

ele apenas retorna ao chamador.

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


O caso do RTEREUS

Pouca gente conhece essa opção.

Existe um parâmetro do LE chamado

RTEREUS

(Runtime Reuse)

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

A IBM afirma claramente:

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

Ou seja:

STOP RUN

↓

destrói o ambiente

↓

novo ambiente precisa ser criado

Enquanto

GOBACK

↓

reutiliza o ambiente

↓

menos overhead

Performance

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

Mas imagine milhares de execuções por minuto.

1000 programas

↓

cada um recria o Runtime

↓

mais CPU

Com reutilização:

Runtime permanece ativo

↓

menos inicialização

↓

menos CPU

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


E no CICS?

No CICS normalmente termina-se com

EXEC CICS RETURN

e não com

STOP RUN

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

O mesmo raciocínio vale para IMS.

O programa devolve o controle ao ambiente.

Não encerra a Run Unit.


Um exemplo interessante: DFSORT

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

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

Ou seja,

STOP RUN

↓

encerra tudo

↓

ERRADO
GOBACK

↓

retorna ao DFSORT

↓

CORRETO

Existe recomendação oficial da IBM?

Sim.

A documentação oficial afirma que:

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

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

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

Documentação oficial da IBM:

Minha recomendação para um COBOL Padawan

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

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

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

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