Translate

quarta-feira, 29 de julho de 2026

O Portal Stargate do IBM Z : Descobre que Git, DevOps e CI/CD Não São Tecnologias Alienígenas.

 

Bellacosa Mainframe e o portal stargata para adentrar no novo mundo do desenvolvimento mainframe

☕ Um Café no Bellacosa Mainframe

O Portal Stargate do IBM Z

Quando um Programador COBOL Descobre que Git, DevOps e CI/CD Não São Tecnologias Alienígenas... São os Endereços para Viajar Entre Galáxias de Software

"Há milhares de anos, os Antigos construíram uma rede capaz de conectar mundos instantaneamente. No século XXI, engenheiros criaram outra rede capaz de conectar milhares de aplicações corporativas espalhadas pelo planeta. Seu nome não é Stargate... é Pipeline DevOps."



Prólogo — O Chevron Número Sete

O relógio marcava 03:27 da madrugada.

No Centro de Processamento de Dados, apenas o z16 permanecia acordado.

Milhões de transações cruzavam seus canais FICON.

Cartões eram autorizados.

PIX eram liquidados.

Voos eram confirmados.

Hospitais consultavam prontuários.

Bolsa de valores processava ordens.

E, em algum lugar daquele universo invisível, um jovem programador COBOL fazia sua primeira alteração em um COPYBOOK.

Ele acreditava que bastava alterar o código.

Mas o veterano apenas sorriu.

— Você ainda acha que um programa vive sozinho...

Naquele instante, uma enorme estrutura metálica começou a girar.

Não era um Stargate.

Era uma Pipeline.

Os chevrons começaram a travar.

Git...

DBB...

GitLab...

Jenkins...

ZUnit...

Deployment...

Produção.

O portal foi ativado.

E a verdadeira aventura começou.



Episódio 1 — O IBM Z é um Planeta

Em Stargate SG-1, cada planeta possui sua própria civilização.

No mundo IBM Z acontece exatamente o mesmo.

Cada ambiente é praticamente um planeta independente.

Desenvolvimento

↓

Integração

↓

Homologação

↓

Pré-Produção

↓

Produção

Cada um possui:

  • regras

  • segurança

  • bases de dados

  • usuários

  • aplicações

  • auditoria

  • monitoramento

Mover software entre esses mundos nunca foi simples.

Durante décadas isso era feito manualmente.

Hoje quem controla os portais é o DevOps.



Episódio 2 — O DHD Chama-se Git

Em Stargate existe um equipamento chamado DHD (Dial Home Device).

Ele controla o portal.

Sem ele, ninguém viaja.

No desenvolvimento moderno existe um equivalente.

Seu nome é Git.

Muitos iniciantes pensam que Git serve apenas para "guardar arquivos".

Isso seria como dizer que o DHD serve apenas para acender luzes.

Git controla praticamente toda a história da aplicação.

Ele registra:

  • quem alterou

  • quando alterou

  • por que alterou

  • quem aprovou

  • qual versão entrou em produção

  • qual versão voltou (rollback)

Cada commit representa um novo endereço gravado na memória do portal.


Curiosidade Bellacosa ☕

Em projetos antigos, a "verdade absoluta" era um PDS ou um Endevor.

Hoje, em arquiteturas modernas, a verdade oficial normalmente reside no repositório Git. Os datasets do z/OS continuam essenciais para compilação e execução, mas o histórico e a colaboração passam a ser organizados pelo controle de versão.


Episódio 3 — A Linguagem dos Antigos

Existe um problema que todo iniciante descobre cedo ou tarde.

Mainframe fala EBCDIC.

O restante do planeta fala ASCII ou UTF-8.

Imagine Daniel Jackson tentando traduzir uma inscrição dos Antigos.

Se errar um símbolo...

Toda a tradução muda.

O mesmo acontece durante uma migração para Git.

Sem conversão correta podemos encontrar situações como:

Antes

AÇÃO

Depois

AÇÃO

Parece pequeno.

Na prática pode causar:

  • conflitos de merge

  • comentários ilegíveis

  • documentação perdida

  • comparações falsas

  • arquivos inutilizados

Por isso existe toda uma estratégia de conversão de code pages.

É um dos assuntos mais importantes do curso.


Episódio 4 — O SGC Chama-se GitLab

No universo Stargate existe o Stargate Command.

É dali que todas as missões são coordenadas.

No DevOps existe um equivalente.

GitLab.

Ele não é apenas um servidor Git.

Ele funciona como uma base operacional.

Ali encontramos:

  • Issues

  • Merge Requests

  • Pipelines

  • Releases

  • Segurança

  • Artefatos

  • Auditoria

Quando um desenvolvedor envia um commit...

É como uma equipe SG retornando de uma missão.

Tudo será analisado.


Episódio 5 — O Iris é a Pipeline

No Stargate existe um Iris.

Ele impede que qualquer coisa atravesse o portal sem autorização.

No DevOps existe um Iris muito parecido.

A Pipeline.

Ela verifica automaticamente:

✔ O código compila?

✔ Os testes passaram?

✔ Existe vulnerabilidade?

✔ O padrão foi respeitado?

✔ Há aprovação?

Se alguma resposta for negativa...

O portal permanece fechado.

Nenhum software chega à produção.


Episódio 6 — Os Asgard Chamam-se DBB

Os Asgard eram extremamente inteligentes.

Criavam tecnologia capaz de resolver problemas gigantescos.

O DBB (Dependency Based Build) faz algo semelhante.

Imagine um banco com:

  • 18.000 programas COBOL

  • 6.000 COPYBOOKS

  • centenas de mapas BMS

  • milhares de JCLs

Você altera apenas um COPYBOOK.

A pergunta é inevitável.

Quem precisa ser recompilado?

Todos?

Claro que não.

O DBB investiga as dependências.

Ele descobre:

Programa A

↓

COPY X

↓

Programa B

↓

Programa C

↓

Programa D

Somente quem realmente depende daquela alteração será recompilado.

Isso economiza:

  • CPU

  • MIPS

  • tempo

  • dinheiro


Easter Egg ☕

Assim como os Asgard dominavam conhecimento acumulado durante milênios, o DBB concentra décadas de experiência em engenharia de build para IBM Z. O verdadeiro "superpoder" não é compilar mais rápido, mas evitar compilar o que não mudou.


Episódio 7 — Thor Apresenta o zAppBuild

O DBB precisa de alguém dizendo como construir a aplicação.

Esse papel pertence ao zAppBuild.

Ele funciona como um roteiro.

Compile

↓

Link

↓

Bind Db2

↓

Package

↓

Deploy

Sem improviso.

Sem dezenas de JCL diferentes.

Tudo padronizado.


Episódio 8 — O Antigo Conhecimento Perdido

Imagine encontrar um programa COBOL criado em 1987.

Ninguém sabe:

  • quem chama

  • quem utiliza

  • quais tabelas acessa

  • quais COPYBOOKS dependem dele

É exatamente aí que entra o ADDI.

Application Discovery and Delivery Intelligence.

Ele funciona como Daniel Jackson.

Escava.

Relaciona.

Traduz.

Reconstrói.

Mostra mapas gigantescos das dependências.

Você finalmente entende uma aplicação criada há quarenta anos.


Episódio 9 — A Equipe SG-1 Chama-se Jenkins

Em Stargate cada missão possui uma equipe.

No DevOps quem coordena diversas missões pode ser o Jenkins.

Ele recebe a ordem.

Executa.

Compila.

Chama scripts.

Executa testes.

Publica resultados.

Tudo automaticamente.

Em muitos ambientes ele trabalha lado a lado com GitLab, Azure DevOps ou outras plataformas de automação.



Episódio 10 — Outros Mundos: Azure e Wazi

O IBM Z já não vive isolado.

Hoje conversa naturalmente com:

  • Azure

  • OpenShift

  • Kubernetes

  • GitHub

  • GitLab

  • APIs REST

  • microsserviços

O Wazi as a Service demonstra exatamente isso.

Você pode desenvolver aplicações IBM Z utilizando ferramentas modernas hospedadas em nuvem.

É como atravessar o Stargate para outro planeta...

Sem abandonar seu idioma.


Episódio 11 — O Campo de Treinamento Tok'ra

Uma civilização não evolui sem treinamento.

Durante muito tempo acreditava-se que COBOL não fazia testes unitários.

Isso mudou.

Com o ZUnit podemos automatizar testes de programas COBOL.

Imagine uma alteração aparentemente simples.

Antes:

Alterar

↓

Compilar

↓

Mandar para homologação

Hoje:

Commit

↓

Build

↓

ZUnit

↓

Resultado

↓

Deploy

Se algum teste falhar...

A missão é cancelada.


Dica do Coronel O'Neill

"Confiar apenas porque compilou é como atravessar um Stargate sem verificar o planeta de destino."

Teste sempre.


Episódio 12 — O Conselho dos Antigos

Chega o momento do Deployment.

Aqui muitos iniciantes imaginam que basta copiar datasets.

Não.

Deployment moderno envolve:

  • empacotamento

  • aprovação

  • auditoria

  • versionamento

  • rollback

  • rastreabilidade

Cada release recebe identidade própria.

Nada entra em produção sem deixar um rastro.


Episódio 13 — As Coordenadas Galácticas (Branches)

Em Stargate cada planeta possui um endereço formado por chevrons.

No Git acontece algo parecido.

Cada branch representa um caminho de desenvolvimento.

main

├── develop

├── release

├── feature

└── hotfix

Cada uma possui finalidade específica.

Misturar tudo seria como discar símbolos aleatórios no Stargate.

Você provavelmente chegaria ao planeta errado.


Episódio 14 — A Cidade Perdida dos Antigos

Muitas empresas possuem aplicações criadas nos anos 1970.

Décadas de evolução.

Milhões de linhas COBOL.

Esses sistemas lembram Atlantis.

Imensos.

Poderosos.

Pouco compreendidos.

Ferramentas como o ADDI ajudam a revelar sua arquitetura, permitindo que equipes modernas façam mudanças com muito mais segurança.


Episódio 15 — O Oráculo da Performance

No fim da jornada surge outro personagem importante.

O APA (Application Performance Analyzer).

Compilar não basta.

Executar também não.

É preciso executar bem.

O APA mostra:

  • consumo de CPU

  • hotspots

  • chamadas excessivas

  • gargalos

  • desperdícios

É como um sensor Asgard analisando cada detalhe de uma nave antes da decolagem.



A Grande Missão DevOps

Quando unimos todas as tecnologias do curso, obtemos uma cadeia contínua de entrega de software:

Programador COBOL
        │
        ▼
 VS Code / IDz
        │
        ▼
      Git
        │
        ▼
 Merge Request
        │
        ▼
 GitLab / Jenkins
        │
        ▼
 DBB + zAppBuild
        │
        ▼
     Build
        │
        ▼
     ZUnit
        │
        ▼
      ADDI
        │
        ▼
  Empacotamento
        │
        ▼
 Deploy Automatizado
        │
        ▼
   CICS • Batch • Db2 • IMS
        │
        ▼
 APA • Monitoramento

Observe como praticamente tudo ocorre de maneira automática. O desenvolvedor continua sendo indispensável, mas passa a dedicar mais tempo ao desenho da solução e menos às tarefas repetitivas.


Passo a Passo para o Iniciante

Se você está começando agora no mundo IBM Z, esta é uma sequência de estudos que faz muito sentido:

  1. Aprenda bem COBOL, JCL, TSO/ISPF e os fundamentos do z/OS.

  2. Entenda VSAM, Db2, CICS e como uma aplicação corporativa é estruturada.

  3. Estude Git profundamente: commits, branches, merge, rebase e revisão de código.

  4. Aprenda conceitos de CI/CD antes de decorar ferramentas específicas.

  5. Conheça DBB e zAppBuild para compreender como builds modernos funcionam.

  6. Estude ZUnit e incorpore testes automatizados desde cedo.

  7. Explore o ADDI para entender impacto de mudanças em aplicações legadas.

  8. Aprenda uma plataforma de orquestração, como GitLab ou Jenkins.

  9. Entenda estratégias de deployment, rollback e versionamento.

  10. Finalmente, aprofunde-se em performance, observabilidade e engenharia de plataformas.

Essa sequência faz com que cada etapa tenha um propósito claro e evita a sensação de aprender tecnologias desconectadas.


Curiosidades que Pouca Gente Conhece

  • O maior desafio de uma pipeline IBM Z normalmente não é compilar COBOL, mas entender corretamente as dependências entre milhares de componentes.

  • Muitos bancos executam centenas ou milhares de pipelines diariamente sem que clientes percebam que há mudanças em produção.

  • Um único COPYBOOK compartilhado pode impactar centenas de programas diferentes.

  • Ferramentas de descoberta de aplicações, como o ADDI, ajudam equipes que nunca participaram do desenvolvimento original a compreender sistemas com décadas de evolução.

  • O movimento Open Mainframe Project acelerou a integração entre tecnologias abertas e o ecossistema IBM Z, aproximando práticas modernas de engenharia de software do ambiente corporativo tradicional.


Conclusão — O Oitavo Chevron

No último episódio de muitas temporadas de Stargate, descobrimos que o verdadeiro objetivo nunca foi apenas atravessar portais.

Era compreender uma rede inteira de civilizações.

O mesmo acontece com o IBM Z.

O programador iniciante costuma acreditar que aprender COBOL é suficiente.

Depois percebe que existe Db2.

Em seguida descobre CICS.

Depois VSAM.

Mais tarde encontra Git.

Pipeline.

DBB.

GitLab.

Jenkins.

ZUnit.

ADDI.

Deployment.

Performance.

Observabilidade.

Cada tecnologia parece um novo planeta.

Mas, pouco a pouco, surge uma revelação: todas fazem parte de uma única galáxia.

O verdadeiro arquiteto não conhece apenas uma linguagem de programação. Ele entende como cada componente conversa com os demais, como uma alteração percorre toda a cadeia de entrega e como manter sistemas que processam bilhões de transações com segurança e previsibilidade.

No fim, o maior portal nunca foi o Stargate.

Foi a mudança de mentalidade.

Quando você deixa de enxergar um simples programa COBOL e passa a visualizar todo o ecossistema que o cerca, o oitavo chevron finalmente trava... e uma nova galáxia de oportunidades se abre diante de você.

Easter Egg Bellacosa: se um dia você ouvir um veterano dizer "o programa compilou, mas a pipeline não deixou passar", lembre-se do Iris do Stargate. O código pode estar pronto para atravessar o portal, mas somente aplicações que sobreviverem a todas as verificações chegam ao destino final: a produção do IBM Z.

terça-feira, 28 de julho de 2026

IBM COBOL Elevate for z/OS: CSI Las Vegas no Laboratório do Código Legado

 

Bellacosa Mainframe apresenta o Ibm cobol elevate for zos

☕ Um Café no Bellacosa Mainframe

IBM COBOL Elevate for z/OS: CSI Las Vegas no Laboratório do Código Legado

Quando um Programador COBOL Descobre que o Verdadeiro Crime Não Está no Código Antigo — Está em Executá-lo Durante Décadas sem Investigar Onde a CPU Desaparece

Era madrugada no Data Center de Las Vegas.

As luzes do corredor piscavam sobre os corredores de armazenamento. O ruído constante da refrigeração lembrava o motor de uma aeronave que jamais poderia pousar. Milhões de transações cruzavam o ambiente enquanto quase toda a cidade dormia.

Cartões eram autorizados.

Reservas de hotéis eram confirmadas.

Pagamentos eram processados.

Apólices eram calculadas.

Contas bancárias eram atualizadas.

No centro daquele ecossistema havia um IBM Z executando programas COBOL que talvez tivessem sido escritos antes de alguns integrantes da equipe de desenvolvimento nascerem.

Tudo parecia normal.

Até que o alarme apareceu:

CPU CONSUMPTION ABOVE EXPECTED LEVEL

Gil Grissom aproximou-se do terminal 3270, observou os números e disse:

— A máquina não mente. Mas os números também não confessam sozinhos.

Ao lado dele, um jovem programador COBOL examinava um programa com 14 mil linhas e perguntava:

— Devemos recompilar tudo?

Grissom colocou os óculos, aproximou-se da tela e respondeu:

— Antes de alterar a cena do crime, precisamos descobrir o que realmente aconteceu.

É exatamente nesse ponto que entra o IBM COBOL Elevate for z/OS.

Anunciado pela IBM em 7 de julho de 2026, o produto foi apresentado como uma solução integrada para otimização, modernização, análise de desempenho e aceleração de upgrades de aplicações COBOL críticas. A primeira versão anunciada é o IBM COBOL Elevate for z/OS 1.1, com disponibilidade geral planejada para 18 de setembro de 2026. (IBM)

Mas o que isso realmente significa?

Seria apenas mais uma ferramenta de análise?

Um novo compilador?

Um profiler?

Uma solução de inteligência artificial?

Um produto de migração?

Ou uma tentativa da IBM de criar uma espécie de laboratório forense para investigar milhares de programas COBOL antes de alguém decidir alterá-los?

Coloque as luvas.

Isole a área.

Faça uma cópia do load module.

A investigação vai começar.



Capítulo 1 — A vítima não era o COBOL

Durante anos, consultorias, fabricantes e apresentações de modernização repetiram uma narrativa aparentemente irresistível:

“O problema é que o sistema foi escrito em COBOL.”

Essa afirmação soa moderna, mas frequentemente está errada.

O COBOL não é necessariamente o problema.

O verdadeiro problema pode estar em:

  • programas compilados há muitos anos;

  • versões antigas do compilador;

  • opções inadequadas de compilação;

  • módulos que consomem CPU desnecessariamente;

  • dependências que ninguém documentou;

  • chamadas repetitivas;

  • algoritmos inadequados para os volumes atuais;

  • programas recompilados parcialmente;

  • aplicações sem inventário confiável;

  • ausência de dados que mostrem onde vale a pena investir.

Imagine uma aplicação criada em 1996.

Naquele período, ela processava 100 mil registros por noite. Em 2026, executa a mesma lógica sobre 80 milhões de registros.

O código pode estar correto.

O resultado pode estar correto.

O batch pode terminar.

Mas um trecho executado uma única vez em 1996 talvez hoje seja repetido 80 milhões de vezes.

O crime não foi escrever o programa daquela forma.

O crime foi aumentar o volume por trinta anos sem voltar à cena para procurar novas evidências.


Capítulo 2 — A ficha do suspeito

Nome

IBM COBOL Elevate for z/OS

Release inicial anunciado

Versão 1.1

Data do anúncio

7 de julho de 2026

Disponibilidade geral planejada

18 de setembro de 2026

Ambiente principal

Aplicações COBOL executadas no IBM Z sob z/OS.

Missão declarada

Ajudar organizações a modernizar aplicações COBOL críticas por meio de:

  • otimização automatizada de desempenho;

  • aceleração de upgrades de compiladores;

  • análise de inventário e prontidão;

  • assistência por inteligência artificial;

  • informações de desempenho ligadas ao código-fonte;

  • redução do risco operacional;

  • aumento da produtividade das equipes.

A página oficial do produto resume a proposta como uma forma de revitalizar aplicações COBOL, obter ganhos contínuos de performance, acelerar upgrades do compilador e melhorar a qualidade do código, procurando minimizar o risco operacional. (IBM)

Portanto, o Elevate não deve ser entendido apenas como “mais uma ferramenta COBOL”.

Ele é apresentado como uma solução composta por três capacidades complementares:

  1. Accelerate

  2. Upgrade

  3. Performance Insights

Esses três componentes correspondem a três perguntas que assombram qualquer grande ambiente COBOL:

1. O que está consumindo recursos?
2. O que precisa ser atualizado?
3. Onde devemos agir primeiro?

Capítulo 3 — A cena do crime corporativa

Considere um banco fictício chamado Cassino Federal de Las Vegas.

Seu inventário contém:

42.000 programas COBOL
18 milhões de linhas de código
7.500 copybooks
12.000 jobs batch
3.800 transações CICS
2.400 módulos Db2
850 integrações MQ
Programas compilados em diferentes gerações

O diretor pergunta:

— Quanto ganharemos se atualizarmos todos os programas?

Ninguém sabe.

Em seguida, ele pergunta:

— Quais programas devemos recompilar primeiro?

Ninguém sabe.

Depois:

— Quais módulos realmente consomem mais CPU?

A equipe mostra relatórios de SMF, RMF, CICS, Db2, ferramentas de monitoramento e planilhas.

Então surge outra pergunta:

— Qual linha do programa provoca esse consumo?

Silêncio.

Esta é uma dificuldade clássica da engenharia de performance.

Os relatórios operacionais mostram que algo consumiu recursos. Entretanto, transformar a métrica operacional em uma ação concreta sobre o código pode exigir um especialista que entenda simultaneamente:

  • COBOL;

  • compiladores;

  • Language Environment;

  • CICS;

  • Db2;

  • IMS;

  • VSAM;

  • JCL;

  • SMF;

  • comportamento do processador;

  • arquitetura da aplicação;

  • regras de negócio.

Esses profissionais existem, mas são raros.

O IBM COBOL Elevate tenta reduzir essa distância entre o sintoma observado no ambiente e a ação que deve ser tomada no programa.


Capítulo 4 — Primeiro laboratório: Accelerate

O primeiro pilar recebe o nome de Accelerate.

Sua função começa com uma pergunta essencial:

Quais programas realmente precisam de otimização?

Isso parece simples, mas é uma mudança importante.

Em muitas empresas, modernização ainda é tratada como um projeto de massa:

Selecionar milhares de programas
            ↓
Recompilar tudo
            ↓
Executar testes
            ↓
Encontrar incompatibilidades
            ↓
Corrigir
            ↓
Testar novamente
            ↓
Implantar

Esse modelo pode funcionar, mas custa tempo, dinheiro e capacidade de testes.

O Accelerate propõe uma abordagem mais seletiva.

A IBM afirma que a solução realiza uma análise antecipada de performance para identificar os programas COBOL que necessitam de otimização. Depois de uma configuração inicial descrita como simples e realizada uma vez, o produto auxilia no processo de otimização. O anúncio também declara que aplicações identificadas podem ser otimizadas sem alteração do código-fonte, sem recompilação e sem extensas atividades manuais de análise de performance. (IBM)

Essa é provavelmente a afirmação mais provocativa de todo o anúncio.

Como otimizar sem modificar o fonte?

Aqui precisamos separar cuidadosamente fato confirmado de interpretação técnica.

O anúncio confirma o objetivo de otimizar determinados módulos sem modificar o fonte e sem exigir recompilação convencional. Porém, o material público inicial não descreve em detalhes toda a implementação interna utilizada para produzir essa otimização.

Portanto, não devemos inventar que o produto “reescreve o load module”, “aplica patches binários” ou “usa otimização JIT” sem documentação técnica que confirme esses mecanismos.

O que podemos afirmar é:

  • ele analisa previamente o ambiente;

  • identifica candidatos que oferecem potencial de ganho;

  • permite otimizações sem mudanças no fonte;

  • pretende reduzir a necessidade de análise manual extensa;

  • procura diminuir o esforço de testes antes da implantação.

No laboratório do CSI, isso equivale a melhorar a investigação sem obrigar alguém a reconstruir todo o edifício onde o crime ocorreu.

Por que o teste pode ser menor?

Porque existe uma diferença importante entre:

ALTERAR A REGRA DE NEGÓCIO

e:

OTIMIZAR A EXECUÇÃO DA MESMA REGRA

Quando o código-fonte é alterado, a organização precisa provar que:

  • nenhuma condição mudou;

  • nenhum cálculo foi afetado;

  • nenhum campo foi deslocado;

  • nenhum fluxo alternativo deixou de funcionar;

  • nenhum comportamento CICS, Db2 ou IMS foi modificado.

Quando a otimização preserva a lógica e não exige alteração do fonte, a estratégia de validação pode ser mais focada.

Isso não significa “não testar”.

Em sistemas críticos, qualquer mudança deve ser validada.

Significa que o escopo do teste pode potencialmente ser reduzido porque o objetivo não é alterar o comportamento funcional da aplicação.

Exemplo

Considere os seguintes programas:

PGM001 — executado 3 vezes por mês
PGM002 — executado 90 milhões de vezes por dia
PGM003 — consome 0,01 segundo
PGM004 — utiliza 17% da CPU total do batch noturno
PGM005 — será desativado em dois meses

Sem análise, uma empresa poderia tratar todos da mesma forma.

Com uma abordagem orientada por evidências, a prioridade provavelmente seria:

1. PGM004
2. PGM002
3. Investigar os demais somente se necessário

O grande ganho do Elevate pode não estar apenas em “acelerar programas”.

Pode estar em impedir que a equipe desperdice seis meses otimizando programas irrelevantes.


Capítulo 5 — Segundo laboratório: Upgrade

O segundo pilar chama-se Upgrade e trata de um dos projetos mais temidos do mundo COBOL:

atualizar o compilador.

Quem está começando pode imaginar que isso significa apenas trocar o comando de compilação.

Não é tão simples.

Um programa pode conter:

  • sintaxe antiga;

  • opções de compilação herdadas;

  • comportamentos dependentes de versões anteriores;

  • estruturas de dados mal definidas;

  • redefinições perigosas;

  • dependências com copybooks;

  • chamadas estáticas ou dinâmicas;

  • interfaces CICS;

  • SQL embutido;

  • acessos IMS;

  • bibliotecas específicas;

  • programas chamados por dezenas de outros módulos.

Por isso, atualizar um compilador não é apenas um problema tecnológico.

É também um problema de inventário.

A pergunta que ninguém deseja ouvir

— Quantos programas ainda foram compilados com versões antigas?

Em muitos ambientes, a resposta é:

— Estamos levantando.

Depois de três meses:

— Ainda estamos levantando.

Depois de seis meses:

— Encontramos outra biblioteca.

O Upgrade do COBOL Elevate foi projetado para ajudar a acelerar a adoção de níveis suportados do Enterprise COBOL. Para isso, a IBM apresenta recursos de inventário automatizado, avaliações de prontidão, remediação assistida por IA, fluxos guiados, análise de dependências, identificação de requisitos e previsão do risco do projeto. (IBM)

Isso transforma o upgrade em algo mais próximo de uma investigação estruturada.

Passo a passo conceitual

Passo 1 — Inventariar

Descobrir:

Quais programas existem?
Onde estão?
Qual compilador foi utilizado?
Quais bibliotecas participam do processo?
Quais programas chamam outros programas?

Passo 2 — Mapear dependências

Um programa raramente vive sozinho.

PGM-A
  ├── COPY CLIENTE
  ├── COPY CONTA
  ├── CALL PGM-B
  ├── EXEC SQL
  └── EXEC CICS LINK PGM-C

Modificar o PGM-A pode afetar mais do que o PGM-A.

Passo 3 — Avaliar prontidão

O sistema precisa identificar:

  • incompatibilidades;

  • padrões problemáticos;

  • opções obsoletas;

  • riscos de migração;

  • necessidades de correção.

Passo 4 — Priorizar

Os programas podem ser classificados, conceitualmente, como:

Baixo risco
Médio risco
Alto risco
Necessita investigação

Passo 5 — Remediar

A assistência de IA pode ajudar a explicar problemas e orientar correções.

Aqui existe uma diferença enorme entre:

ERRO NA LINHA 1784

e:

A construção utilizada depende de um comportamento legado.
Considere a seguinte alteração e execute estes testes.

Passo 6 — Executar ondas de migração

Em vez de uma migração caótica de 40 mil programas:

Onda 1 — baixo risco
Onda 2 — médio risco
Onda 3 — aplicações críticas
Onda 4 — casos especiais

Esse planejamento reduz o efeito “Big Bang”, no qual tudo é alterado ao mesmo tempo e ninguém consegue determinar qual mudança causou o incidente.


Capítulo 6 — Terceiro laboratório: Performance Insights

O terceiro pilar é o Performance Insights.

Talvez seja a parte mais fácil de explicar para um programador iniciante e uma das mais interessantes para um profissional experiente.

Tradicionalmente, performance no mainframe é observada por meio de dados como:

  • tempo de CPU;

  • tempo decorrido;

  • EXCP;

  • utilização de serviço;

  • contadores CICS;

  • métricas Db2;

  • estatísticas IMS;

  • informações SMF;

  • relatórios RMF;

  • medições por job, transação ou address space.

Essas informações são valiosas.

Porém, existe um problema.

Elas podem dizer:

O PROGRAMA X CONSOME MUITA CPU

mas não necessariamente:

A REGIÃO ENTRE AS LINHAS 1840 E 1880
É A PRINCIPAL RESPONSÁVEL

O Performance Insights procura conectar análise estática, análise dinâmica e dados reais de execução ao código-fonte COBOL. Com isso, a solução pretende identificar e priorizar problemas potenciais de performance, oferecendo recomendações acionáveis diretamente associadas ao fonte. (IBM)

Análise estática

É a investigação do código sem depender apenas de uma execução específica.

Ela pode observar padrões como:

  • estruturas de repetição;

  • chamadas;

  • pesquisas;

  • conversões;

  • movimentações;

  • uso de tabelas;

  • caminhos lógicos;

  • construções que merecem revisão.

Exemplo:

PERFORM 1000-PROCESSAR
   VARYING WS-INDICE FROM 1 BY 1
   UNTIL WS-INDICE > 5000000

A estrutura não é automaticamente um erro.

Mas merece atenção porque qualquer operação dentro dela pode ser repetida cinco milhões de vezes.

Análise dinâmica

É a observação da aplicação durante uma execução real ou representativa.

Ela responde:

  • quantas vezes o trecho executou;

  • quanto recurso foi consumido;

  • quais caminhos foram mais utilizados;

  • quais rotinas quase nunca foram chamadas;

  • onde o tempo ficou concentrado.

A união das duas

A análise estática diz:

“Este trecho tem potencial para ser caro.”

A dinâmica responde:

“Ele foi executado 80 milhões de vezes e representa parte relevante do consumo.”

Juntas, elas formam uma evidência muito mais forte.

No CSI, uma impressão digital isolada pode não resolver o caso.

Uma impressão digital, uma gravação, o horário e o DNA formam um conjunto muito mais convincente.


Capítulo 7 — Exemplo investigativo

Considere um programa de cálculo de tarifas:

       PERFORM VARYING WS-I FROM 1 BY 1
          UNTIL WS-I > WS-QTD-LANCAMENTOS

          MOVE SPACES TO WS-DESCRICAO

          PERFORM 3000-LOCALIZAR-TARIFA

          IF WS-TARIFA-ENCONTRADA
             COMPUTE WS-VALOR-TOTAL =
                     WS-VALOR-TOTAL + WS-TARIFA
          END-IF

       END-PERFORM.

O programa funciona.

Mas a análise revela:

Quantidade de iterações: 60.000.000
Chamadas à rotina de localização: 60.000.000
Percentual de CPU concentrado na rotina: 42%

A investigação do fonte mostra que a tabela de tarifas está ordenada, mas o programa realiza uma busca sequencial.

Um desenvolvedor poderia estudar a possibilidade de substituir uma lógica equivalente a busca linear por uma estratégia de busca binária, quando tecnicamente válida.

Por exemplo, em COBOL, uma tabela adequadamente declarada e ordenada pode permitir o uso de SEARCH ALL.

Mas aqui surge uma regra de ouro:

Nunca troque SEARCH por SEARCH ALL apenas porque alguém disse que é mais rápido.

Para utilizar SEARCH ALL, é necessário garantir, entre outros pontos:

  • tabela ordenada conforme a chave;

  • declaração compatível;

  • condição de busca adequada;

  • manutenção correta da ordenação;

  • testes que confirmem o comportamento.

Performance não é adivinhação.

É ciência baseada em medição.

O Elevate pretende ajudar justamente a mostrar onde uma mudança pode produzir impacto real, evitando a otimização baseada em superstição.


Capítulo 8 — A inteligência artificial entra na sala

A expressão “AI-assisted” aparece no anúncio, especialmente na área de remediação do upgrade.

Isso não deve ser interpretado como:

A IA substituirá todos os programadores COBOL.

O cenário é mais interessante.

A IA pode atuar como um assistente técnico capaz de:

  • interpretar resultados;

  • resumir dependências;

  • explicar incompatibilidades;

  • sugerir remediações;

  • orientar fluxos de atualização;

  • ajudar profissionais menos experientes;

  • reduzir o tempo gasto em levantamentos manuais.

Imagine o programador iniciante encontrando uma construção problemática.

Sem assistência, ele vê:

MIGRATION ISSUE 0C27

Com assistência contextual, ele poderia receber algo semelhante a:

O programa utiliza uma construção cujo comportamento
deve ser revisado na atualização do compilador.

Arquivos relacionados:
COPY-A
COPY-B

Programas dependentes:
PGM102
PGM238

Risco estimado:
Médio

Ação recomendada:
Revisar a definição do campo e executar os testes X, Y e Z.

A inteligência artificial não elimina a necessidade de julgamento humano.

Ela reduz o tempo necessário para chegar às perguntas corretas.

Grissom jamais condenaria um suspeito apenas porque um algoritmo o indicou.

Ele usaria a indicação para procurar evidências.

O mesmo vale para modernização COBOL.


Capítulo 9 — A ligação com o IBM z17

O anúncio do COBOL Elevate foi publicado no mesmo contexto da expansão da família IBM z17, incluindo configurações single frame e rack mount. A IBM posiciona o z17 como uma plataforma para aplicações críticas e relaciona o Elevate ao objetivo de extrair mais valor das aplicações COBOL existentes. A disponibilidade do COBOL Elevate foi anunciada para 18 de setembro de 2026. (IBM Newsroom)

Por que essa ligação importa?

Porque hardware e compilador evoluem juntos.

Um módulo compilado há muitos anos pode não aproveitar da melhor forma:

  • instruções mais recentes;

  • melhorias de geração de código;

  • avanços da arquitetura;

  • otimizações presentes em compiladores modernos;

  • capacidades da nova geração do IBM Z.

Isso não significa que um programa antigo deixe de funcionar.

A retrocompatibilidade é uma das forças históricas do mainframe.

Significa que:

funcionar não é necessariamente o mesmo que aproveitar todo o potencial disponível.

É como colocar um excelente piloto em um veículo moderno, mas obrigá-lo a dirigir utilizando um manual escrito para um modelo de trinta anos atrás.

O veículo anda.

Porém, vários recursos permanecem inutilizados.


Capítulo 10 — Para que o produto serve?

O IBM COBOL Elevate pode ajudar organizações que enfrentam problemas como:

1. Inventário desconhecido

A empresa não sabe exatamente quais programas existem, como se relacionam ou quais versões de compilador foram utilizadas.

2. Upgrade adiado

O projeto de atualização é constantemente postergado por medo do risco, falta de profissionais ou ausência de estimativas confiáveis.

3. CPU crescente

Os volumes aumentam, o consumo cresce e ninguém consegue relacionar facilmente a métrica operacional ao trecho de código responsável.

4. Equipe reduzida

Poucos profissionais conhecem profundamente todo o ambiente.

5. Otimização sem prioridade

Existem milhares de programas, mas não há critérios para decidir quais merecem atenção.

6. Modernização genérica

A empresa fala em modernização, mas não possui uma sequência prática de ações.

O Elevate procura oferecer uma rota mais objetiva:

Descobrir
   ↓
Medir
   ↓
Classificar
   ↓
Priorizar
   ↓
Otimizar
   ↓
Atualizar
   ↓
Validar
   ↓
Acompanhar

Capítulo 11 — O que ele não é

Também precisamos eliminar alguns suspeitos inocentes.

Não é um substituto automático do COBOL

O objetivo não é apagar o COBOL e converter tudo para outra linguagem.

Não é simplesmente um compilador novo

O Enterprise COBOL continua sendo o compilador. O Elevate trabalha em torno do processo de análise, otimização, priorização e upgrade.

Não é uma autorização para deixar de testar

Reduzir esforço de teste não significa eliminar testes.

Não é uma bola de cristal

Uma recomendação precisa ser analisada dentro do contexto da aplicação.

Não elimina especialistas

Ele pode reduzir dependências excessivas e tornar conhecimento mais acessível, mas arquitetos, desenvolvedores, engenheiros de performance, equipes de testes e especialistas de negócio continuam essenciais.

Não corrige regras de negócio erradas apenas acelerando o código

Um programa que calcula algo incorretamente continuará errado, talvez apenas mais rápido.

Essa é uma curiosidade importante:

Otimizar um erro pode transformar um erro lento em um erro de alta velocidade.


Capítulo 12 — Como um programador COBOL iniciante deve estudar o Elevate

Mesmo antes de utilizar o produto, o iniciante pode preparar a base técnica.

Passo 1 — Aprenda o ciclo de compilação

Entenda:

Fonte COBOL
   ↓
Pré-compilação, quando aplicável
   ↓
Compilação
   ↓
Objeto
   ↓
Binder
   ↓
Load module ou program object
   ↓
Execução

Sem compreender essa sequência, será difícil perceber o significado de otimizar, recompilar ou atualizar compiladores.

Passo 2 — Estude opções de compilação

Conheça conceitos como:

  • OPTIMIZE;

  • ARCH;

  • TUNE;

  • informações de debug;

  • listings;

  • mapas;

  • opções relacionadas ao comportamento do compilador.

Não é necessário decorar tudo.

O importante é perceber que dois programas com o mesmo fonte podem gerar objetos diferentes dependendo da versão e das opções utilizadas.

Passo 3 — Aprenda o básico de performance

Diferencie:

  • CPU time;

  • elapsed time;

  • espera por I/O;

  • contenção;

  • consumo de Db2;

  • tempo de serviço;

  • volume processado;

  • frequência de execução.

Um programa pode demorar muito sem consumir muita CPU, por exemplo, quando espera I/O ou algum recurso.

Passo 4 — Estude estruturas COBOL críticas

Observe:

  • loops;

  • tabelas;

  • chamadas;

  • buscas;

  • conversões;

  • campos mal definidos;

  • uso de funções;

  • movimentações repetitivas;

  • acessos a arquivos e bancos.

Passo 5 — Aprenda a medir antes de alterar

Nunca otimize apenas porque um trecho “parece feio”.

Código feio pode executar uma vez por semana.

Código elegante pode executar 500 milhões de vezes por dia.

Passo 6 — Entenda o negócio

Uma rotina pode parecer redundante, mas existir por exigência regulatória, contábil ou histórica.

Antes de removê-la, investigue.

No mainframe, muitos comentários ausentes estão escondidos na memória dos antigos membros da equipe.


Capítulo 13 — Um roteiro corporativo de adoção

Uma organização interessada no COBOL Elevate poderia estruturar uma iniciativa conceitual em fases.

Fase 1 — Definir o caso

Escolher uma aplicação com:

  • consumo relevante;

  • valor de negócio;

  • dados confiáveis;

  • equipe disponível;

  • volume representativo.

Fase 2 — Criar a linha de base

Registrar:

CPU atual
Elapsed atual
Volume processado
Versão dos módulos
Compiladores
Opções
Incidentes
Janela batch
SLA

Sem linha de base, qualquer alegação de melhoria vira opinião.

Fase 3 — Inventariar

Mapear programas, copybooks, bibliotecas e dependências.

Fase 4 — Analisar candidatos

Separar os módulos realmente relevantes.

Fase 5 — Avaliar recomendações

Reunir:

  • desenvolvimento;

  • performance;

  • produção;

  • testes;

  • negócio.

Fase 6 — Criar piloto

Começar com um conjunto controlado.

Fase 7 — Testar

Executar:

  • comparação funcional;

  • regressão;

  • análise de resultados;

  • performance;

  • recuperação;

  • rollback.

Fase 8 — Comparar

Exemplo:

ANTES
CPU: 100 unidades
Elapsed: 45 minutos

DEPOIS
CPU: 78 unidades
Elapsed: 37 minutos

Mas também verificar:

Resultados de negócio idênticos?
Registros processados idênticos?
Abends?
Diferenças?
Comportamento em pico?

Fase 9 — Expandir

Somente depois das evidências, ampliar para outras aplicações.


Capítulo 14 — Curiosidades recolhidas no laboratório

Curiosidade 1 — O nome “Elevate”

A escolha sugere elevar aplicações existentes, não descartá-las.

Não é “COBOL Replace”.

Não é “COBOL Escape”.

É “COBOL Elevate”.

O patrimônio permanece, mas deve ser levado a outro nível de eficiência e manutenção.

Curiosidade 2 — O release começa em 1.1

O produto foi anunciado publicamente como IBM COBOL Elevate for z/OS 1.1. A numeração pode refletir a estratégia de empacotamento e evolução do produto, mas não devemos inventar a existência de uma versão comercial 1.0 sem documentação específica.

Curiosidade 3 — O fonte não é a única evidência

Um programa COBOL possui várias camadas relevantes:

Fonte
Copybooks
Opções do compilador
Objeto
Program object
Runtime
Dados
Volume
Ambiente
Hardware

Analisar apenas o fonte é como analisar apenas a fotografia da cena sem examinar impressões digitais, horários e depoimentos.

Curiosidade 4 — O programa mais longo pode não ser o mais caro

Um programa de 20 mil linhas executado uma vez pode consumir menos que uma rotina de 30 linhas chamada 200 milhões de vezes.

Curiosidade 5 — A otimização pode adiar expansão de capacidade

Quando aplicações utilizam menos CPU ou terminam mais cedo, a empresa pode obter maior valor do hardware existente, liberar janela batch e acomodar crescimento.

Isso não significa que qualquer otimização automaticamente reduzirá custos, pois contratos, métricas e modelos de cobrança variam. Mas eficiência técnica aumenta as opções disponíveis para planejamento de capacidade.


Capítulo 15 — Easter eggs para veteranos

Easter egg 1 — O cadáver que se levantou

O COBOL já foi declarado morto tantas vezes que deveria possuir mais certidões de óbito que programas em uma load library.

Agora, em vez de organizar seu funeral, a IBM apresenta uma solução para fazê-lo executar melhor no z17.

Easter egg 2 — “Follow the evidence”

No CSI, Grissom dizia que as evidências contam a história.

Na performance, o equivalente é:

Follow the measurements.

Não siga a opinião.

Não siga a estética do código.

Não siga o módulo que alguém “acha” problemático.

Siga CPU, frequência, volume, tempo e impacto.

Easter egg 3 — O copybook desaparecido

Todo grande projeto de inventário encontra algum programa cuja compilação depende de um copybook guardado em uma biblioteca que ninguém conhecia.

Em Las Vegas, isso seria chamado de evidência escondida.

No mainframe, chama-se terça-feira.

Easter egg 4 — O load module sem fonte

Existe sempre aquele módulo antigo que funciona há vinte anos, mas cujo fonte correto ninguém consegue localizar.

Ele continua em produção como um suspeito sem documentos, vivendo sob identidade falsa.

Easter egg 5 — A linha inocente

Um simples:

MOVE ZERO TO WS-CONTADOR

parece inofensivo.

E geralmente é.

Mas qualquer operação multiplicada por centenas de milhões merece ser analisada no contexto correto.


Capítulo 16 — A pergunta provocativa

Durante décadas, a modernização foi vendida como uma escolha binária:

OU REESCREVEMOS TUDO
OU CONTINUAMOS PARADOS NO PASSADO

O COBOL Elevate confronta essa ideia.

Ele sugere uma terceira rota:

PRESERVAR A LÓGICA
COMPREENDER O AMBIENTE
ATUALIZAR O COMPILADOR
OTIMIZAR O QUE IMPORTA
MELHORAR CONTINUAMENTE

Isso é menos cinematográfico que uma reescrita completa.

Não produz um slide dizendo “100% transformação”.

Mas pode ser muito mais responsável.

Reescrever milhões de linhas de código não remove automaticamente a complexidade do negócio. Às vezes, apenas transporta os mesmos problemas para uma nova linguagem, adicionando novos defeitos durante o percurso.

A lógica acumulada durante décadas representa conhecimento institucional.

A modernização inteligente não começa perguntando:

“Como nos livramos do COBOL?”

Ela começa perguntando:

“O que este sistema faz, por que é importante, onde está o risco e como podemos melhorá-lo com evidências?”


Capítulo 17 — O impacto para a carreira COBOL

Para o programador iniciante, o anúncio traz uma notícia excelente.

O futuro profissional não será apenas escrever:

IF SALDO > ZERO
   PERFORM PAGAMENTO
END-IF

O novo profissional COBOL precisará compreender:

  • performance;

  • compilação;

  • dependências;

  • observabilidade;

  • análise estática;

  • análise dinâmica;

  • IA assistiva;

  • DevOps;

  • modernização;

  • arquitetura IBM Z;

  • qualidade de software.

O programador deixa de ser apenas o autor do fonte.

Torna-se investigador do comportamento da aplicação.

Essa mudança amplia a carreira.

Um desenvolvedor pode evoluir para:

  • especialista em modernização COBOL;

  • engenheiro de performance;

  • arquiteto de aplicações IBM Z;

  • especialista em upgrade de compiladores;

  • engenheiro DevOps para mainframe;

  • líder de qualidade;

  • analista de dependências;

  • consultor de otimização.

O COBOL Elevate não reduz a importância do conhecimento COBOL.

Ele torna esse conhecimento parte de uma disciplina mais ampla.


Veredito final do laboratório

O IBM COBOL Elevate for z/OS 1.1, anunciado em 7 de julho de 2026 e com disponibilidade geral planejada para 18 de setembro de 2026, representa uma tentativa ambiciosa da IBM de reunir otimização, modernização, atualização de compiladores, inteligência artificial e análise de performance em uma solução integrada. (IBM)

Seus três pilares formam uma sequência lógica:

ACCELERATE
Identificar e otimizar módulos relevantes.

UPGRADE
Inventariar, avaliar e acelerar a atualização do compilador.

PERFORMANCE INSIGHTS
Ligar evidências de execução ao código-fonte.

O maior mérito da proposta não é prometer uma substituição mágica do legado.

É reconhecer que o ambiente COBOL precisa ser investigado antes de ser transformado.

Em vez de tratar todos os programas como culpados, a solução procura:

  • localizar os verdadeiros consumidores;

  • medir o impacto;

  • identificar dependências;

  • avaliar riscos;

  • orientar correções;

  • concentrar o esforço onde existe retorno.

No final daquela madrugada em Las Vegas, o jovem programador olhou novamente para o alerta de CPU.

— Então não devemos recompilar tudo?

Grissom desligou a lanterna, colocou o relatório sobre a mesa e respondeu:

— Não até sabermos quais módulos estavam presentes, quantas vezes foram executados e o que fizeram com cada ciclo de processador.

Na tela do terminal, milhares de programas continuavam trabalhando.

Alguns estavam perfeitamente inocentes.

Outros escondiam comportamentos caros havia décadas.

E pela primeira vez, havia um novo investigador entrando no laboratório.

Seu nome era:

IBM COBOL ELEVATE FOR z/OS
RELEASE 1.1

Porque no mainframe, como no CSI, o código pode permanecer em silêncio.

Mas a CPU sempre deixa vestígios.

 Maiores informações

https://www.ibm.com/new/announcements/introducing-ibm-cobol-elevate-for-z-os

segunda-feira, 27 de julho de 2026

AWS vs Mainframe: O Grande Dicionário Bilíngue da Computação Corporativa

 

Bellacosa Mainframe compara o aws com o mainframe

☕ Um Café no Bellacosa Mainframe

AWS vs Mainframe: O Grande Dicionário Bilíngue da Computação Corporativa

Quando um Programador COBOL Descobre que a Nuvem Não Inventou Tudo... Apenas Deu Novos Nomes às Velhas Ideias

Existe uma frase muito conhecida entre os profissionais de tecnologia:

"Toda tecnologia nova parece revolucionária... até você descobrir que o mainframe já fazia algo parecido há décadas."

Naturalmente, essa frase é um exagero. A computação em nuvem trouxe inúmeras inovações reais: elasticidade praticamente infinita, cobrança sob demanda, infraestrutura global distribuída, APIs padronizadas e uma velocidade de provisionamento que seria impensável nos anos 1970.

Por outro lado...

Quem trabalhou muitos anos em IBM Z percebe rapidamente algo curioso.

Boa parte dos conceitos fundamentais da Cloud Computing já existiam, apenas recebiam outros nomes.

É justamente isso que o infográfico procura mostrar.

Não se trata de afirmar que AWS = Mainframe.

Muito menos que um substitui o outro.

A proposta é muito mais inteligente:

Traduzir conceitos.

Da mesma forma que um brasileiro aprende inglês associando "house" com "casa", um programador COBOL aprende AWS muito mais rapidamente quando pensa:

"EC2... isso lembra uma LPAR."

É exatamente essa mudança mental que acelera o aprendizado.

Vamos aprofundar essa comparação.


Antes de tudo...

Existe um erro extremamente comum.

Muitos profissionais perguntam:

"Qual é o equivalente do AWS Lambda no Mainframe?"

Na verdade essa pergunta está errada.

O correto seria perguntar:

"Qual tecnologia do Mainframe resolve um problema semelhante?"

Porque tecnologias diferentes podem resolver o mesmo problema de maneiras completamente distintas.

É exatamente isso que veremos.


EC2 × LPAR

AWS

EC2 fornece máquinas virtuais sob demanda.

Você cria.

Liga.

Desliga.

Apaga.

Escala.

Tudo em minutos.


Mainframe

A comparação natural é a LPAR (Logical Partition).

Mas aqui existe uma enorme diferença filosófica.

Uma instância EC2 normalmente é um servidor virtual.

Uma LPAR é praticamente um computador completo.

Dentro dela existe:

  • z/OS

  • JES

  • RACF

  • CICS

  • Db2

  • MQ

  • milhares de usuários

Ou seja...

Uma única LPAR frequentemente faz o trabalho de centenas de servidores Linux.

Por isso muitos profissionais dizem:

"Comparar uma EC2 com uma LPAR é como comparar um apartamento com um condomínio inteiro."


Curiosidade

O conceito de particionamento lógico apareceu comercialmente décadas antes da virtualização popularizada pelo VMware.

A IBM fazia isso quando a maioria dos servidores ainda era física.


S3 × VSAM / DASD

Esta comparação merece cuidado.

S3 não é um disco.

É um armazenamento de objetos.

VSAM não é armazenamento de objetos.

É um método de acesso.

Então por que a comparação?

Porque ambos representam onde os dados vivem.


S3

Armazena objetos.

  • fotos

  • backups

  • vídeos

  • PDFs

  • logs

Escala praticamente infinita.


Mainframe

No IBM Z os dados normalmente ficam em:

  • DASD

  • VSAM

  • Sequential datasets

  • GDGs

  • PDS/PDSE

O conceito é diferente.

Enquanto S3 trabalha com objetos identificados por chaves, o mainframe trabalha com datasets catalogados e métodos de acesso especializados.

Um VSAM KSDS, por exemplo, comporta-se muito mais como um banco de dados indexado do que como um bucket S3.


Melhor analogia

Talvez fosse mais correto dizer:

S3 ≈ Conjunto de datasets altamente duráveis.

Não existe equivalente perfeito.


RDS × Db2 for z/OS

Aqui a aproximação é muito boa.

AWS oferece banco relacional gerenciado.

Db2 oferece banco relacional corporativo.

Mas termina aí.


O que muda?

No AWS:

Você administra menos infraestrutura.

No Mainframe:

Você administra muito mais parâmetros.

Em compensação...

Obtém níveis absurdos de disponibilidade.

Db2 z/OS foi construído para:

  • bancos

  • cartões

  • bolsas

  • governos

  • seguradoras

Milhões de transações por segundo.

Décadas de evolução.

Consistência extrema.


Easter Egg

Quando alguém diz:

"Meu banco usa RDS."

O programador de mainframe responde:

"Interessante... o meu banco inteiro usa Db2."


Lambda × CICS

Essa comparação é conceitual.

Lambda executa código quando um evento ocorre.

CICS executa transações quando uma requisição chega.

Ambos respondem a eventos.

Mas de maneiras completamente diferentes.


Lambda

Sem servidor visível.

Escala automaticamente.

Cada chamada inicia uma execução.


CICS

Servidor transacional residente.

As tarefas reutilizam recursos.

Baixíssima latência.

Controle rigoroso.

Extrema confiabilidade.


Uma transação CICS pode durar poucos milissegundos.

E atender milhares de usuários simultaneamente.

Há bancos onde o cliente insere a senha no caixa eletrônico...

E em menos de um décimo de segundo:

  • RACF valida

  • CICS executa

  • Db2 consulta

  • MQ envia mensagens

  • resposta retorna

Tudo isso antes do usuário piscar.


API Gateway × CICS Web Services

Nos últimos anos o CICS tornou-se um verdadeiro servidor de APIs.

Hoje é possível expor programas COBOL como:

  • REST

  • SOAP

  • JSON

Sem reescrever décadas de código.

A ideia é semelhante ao API Gateway:

publicar serviços de forma segura.

A diferença é que no CICS o backend muitas vezes continua sendo um programa escrito em 1989.

E funcionando perfeitamente.


CloudWatch × RMF / SMF

Talvez uma das melhores comparações.

CloudWatch monitora.

RMF mede.

SMF registra praticamente tudo.


No mainframe existem registros para:

CPU.

I/O.

Memória.

Logons.

Jobs.

CICS.

Db2.

MQ.

Segurança.

Tudo vira SMF.

Depois essas informações alimentam:

  • relatórios

  • capacity planning

  • billing interno

  • auditoria

  • performance

É praticamente uma caixa-preta de avião.


VPC × VTAM / TCP-IP

VPC cria uma rede privada lógica.

No mainframe temos:

  • TCP/IP

  • Enterprise Extender

  • SNA

  • VTAM (historicamente)

São tecnologias diferentes.

Mas ambas organizam comunicações seguras entre aplicações.

Hoje, o TCP/IP é predominante no z/OS, enquanto o VTAM permanece como parte importante da arquitetura SNA e do gerenciamento de sessões legadas.


IAM × RACF

Esta talvez seja a comparação mais intuitiva.

IAM controla identidades.

RACF controla identidades.

Mas RACF faz isso desde os anos 1970.


No RACF encontramos:

  • usuários

  • grupos

  • perfis

  • datasets

  • transações

  • comandos

  • permissões

Tudo centralizado.

Em ambientes corporativos enormes, RACF continua sendo um dos sistemas de segurança mais robustos do mercado.


CloudFront

Aqui o infográfico coloca:

Sem equivalente.

Concordo parcialmente.

CloudFront é uma CDN.

Mainframe nunca precisou distribuir imagens para milhões de navegadores.

Mas existe um conceito parecido.

CICS, z/OS Connect e balanceadores corporativos podem distribuir carga entre regiões, embora isso não seja uma CDN. Portanto, realmente não há um equivalente direto.


DynamoDB

Também não existe equivalente perfeito.

O mainframe tradicional trabalha principalmente com:

  • Db2

  • IMS DB

  • VSAM

Entretanto...

IMS Hierarchical Database possui algumas características que lembram bancos NoSQL modernos.

Não são iguais.

Mas resolvem certos problemas semelhantes.


SQS × IBM MQ

Esta comparação é excelente.

Ambos trabalham com filas.

Mensagens.

Processamento assíncrono.

Desacoplamento.

A principal diferença está no foco.

IBM MQ nasceu para ambientes corporativos críticos.

SQS nasceu para aplicações distribuídas na nuvem.

Ambos resolvem brilhantemente problemas de integração, mas IBM MQ oferece recursos avançados de transação, persistência e integração com sistemas legados que o tornam um pilar do processamento empresarial.


SNS × WTO / Console Messages

Aqui talvez seja a comparação mais discutível.

SNS distribui notificações para diversos assinantes.

Já WTO (Write To Operator) envia mensagens ao console do operador do z/OS.

Embora ambos "notifiquem", cumprem papéis muito diferentes.

Uma analogia funcional mais próxima seria:

  • SNS ↔ combinação de IBM MQ + Event Notification + automação (como IBM Z System Automation ou NetView), dependendo do cenário.

WTO é muito mais voltado para operação do sistema do que para publicação de eventos para consumidores.


O que ficou faltando?

O universo AWS é enorme. Diversos serviços modernos também encontram paralelos conceituais no ecossistema IBM Z:

AWSMainframe
EBSVolumes DASD
EFSzFS / HFS
Elastic Load BalancerSysplex Distributor
Auto ScalingWLM + Capacity on Demand
Secrets ManagerRACF Key Rings + ICSF
KMSICSF + Hardware Crypto Express
CloudTrailSMF + RACF Auditing
Systems Managerz/OSMF
ECS/EKSzCX (z/OS Container Extensions)
EventBridgeIBM MQ + CICS START + automação
Step FunctionsJCL + Scheduler (TWS/IWS, CA 7, Control-M)
GlueDFSORT, SyncSort, DataStage e ferramentas ETL
AthenaDb2 Analytics, SQL Federation e consultas distribuídas
RedshiftDb2 Analytics Accelerator (IDAA)
CognitoRACF + provedores de identidade (LDAP, SAF, z/OS Connect)

A Filosofia por Trás da Comparação

A maior lição do infográfico não é decorar equivalências.

É perceber que os problemas fundamentais da computação permanecem os mesmos:

  • executar aplicações;

  • armazenar dados;

  • proteger acessos;

  • integrar sistemas;

  • monitorar ambientes;

  • processar eventos;

  • escalar capacidade.

O que muda é a forma como cada arquitetura resolve esses desafios.

O IBM Z foi concebido para oferecer estabilidade, consistência transacional e disponibilidade extrema em um ambiente centralizado. A AWS foi projetada para privilegiar elasticidade, automação, distribuição geográfica e provisionamento sob demanda em uma infraestrutura de nuvem.

Essas filosofias não são concorrentes em todos os casos — são frequentemente complementares. Hoje, é comum encontrar bancos, seguradoras e governos executando seus sistemas críticos em IBM Z enquanto utilizam AWS para APIs, analytics, inteligência artificial, aplicações móveis e serviços digitais.


Conclusão: O Melhor Profissional Fala Dois "Idiomas"

No início da carreira, muitos especialistas em mainframe enxergavam a nuvem como uma ameaça. Da mesma forma, muitos profissionais de cloud acreditavam que o mainframe era apenas uma tecnologia ultrapassada.

Com o tempo, o mercado mostrou uma realidade bem diferente.

Os ambientes corporativos mais sofisticados são híbridos.

O cartão de crédito pode ser autorizado por um programa COBOL executando em CICS e Db2 no IBM Z, enquanto o aplicativo móvel utiliza APIs hospedadas na AWS, com autenticação moderna, monitoramento em nuvem e microsserviços.

Em vez de escolher entre "mainframe ou cloud", as organizações escolhem mainframe e cloud.

Para o profissional de tecnologia, isso significa uma oportunidade extraordinária: dominar os dois mundos. Quem entende como traduzir conceitos entre AWS e IBM Z consegue atuar como uma ponte entre equipes, acelerar projetos de modernização e preservar décadas de conhecimento corporativo enquanto incorpora as práticas mais recentes da computação em nuvem.

No fim das contas, aprender AWS não exige esquecer o mainframe. Pelo contrário: para quem já conhece IBM Z, muitas ideias da nuvem deixam de parecer completamente novas e passam a ser apenas uma nova linguagem para resolver problemas que a computação empresarial enfrenta — e resolve — há mais de meio século.

domingo, 26 de julho de 2026

Lógica de Validação : Quando um Programador COBOL Descobre que o Campo Obrigatório Não Foi Criado para Irritar Usuários... Mas para Evitar que um Banco Inteiro Exploda às 23h59

 

Bellacosa Mainframe e a logica de validação

☕ Um Café no Bellacosa Mainframe

Lógica de Validação sem Mistérios para Programadores COBOL

Quando um Programador COBOL Descobre que o Campo Obrigatório Não Foi Criado para Irritar Usuários... Mas para Evitar que um Banco Inteiro Exploda às 23h59

"Meu nome é COBOL. Enterprise COBOL."

Imagine a cena clássica de um filme de James Bond.

Em algum lugar de Londres, M entrega uma missão.

— Bond, encontramos um programa escrito em RPG III em 1989. Um desenvolvedor júnior pretende remover algumas validações porque "atrapalham a experiência do usuário". Se ele conseguir... centenas de sistemas financeiros poderão produzir dados incorretos durante meses sem que ninguém perceba.

Bond responde calmamente.

— Então o problema não é o código.

— Exatamente. O problema é que ninguém sabe por que aquele código existe.

...

Bem-vindo ao mundo dos sistemas corporativos.

E curiosamente...

Essa história acontece praticamente todos os dias: validações aparentemente simples escondem regras de negócio extremamente sofisticadas.

Para um programador COBOL iniciante, isso representa uma das maiores mudanças de mentalidade da carreira.


O grande erro dos iniciantes

Todo iniciante pensa parecido.

Ele abre um programa COBOL.

Encontra:

IF CLIENTE = SPACES
    DISPLAY "CLIENTE OBRIGATORIO"
    GO TO TELA
END-IF

Primeira reação:

"Isso é simples."

Segunda reação:

"Posso melhorar."

Terceira reação:

"Nem precisa existir."

...

E é exatamente aí que começam os problemas.

Porque talvez esse IF esteja protegendo:

  • faturamento

  • integração

  • impostos

  • compliance

  • auditoria

  • relatórios

  • processamento batch

  • fechamento mensal

Ou seja...

o verdadeiro trabalho nunca foi impedir campo vazio.

O verdadeiro trabalho era proteger todo o restante do sistema.


O efeito James Bond

Nos filmes do 007 existe um detalhe interessante.

Quase nunca o vilão destrói Londres usando uma bomba gigante.

Ele altera uma pequena peça.

Troca um satélite.

Muda um código.

Rouba uma chave.

Troca uma senha.

Depois observa o caos acontecer sozinho.

Nos sistemas corporativos acontece exatamente igual.

Você altera uma validação aparentemente insignificante.

Nada acontece.

Durante dias.

Durante semanas.

Depois...

o fechamento financeiro falha.


O usuário vê uma mensagem.

O sistema vê um contrato.

O artigo explica algo extremamente importante.

Para o usuário existe apenas isto:

Campo obrigatório.

Fim.

Mas internamente aquela mensagem significa:

"Não permita que este registro siga adiante porque cinquenta processos dependem dele."

Essa diferença de perspectiva muda completamente a forma como analisamos software legado.


O iceberg das validações

A tela é apenas a ponta.

Debaixo dela existem dezenas de dependências.

Imagine:

Tela

↓

Programa COBOL

↓

VSAM

↓

DB2

↓

MQ

↓

Interface REST

↓

Batch Noturno

↓

Relatórios

↓

BI

↓

Auditoria

↓

Banco Central

O usuário enxerga:

Campo obrigatório.

O arquiteto enxerga:

Uma cadeia inteira de dependências.

Por que sistemas antigos fazem tantas validações?

Porque durante décadas não existiam:

  • APIs

  • Microservices

  • Gateway

  • Event Broker

  • Kafka

  • Camadas REST

Tudo acontecia dentro do programa.

Logo...

a validação morava exatamente onde os dados entravam.

Na tela.

Esse padrão tornou-se extremamente comum em RPG, COBOL, Natural e PL/I.


O verdadeiro inimigo chama-se "dados ruins"

Programadores novos costumam pensar:

"Erro de compilação é ruim."

Não.

Muito pior é dado errado.

Porque código errado normalmente explode imediatamente.

Dado errado...

pode sobreviver anos.


Imagine:

Cliente cadastrado sem CPF.

Hoje nada acontece.

Amanhã:

batch ignora.

Depois:

faturamento não encontra cliente.

Depois:

impostos errados.

Depois:

auditoria encontra inconsistência.

Depois:

advogados entram.

Tudo começou porque alguém retirou um IF.


O paradoxo da modernização

Outro ponto excelente discutido no artigo.

Modernizar NÃO significa preservar tudo.

Nem apagar tudo.

Modernizar significa entender primeiro.

Depois decidir.

A sequência correta é:

  1. Descobrir a regra.

  2. Entender a regra.

  3. Descobrir quem usa.

  4. Descobrir quem depende.

  5. Só então alterar.

Jamais o contrário.


Um dos maiores perigos: o efeito dominó

Imagine uma peça de dominó.

Você derruba apenas uma.

As outras caem sozinhas.

Validações funcionam exatamente assim.

Uma alteração pequena pode atingir:

  • relatórios

  • integração SAP

  • emissão fiscal

  • XML

  • APIs

  • Data Warehouse

  • Analytics

Nenhuma dessas equipes estava olhando aquela tela.

Mas todas dependiam dela.


James Bond e o Mainframe

Se James Bond trabalhasse num banco...

Q provavelmente lhe entregaria um gadget chamado:

Validator Scanner 9000

Funções:

✓ localizar IF esquecidos

✓ encontrar PERFORM misteriosos

✓ rastrear GO TO perigosos

✓ identificar programas batch impactados

Infelizmente...

na vida real esse gadget chama-se:

Conhecimento.

A IA entra em cena

O artigo mostra um uso extremamente inteligente da IA.

Não para substituir o desenvolvedor.

Mas para acelerar investigação.

Por exemplo.

A IA pode responder rapidamente:

  • Qual campo é validado?

  • Qual mensagem aparece?

  • Qual arquivo recebe update?

  • Qual status muda?

  • Quais programas são chamados?

  • Quais SQL executam?

  • Quais interfaces dependem?

Ela reduz dias de investigação para minutos em muitos casos.


Mas cuidado...

A IA enxerga código.

Ela não enxerga história.

Ela pode dizer:

"Campo obrigatório."

Mas não sabe que:

Em 1997 um cliente perdeu milhões porque esse campo ficou vazio.

Quem sabe isso?

O analista veterano.


O método Bellacosa de investigação

Sempre ensine seu cérebro a pensar nesta sequência:

Etapa 1

Onde está a validação?


Etapa 2

Quem chama?


Etapa 3

Quem grava?


Etapa 4

Quem lê?


Etapa 5

Quem depende?


Etapa 6

O que quebra?


Etapa 7

Ainda faz sentido?


Só depois:

Modificar.


A importância da documentação

Outro excelente ponto.

Quando finalmente descobrimos o motivo daquela validação...

não podemos guardar isso apenas na cabeça.

Transforme em:

  • Wiki

  • Confluence

  • Markdown

  • Obsidian

  • Teste

  • Caso de Uso

Conhecimento que permanece apenas em pessoas desaparece quando elas mudam de projeto ou se aposentam.


O prompt apresentado

O artigo também fornece um excelente modelo para IA.

Ele pede análise sobre:

  • campo

  • condição

  • mensagem

  • regra

  • arquivos

  • programas

  • SQL

  • interfaces

  • batch

  • riscos

  • QA

  • suporte

  • testes

Na prática é quase um checklist de engenharia reversa moderna.


Os cinco agentes secretos da modernização

Desenvolvedor

Descobre como funciona.


Analista

Descobre por quê.


QA

Prova que continua funcionando.


Suporte

Conta todas as tragédias já ocorridas.


Arquiteto

Decide onde essa regra deverá viver daqui para frente.

Cada um possui uma parte da missão.


Curiosidade histórica

Nos anos 1970 e 1980 era comum concentrar praticamente toda a inteligência do negócio dentro do programa COBOL ou RPG.

Não porque fosse "bonito".

Mas porque era o local natural onde os dados entravam.

Décadas depois, APIs, microsserviços e arquiteturas em camadas redistribuíram muitas dessas responsabilidades, mas inúmeras regras continuam preservadas no legado por razões históricas e operacionais.


Easter Egg 007

Existe um paralelo curioso.

Nos filmes do James Bond, M frequentemente diz:

"Confie em seus instintos."

No mainframe existe uma versão melhor:

"Nunca remova um IF antes de descobrir quem escreveu aquele IF."

Porque talvez quem escreveu já tenha resolvido um desastre que nunca foi documentado.


Licença para Refatorar

Bond tinha licença para matar.

O programador moderno deveria possuir outra licença:

Licença para perguntar.

Antes de remover qualquer validação:

  • Quem pediu?

  • Quando surgiu?

  • Qual incidente originou?

  • Existe documento?

  • Existe chamado?

  • Existe histórico?

  • Existe auditoria?

Se ninguém souber responder...

o IF merece respeito.


Conclusão — O verdadeiro agente secreto é a regra de negócio

Todo iniciante imagina que programas COBOL são grandes coleções de IFs antigos, mensagens em maiúsculas e GO TO espalhados pelo código.

Com o tempo, porém, descobre uma verdade muito mais fascinante: cada validação é um pequeno agente secreto infiltrado no sistema. Ela trabalha silenciosamente, impedindo que dados inconsistentes atravessem fronteiras invisíveis e provoquem efeitos em cadeia em faturamento, relatórios, integrações, processamento batch e auditorias.

Modernizar não é eliminar essas sentinelas indiscriminadamente. É investigar sua missão, entender o contexto histórico, confirmar se ainda fazem sentido e decidir o melhor lugar para que continuem protegendo o negócio. A inteligência artificial pode acelerar essa investigação, resumir código e sugerir perguntas relevantes, mas ela ainda depende da experiência humana para interpretar o significado de cada regra e validar seu impacto no mundo real.

No universo Bellacosa Mainframe, a maior lição é simples: um IF aparentemente banal pode valer mais do que milhares de linhas de código moderno, porque ele representa conhecimento acumulado ao longo de décadas. Assim como James Bond salva o mundo antes que a maioria perceba que havia perigo, uma boa validação impede desastres que nunca aparecerão nos relatórios de incidentes justamente porque jamais chegaram a acontecer.

Da próxima vez que encontrar um antigo IF CAMPO = SPACES, não pense apenas em removê-lo. Pense que talvez ele seja o 007 do seu sistema: discreto, elegante, quase invisível... e responsável por impedir que uma catástrofe silenciosa aconteça todos os dias.

Os Três Bugs Invisíveis do Padawan COBOL : Como vencer a hesitação, a ingenuidade e o excesso de confiança

Bellacosa Mainframe e os 3 bugs invisiveis do padawan cobol



☕ Um Café no Bellacosa Mainframe

Os Três Bugs Invisíveis do Padawan COBOL

Como vencer a hesitação, a ingenuidade e o excesso de confiança antes que eles provoquem o primeiro ABEND da sua carreira

"O primeiro programa raramente derruba o banco. O primeiro erro de julgamento, sim."


Introdução

Existe um momento curioso na carreira de praticamente todo programador COBOL.

Não importa se ele estudou durante seis meses, um ano ou cinco anos.

Não importa se tirou certificações IBM.

Não importa se domina PROCEDURE DIVISION, PERFORM VARYING, OCCURS DEPENDING ON, SQL EMBEDDED, CICS ou VSAM.

O verdadeiro teste começa no primeiro dia em produção.

É ali que nasce o verdadeiro programador.

Durante décadas observando profissionais entrando em grandes bancos, seguradoras, empresas aéreas, órgãos públicos e processadoras de cartões, percebi um padrão curioso.

Os novatos quase nunca fracassam por falta de conhecimento técnico.

Eles tropeçam em três inimigos invisíveis.

São eles:

  • Hesitação

  • Ingenuidade

  • Excesso de confiança

Esses três defeitos aparecem em praticamente toda profissão crítica.

Na aviação.

Na medicina.

Na engenharia.

Na investigação criminal.

E, principalmente, em ambientes IBM Mainframe.

O curioso é que eles aparecem em momentos diferentes da evolução profissional.

E quase sempre na mesma ordem.

Hoje vamos investigar cada um deles como se estivéssemos em um episódio de CSI.

Porque um sistema crítico deixa rastros.

E a mente do programador também.


Cena do Crime 1

A Hesitação

Imagine a seguinte situação.

Você acabou de entrar na empresa.

Seu líder diz:

"Precisamos alterar o programa FINA340."

Você abre o programa.

28.000 linhas.

Escrito em 1989.

Última alteração:
há quatro dias.

Autores:

  • João

  • Carlos

  • Equipe Y2K

  • Projeto PIX

  • Open Banking

  • Adequação LGPD

Você olha aquilo.

O cursor pisca.

Cinco minutos.

Dez minutos.

Quinze minutos.

Você simplesmente não consegue tocar em nada.

Isso é completamente normal.


O cérebro entra em modo de sobrevivência

Nosso cérebro odeia destruir algo que parece importante.

Quanto maior a responsabilidade...

Maior a hesitação.

É um mecanismo biológico.

O problema é que hesitação excessiva paralisa.

E um programador parado não aprende.


O primeiro segredo

Veteranos não têm menos medo.

Eles apenas sabem investigar antes.

Essa é uma diferença gigantesca.

O novato pensa:

"Vou alterar."

O veterano pensa:

"Vou entender."


O método Bellacosa

Nunca altere antes de responder:

O que este programa faz?

Quem chama este programa?

Quem ele chama?

Quais arquivos atualiza?

Quais tabelas Db2 altera?

Existe rollback?

Existe commit?

Existe checkpoint?

Existe controle de versão?

Existe scheduler?

Existe impacto batch?

Existe impacto online?

Existe interface MQ?

Existe interface CICS?

Existe API?

Quando todas essas respostas aparecem...

A hesitação desaparece.

Porque ela foi substituída por conhecimento.


Easter Egg

Sherlock Holmes dizia:

"É um erro teorizar antes de possuir os fatos."

Todo programador COBOL deveria colocar essa frase no monitor.


Cena do Crime 2

A Ingenuidade

Depois do primeiro mês...

A hesitação diminui.

Agora nasce outro inimigo.

O iniciante acredita em tudo.

Documentação.

Comentários.

Fluxogramas.

Diagramas.

PowerPoint.

Wiki.

Chamados.

Manuais.


A maior mentira do Mainframe

Imagine encontrar isso:

* Atualiza somente clientes ativos

Bonito.

Organizado.

Profissional.

Mas você olha o código...

MOVE "S" TO WS-ATIVO

Nada mais.

Nenhuma validação.

Nenhuma regra.

Nenhum IF.

O comentário está errado há quinze anos.

Quem escreveu?

Provavelmente alguém que saiu da empresa em 2004.


A documentação envelhece

Código muda.

Documentação nem sempre.

O sistema continua funcionando.

Mas o documento virou arqueologia.

É como encontrar um mapa romano tentando dirigir em São Paulo.


A regra de ouro

Nunca confie totalmente em:

Comentários

Diagramas

Documentação

Fluxogramas

Apresentações

Emails antigos

Confie no comportamento do sistema.

Ele não mente.


Curiosidade

Muitos bancos possuem documentação cuja última atualização ocorreu antes do PIX existir.

O sistema evoluiu.

O documento não.


Cena do Crime 3

O Excesso de Confiança

Esse é o mais perigoso.

Porque normalmente aparece depois dos primeiros sucessos.

Você já resolveu alguns chamados.

Corrigiu ABEND.

Alterou tela CICS.

Fez alguns programas.

Agora pensa:

"Estou dominando."

É aí que mora o perigo.


O efeito Dunning-Kruger no Mainframe

Existe um fenômeno psicológico famoso.

Quanto menos sabemos...

Mais acreditamos saber.

Depois de alguns anos...

Percebemos o tamanho do universo.

É curioso.

O profissional de cinco meses costuma parecer mais confiante que o de vinte anos.

Porque ainda não descobriu tudo o que desconhece.


O veterano faz mais perguntas

O iniciante responde rápido.

O veterano pergunta mais.

Isso parece contraditório.

Mas faz sentido.

O veterano conhece centenas de armadilhas.

Ele sabe que sistemas críticos escondem surpresas.


Exemplo clássico

Você altera:

IF SALDO > 0

Parece simples.

Mas esquece que existe outro programa batch.

Outro online.

Outro scheduler.

Outro MQ.

Outro API Gateway.

Outro processo noturno.

Outro job semanal.

Outro fechamento mensal.

Outro processamento anual.

Seu IF alterou uma cadeia inteira.


O código nunca vive sozinho

Essa talvez seja a maior descoberta da carreira.

Programas COBOL não são ilhas.

São organismos.

Cada programa conversa com dezenas de outros.

Às vezes centenas.

Você altera uma linha.

Pode movimentar uma cidade inteira.


CSI Mainframe

Imagine Gil Grissom entrando no CPD.

Ele nunca começaria perguntando:

"Quem é o culpado?"

Ele perguntaria:

"O que aconteceu primeiro?"

Depois:

"O que mudou?"

Depois:

"Quem foi impactado?"

É exatamente assim que um analista experiente investiga incidentes.


Indiana Jones no Data Center

O código legado lembra uma cidade perdida.

Você entra com uma tocha.

Cada COPYBOOK é uma sala.

Cada PERFORM é um corredor.

Cada CALL é uma porta secreta.

Cada JCL é um mapa.

Cada PROC é um túnel subterrâneo.

E cada alteração pode ativar uma armadilha escondida.

O aventureiro imprudente corre.

O arqueólogo observa.


A Regra dos Cinco "Por Quês"

Sempre pergunte:

Por que isso existe?

Por que foi escrito assim?

Por que não removeram?

Por que ainda funciona?

Por que ninguém mexe nisso?

A quinta resposta normalmente revela uma decisão de negócio esquecida.


O Erro Mais Caro

Não é apagar um arquivo.

Nem provocar um ABEND.

Nem esquecer um END-IF.

O erro mais caro é assumir.

Assumir que entendeu.

Assumir que ninguém usa.

Assumir que é simples.

Assumir que o comentário está correto.

Assumir que aquele campo nunca recebe zeros.

Mainframe odeia suposições.


O Poder da Humildade Técnica

Existe uma frase muito comum entre grandes especialistas IBM.

"Não sei. Vamos verificar."

Observe.

Eles não respondem imediatamente.

Eles investigam.

Essa postura não demonstra fraqueza.

Demonstra maturidade.


O Ritual Bellacosa Antes de Alterar Qualquer Programa

Criei ao longo dos anos um pequeno ritual que evita boa parte dos problemas em produção. Antes de salvar qualquer alteração, faça estas perguntas:

  1. Entendi exatamente qual é o problema de negócio?

  2. Descobri todos os programas envolvidos?

  3. Verifiquei os COPYBOOKs relacionados?

  4. Analisei impactos em Db2, VSAM, CICS ou IMS?

  5. Procurei alterações semelhantes no histórico?

  6. Executei testes com dados normais e dados extremos?

  7. Pensei no que acontece se um campo vier vazio, nulo ou inesperado?

  8. Existe plano de retorno (rollback) caso algo dê errado?

  9. Alguém mais experiente revisou minha lógica?

  10. Eu conseguiria explicar esta alteração para outra pessoa em cinco minutos?

Se alguma resposta for "não", ainda há investigação a fazer.


Os Três Mestres da Carreira

Todo grande profissional aprende a equilibrar três características:

Coragem
Para enfrentar programas enormes sem fugir.

Curiosidade
Para investigar antes de alterar.

Humildade
Para aceitar que sempre existe algo escondido no sistema.

Esses três pilares são muito mais importantes do que decorar todas as instruções do COBOL.


O Último Easter Egg

Na saga Star Wars, Luke Skywalker acreditava que vencer significava lutar melhor.

Yoda ensinou outra coisa.

Primeiro, controlar a própria mente.

Só depois controlar o sabre de luz.

No Mainframe acontece exatamente o mesmo.

O COBOL não é o sabre.

O sabre é apenas uma ferramenta.

O verdadeiro combate acontece dentro da cabeça do programador.

A hesitação precisa ser transformada em investigação.

A ingenuidade precisa ser substituída por validação.

O excesso de confiança precisa dar lugar à disciplina.

Quando isso acontece, nasce um profissional capaz de trabalhar em ambientes onde milhões de transações financeiras, folhas de pagamento, benefícios governamentais, seguros, cartões de crédito e operações bancárias dependem de algumas linhas de código escritas décadas atrás.


Conclusão — O Primeiro Grande Upgrade Não é no Código, é no Programador

No universo Bellacosa Mainframe, costumo dizer que existem dois tipos de iniciantes.

O primeiro acredita que aprender COBOL significa memorizar verbos, comandos, JCLs e utilitários. Ele mede seu progresso pela quantidade de sintaxes que conhece.

O segundo entende que COBOL é apenas a linguagem usada para conversar com um ecossistema gigantesco de regras de negócio, processos, integrações e pessoas. Ele mede seu progresso pela qualidade das perguntas que faz, pela capacidade de investigar antes de modificar e pela prudência ao assumir responsabilidades.

É esse segundo profissional que evolui para analista, arquiteto, líder técnico e mentor.

A verdadeira iniciação de um Padawan Mainframe não acontece quando ele compila seu primeiro programa sem erros. Ela acontece no dia em que percebe que um sistema legado é como um templo antigo: cada rotina foi construída por gerações diferentes, cada COPYBOOK guarda um pedaço da história da empresa e cada linha de código existe por um motivo — mesmo que esse motivo tenha sido esquecido pelo tempo.

Se você conseguir vencer a hesitação sem perder a prudência, abandonar a ingenuidade sem perder a curiosidade e controlar o excesso de confiança sem perder a coragem, terá desenvolvido a característica mais valiosa de todas: o julgamento técnico.

E julgamento técnico não se aprende em um manual. Ele é construído a cada investigação, a cada revisão de código, a cada incidente resolvido e a cada lição deixada por um erro.

No fim das contas, o maior sistema que um programador COBOL precisa aprender a administrar não é o z/OS, o CICS ou o Db2.

É a própria mente. Só quando ela trabalha de forma disciplinada, investigativa e humilde é que o restante do ecossistema Mainframe deixa de parecer um labirinto e passa a revelar sua verdadeira arquitetura. Nesse momento, o Padawan deixa de apenas escrever programas e começa, de fato, a pensar como um guardião dos sistemas que sustentam parte da economia do mundo.

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