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

Translate

Mostrar mensagens com a etiqueta modernização. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta modernização. Mostrar todas as mensagens

quarta-feira, 23 de setembro de 2026

🐷 A FÁBULA DOS PORCOS ASSADOS NO MAINFRAME

 

Bellacosa Mainframe entre porcos e computadores visoes do sistema legado

☕ Um Café no Bellacosa Mainframe

🐷 A FÁBULA DOS PORCOS ASSADOS NO MAINFRAME

Ou: como uma empresa construiu 47 subsistemas, 312 jobs, 18 filas de MQ e uma War Room para continuar incendiando a floresta

Era uma vez uma enorme empresa que possuía um mainframe.

Ninguém sabia exatamente quando o primeiro programa havia entrado em produção.

Alguns diziam 1974.

Outros juravam ter encontrado um comentário COBOL contendo:

* ALTERADO EM 12/08/1969 - J.SILVA

Mas ninguém tinha coragem de investigar aquilo profundamente.

O importante era que o mainframe funcionava.

E dentro daquele mainframe existia o mais importante sistema corporativo da empresa:


🐷 O SISTEMA DE ASSAR PORCOS

A história começara décadas antes.

Certo dia, um incêndio acidental atingiu uma floresta próxima ao Data Center.

Havia porcos na floresta.

Quando o incêndio terminou, descobriram que os porcos haviam sido assados.

E estavam deliciosos.

Um programador teve então uma ideia:

— Quando precisarmos de porcos assados, podemos incendiar outra floresta.

Funcionou.

Foi criado o primeiro procedimento operacional:

PROC-PORCO-001 — Procedimento para Incêndio Controlado de Floresta para Produção de Porcos Assados.

Durante algum tempo, tudo correu maravilhosamente.

Quando alguém queria porco assado:

  1. colocavam os porcos na floresta;

  2. incendiavam a floresta;

  3. esperavam;

  4. recolhiam os porcos;

  5. serviam o jantar.

Era simples.

Até a empresa crescer.



🖥️ A INDUSTRIALIZAÇÃO DO PORCO

O número de clientes aumentou.

Agora não eram dez porcos.

Eram dez mil.

Foi necessário automatizar o processo.

Um programador COBOL escreveu:

PORC001

Outro criou:

PORC002

Depois vieram:

PORC003

PORC003A

PORC003B

PORC003B2

e finalmente:

PORC003B2N

Ninguém sabia onde estava PORC003B1.

Mas havia referências a ele em três copybooks.

Por segurança, ninguém mexia.

O processo passou a ser executado pelo JES2.

Às 22:00:

JOB PORCO01

selecionava os animais.

Às 22:30:

JOB FLOREST1

identificava uma floresta disponível.

Às 23:00:

JOB FIRE001

iniciava o incêndio.

À 01:00:

JOB ASSADO1

calculava o grau provável de cozimento.

Às 03:17, invariavelmente, alguma coisa dava errado.

Então começava a War Room.



🔥 O PRIMEIRO INCIDENTE

Certa madrugada, metade dos porcos saiu crua.

A outra metade virou carvão.

Foi declarado:

SEV1 — CRITICAL INCIDENT

Trinta e sete pessoas entraram na conferência.

— É COBOL?

— Não.

— É CICS?

— Não.

— Db2?

— Normal.

— MQ?

— Algumas filas estão crescendo.

— CPU?

— 43%.

— WLM?

— Dentro da política.

— Storage?

— Normal.

Finalmente alguém perguntou:

— E o fogo?

Silêncio.

Ninguém da reunião pertencia à equipe responsável pelo fogo.

Foi necessário abrir um chamado.

INC00473192

A equipe respondeu:

FIRE SYSTEM OPERATING AS DESIGNED.

O incidente foi encerrado como:

ROOT CAUSE UNKNOWN.



🐷 CRIA-SE A ENGENHARIA DE PORCOS

A direção decidiu que aquilo jamais poderia acontecer novamente.

Foi criado o departamento de:

Enterprise Pig Roasting Architecture — EPRA.

O departamento estabeleceu padrões.

Agora cada porco precisava possuir:

  • PIG-ID;

  • peso;

  • idade;

  • raça;

  • temperatura inicial;

  • floresta de destino;

  • horário de entrada;

  • previsão de cozimento;

  • classificação de criticidade.

Foi criado um banco Db2.

TB_PORCO
TB_FLORESTA
TB_INCENDIO
TB_ASSAMENTO
TB_TEMPERATURA
TB_PORCO_FLORESTA

Um arquiteto observou que TB_PORCO_FLORESTA possuía uma relação N:N problemática.

Foram necessárias seis reuniões.

Enquanto isso, os porcos continuavam queimando.


📊 OBSERVABILIDADE

Alguém afirmou:

— O problema é falta de observabilidade.

Todos concordaram.

Foram instalados sensores.

Dashboards.

Métricas.

Logs.

Tracing.

Alertas.

Agora era possível saber em tempo real:

PIGS_PER_SECOND

MEAN_TIME_TO_ROAST

FOREST_BURN_RATE

AVERAGE_PIG_TEMPERATURE

PIG_ERROR_RATE

CARBONIZED_PIG_PERCENTAGE

Um enorme monitor foi colocado no NOC.

Quando um porco queimava demais, uma linha ficava vermelha.

Os executivos ficaram impressionados.

— Agora temos visibilidade!

Os porcos continuavam queimando.

Mas agora isso podia ser acompanhado num dashboard.


☁️ A MODERNIZAÇÃO

Chegou então um consultor.

Depois de analisar a arquitetura durante três semanas, apresentou 186 slides.

O primeiro dizia:

DIGITAL PIG TRANSFORMATION

A conclusão era clara:

o problema estava no legado.

Era necessário modernizar.

O COBOL PORC001 foi encapsulado por uma API REST.

Agora era possível incendiar a floresta utilizando:

POST /api/v1/pigs/roast

Payload:

{
  "pigId": "0004711",
  "forest": "F023",
  "roastingLevel": "MEDIUM"
}

A API chamava z/OS Connect.

Que chamava CICS.

Que chamava COBOL.

Que gravava Db2.

Que publicava MQ.

Que finalmente executava:

INCENDIAR FLORESTA.

O CIO apresentou o projeto numa conferência:

“Transformamos nosso processo tradicional de produção de alimentos em uma plataforma API-first.”

Todos aplaudiram.

Os porcos continuavam sendo assados incendiando florestas.


☁️🐷 PORCOS NA CLOUD

Um novo estudo concluiu que o problema era outro.

A floresta estava on-premises.

Foi criado então:

Hybrid Cloud Pig Roasting Architecture.

O cadastro dos porcos foi para a cloud.

O sistema de incêndio permaneceu no mainframe.

Kafka transmitia eventos:

PIG_ENTERED_FOREST

FOREST_IGNITED

PIG_TEMPERATURE_CHANGED

PIG_ROASTED

PIG_OVERCOOKED

Um Data Lake armazenava vinte anos de telemetria de porcos queimados.

Machine Learning começou a prever quais porcos provavelmente seriam carbonizados.

A precisão chegou a 94%.

Um executivo perguntou:

— E conseguimos evitar que eles queimem?

O cientista de dados respondeu:

— Ainda não. Mas conseguimos prever com excelente precisão quais irão queimar.

O projeto recebeu um prêmio de inovação.


🤖 CHEGA A INTELIGÊNCIA ARTIFICIAL

Em 2026 surgiu a grande esperança.

IA Generativa.

Foi criado:

PigGPT Enterprise Edition.

A IA recebeu documentação, runbooks, logs, dumps, métricas SMF e quarenta anos de incidentes.

Perguntaram:

— Como melhorar o sistema de assar porcos?

A IA respondeu:

“Talvez seja possível assar os porcos diretamente utilizando uma fonte controlada de calor, sem incendiar uma floresta inteira.”

A resposta foi classificada como:

LOW CONFIDENCE / REQUIRES HUMAN VALIDATION

Um comitê de governança de IA foi convocado.

Após oito reuniões decidiu-se que a sugestão representava risco arquitetural porque não respeitava o processo corporativo estabelecido.


👨‍💻 JOÃO BOM-SENSO ENTRA NO CPD

Foi então que apareceu João.

João era programador COBOL.

Não era Distinguished Engineer.

Não era Enterprise Architect.

Não possuía certificação em transformação digital de porcos.

Ele estava apenas acompanhando um incidente.

Olhou os diagramas.

Olhou os jobs.

Olhou os dashboards.

Olhou os milhares de linhas COBOL.

Olhou Kafka.

Olhou MQ.

Olhou Kubernetes.

Olhou o Data Lake.

Depois perguntou:

— Por que vocês incendeiam uma floresta inteira?

A sala ficou silenciosa.

Um arquiteto respondeu:

— Para assar os porcos.

— Sim. Mas por que não fazemos uma pequena fogueira e colocamos o porco sobre ela?

Silêncio.

Alguém desligou o microfone.

Outro escreveu no chat privado:

“Quem convidou esse cara?”


🧪 A PROVA DE CONCEITO

João pegou um porco.

Algumas brasas.

Uma grelha.

Esperou.

O porco ficou perfeitamente assado.

Nenhuma floresta foi incendiada.

Nenhum batch foi executado.

Nenhuma mensagem MQ.

Nenhuma chamada REST.

Nenhum evento Kafka.

Nenhum Data Lake.

Nenhum SEV1.

Custo operacional:

quase zero.

O resultado foi apresentado à direção.

Por alguns segundos João acreditou que seria promovido.

Então começaram as perguntas.

— E o departamento de Engenharia de Incêndios?

— Não precisaria mais existir dessa forma.

— E nossos especialistas certificados em Propagação Florestal?

— Também não.

— E os 312 jobs?

— Poderíamos desativá-los.

— E nosso contrato de observabilidade?

— Grande parte deixaria de ser necessária.

— E o Data Lake?

— Continuaria existindo para outras coisas.

— E os vinte anos de dados históricos de incêndios?

— Seriam históricos.

— E nossa API?

— Provavelmente desnecessária para isso.

— E Kafka?

— Para assar um porco?

João começou a perceber o problema.

Ele não estava propondo apenas uma grelha.

Estava propondo destruir um ecossistema.


🏢 O SISTEMA NÃO ERA MAIS O SISTEMA

Durante cinquenta anos a empresa construíra organizações inteiras ao redor do método de incendiar florestas.

Existiam:

engenheiros de incêndio;

analistas de capacidade de incêndio;

DBAs especializados em tabelas de porcos;

operadores de batch;

especialistas em temperatura;

arquitetos de integração;

consultores;

auditores;

fornecedores;

contratos;

KPIs;

SLAs;

certificações;

procedimentos;

comitês;

diretorias.

O objetivo original havia sido:

assar porcos.

Mas lentamente o objetivo transformara-se em:

operar eficientemente o Sistema Corporativo de Incêndio de Florestas.

Essa diferença parecia pequena.

Não era.

Era gigantesca.


🧠 O DIRETOR EXPLICA A REALIDADE

O diretor chamou João.

— Sua ideia é interessante.

João sorriu.

— Obrigado.

— Mas você não compreende toda a complexidade.

João parou de sorrir.

O diretor mostrou o organograma.

Centenas de pessoas dependiam daquele processo.

Havia contratos plurianuais.

Depreciação de ativos.

Compliance.

Auditoria.

Treinamentos.

Orçamento.

Fornecedores.

Roadmaps.

Projetos estratégicos.

— Você está olhando apenas para o problema técnico — explicou o diretor.

João respondeu:

— Eu estou olhando para o porco.

O diretor respirou fundo.

— Exatamente. Esse é o problema.


🐷 O PORCO ESQUECIDO

Naquela noite João caminhou pelo Data Center.

Passou pelos enormes computadores.

Viu os painéis.

Os dashboards.

As luzes.

Os gráficos.

Tudo extraordinariamente sofisticado.

Então percebeu algo.

A organização sabia medir praticamente tudo.

Sabia quantas árvores queimavam.

Quanto combustível utilizava.

Quanto tempo levava.

Quantos processadores consumia.

Quantas mensagens trafegavam.

Quantos incidentes aconteciam.

Quanto custava cada floresta.

Mas havia uma pergunta que quase ninguém fazia:

“Ainda precisamos fazer isso dessa maneira?”

Essa pergunta não aparecia no SMF.

Não estava no RMF.

Não aparecia no Splunk.

Não existia no Grafana.

Não estava no Jira.

Não havia campo para ela no ServiceNow.

Porque nenhum sistema de observabilidade consegue detectar sozinho que o próprio processo observado deixou de fazer sentido.


☕ EPÍLOGO — O VERDADEIRO LEGADO

E aqui está a armadilha.

Legado não é COBOL.

Legado não é mainframe.

Legado não é VSAM.

Legado não é CICS.

Um programa COBOL com cinquenta anos que executa perfeitamente uma função necessária pode ser uma extraordinária peça de engenharia.

Enquanto isso, um microsserviço escrito ontem pode nascer legado se automatizar brilhantemente uma coisa que ninguém deveria continuar fazendo.

Modernização verdadeira não significa trocar:

COBOL → Java

ou:

MAINFRAME → CLOUD

ou:

BATCH → KAFKA

A pergunta anterior é muito mais importante:

POR QUE ESTE PROCESSO EXISTE?

Depois:

QUAL PROBLEMA ELE RESOLVE?

Depois:

AINDA PRECISAMOS RESOLVÊ-LO?

E somente então:

QUAL É A MELHOR TECNOLOGIA?

Porque você pode colocar uma API REST na frente do incêndio.

Pode publicar o incêndio no Kafka.

Pode executar o controle do incêndio em containers.

Pode armazenar os incêndios num Data Lake.

Pode usar IA para prever incêndios.

Pode criar dashboards espetaculares mostrando incêndios em tempo real.

E pode chamar tudo isso de transformação digital.

Mas...

se para conseguir um simples porco assado você ainda precisa incendiar uma floresta inteira,

talvez o problema nunca tenha sido o COBOL.

Talvez o problema seja que, em algum momento dos últimos cinquenta anos,

todo mundo começou a cuidar do SISTEMA e ninguém mais perguntou pelo porco.


🥚 EASTER EGG DO OPERADOR

Dizem que até hoje, exatamente às 03:17, existe um job desconhecido no scheduler:

JOB PORK999

Ninguém sabe quem o criou.

Ele executa apenas:

IF FLORESTA-EM-CHAMAS
    DISPLAY 'MAS POR QUE?'
END-IF.

O programa possui somente um comentário:

*> J.BOM-SENSO - NAO REMOVER.

Ninguém remove.

Afinal...

é legado.

Inspirado em fabula dos porcos Juício a La Escuela Cirigliano, Forcade Tilich Editorial Editorial Humanitas – Buenos Aires, 1974

sábado, 5 de setembro de 2026

IBM Bob Entra no CPD — O Dia em que o Programador COBOL Parou de Pedir Código e Começou a Comandar Agentes

 

Bellacosa Mainframe e o ibm bob chegando no cpd

☕ Um Café no Bellacosa Mainframe

IBM Bob Entra no CPD — O Dia em que o Programador COBOL Parou de Pedir Código e Começou a Comandar Agentes

Ou: por que “eu uso IA para programar” já vale quase o mesmo que dizer “sei usar Google”, como ASK, PLAN e AGENT mudam a engenharia de software, por que um agente merece menos privilégios que um estagiário com RACF SPECIAL e como o COBOL pode ensinar uma lição ao futuro da programação




Prólogo — Bob chegou ao CPD e pediu acesso ao código

Imagine a cena.

São 22h37.

O CPD está silencioso.

O café já foi requentado duas vezes.

No canto da sala existe um programa COBOL chamado:

PAYR001

Ele tem 18 mil linhas.

Foi criado quando alguém ainda dizia:

“Internet? Isso aí não vai pegar.”

Ninguém sabe exatamente tudo o que o programa faz.

O analista que escreveu a primeira versão se aposentou.

O sujeito que conhecia metade das regras de negócio abriu uma pousada em Ubatuba.

O último programador que tentou “modernizar rapidinho” deixou três comentários no fonte:

      * NAO MEXER AQUI
      * NAO SEI PQ FUNCIONA
      * MAS FUNCIONA

Então entra Bob.

Não o operador Bob.

Não o Bob da contabilidade.

IBM Bob, o parceiro de desenvolvimento baseado em inteligência artificial.

Bob olha para PAYR001.

O programador COBOL iniciante olha para Bob.

E comete o primeiro pecado da programação assistida por inteligência artificial:

“Bob, modernize isso.”

Nesse instante, em algum lugar do universo, um sysprog derruba uma caneca de café.

Porque o problema da IA em desenvolvimento de software nunca foi apenas:

Ela consegue escrever código?

A pergunta correta é:

Você sabe o que está autorizando a IA a fazer?

Bem-vindo à próxima etapa da programação.



1. “Eu uso IA para programar” deixou de impressionar

Há alguns anos, colocar no currículo:

Experiência com inteligência artificial aplicada ao desenvolvimento.

podia chamar atenção.

Depois vieram ChatGPT, GitHub Copilot, CodeWhisperer, Claude, Gemini, IBM Bob e uma coleção cada vez maior de ferramentas.

Hoje é comum um desenvolvedor digitar:

crie uma função

e receber uma função.

Depois:

crie os testes

e receber testes.

Depois:

documente

e receber documentação.

Isso continua sendo útil.

Mas deixou de ser extraordinário.

É parecido com escrever no currículo:

“Sei pesquisar no Google.”

Parabéns.

Em 2001 talvez fosse diferencial.

Em 2026 é parte do trabalho.

O que começa a separar profissionais é outra coisa:

o que você consegue fazer com a IA depois que ela deixa de ser uma simples máquina de completar código?





2. O iniciante costuma confundir programação com digitação de programa

Essa confusão já existia muito antes da inteligência artificial.

Veja este COBOL:

       IF WS-SALDO > 0
           MOVE 'ATIVO' TO WS-STATUS
       ELSE
           MOVE 'INATIVO' TO WS-STATUS
       END-IF.

Um iniciante pode aprender essa sintaxe rapidamente.

Isso significa que ele entende o sistema?

Não.

Talvez WS-SALDO represente:

  • saldo contábil;

  • saldo disponível;

  • saldo bloqueado;

  • saldo devedor;

  • posição intraday;

  • um campo legado chamado saldo que na prática representa outra coisa.

O problema empresarial não mora na palavra MOVE.

Ele mora no significado.

Esse é um dos primeiros ensinamentos que o mainframe oferece para a era da IA:

Código é representação. Negócio é contexto.

IA ficou extraordinariamente boa na primeira parte.

A segunda continua sendo muito mais complicada.


3. O código está deixando de ser o gargalo

Durante décadas, escrever software era caro.

Você precisava transformar uma ideia em milhares de instruções.

Então nasceram linguagens de alto nível.

Depois bibliotecas.

Frameworks.

IDEs.

Stack Overflow.

Geradores.

Low-code.

E finalmente grandes modelos de linguagem.

Agora imagine que produzir código fique dez vezes mais rápido.

Excelente.

Mas surge um efeito curioso.

Antes:

REQUISITO
   ↓
ANÁLISE
   ↓
CODIFICAÇÃO     ← lento
   ↓
REVISÃO
   ↓
TESTE
   ↓
HOMOLOGAÇÃO
   ↓
PRODUÇÃO

Depois da IA:

REQUISITO
   ↓
ANÁLISE
   ↓
IA
   ↓
████████████████████
REVISÃO
TESTES
SEGURANÇA
VALIDAÇÃO
████████████████████
   ↓
PRODUÇÃO

Você não eliminou necessariamente o gargalo.

Você mudou o gargalo de lugar.

A própria documentação e comunicação recente em torno do IBM Bob refletem essa mudança de foco: Bob trabalha hoje com modos específicos para perguntar, planejar e executar, além de ferramentas, subagentes, MCP e integrações além da simples geração de texto.

Quanto mais código conseguimos produzir automaticamente, mais importante passa a ser responder:

Isto está correto?

Isto deveria existir?

Isto viola alguma regra?

Isto quebra quem?

Isto pode ir para produção?

A IA acelera a construção.

Mas alguém ainda precisa saber o que merece ser construído.



4. Conheça os três estados mentais: ASK, PLAN e AGENT

Aqui aparece uma das ideias mais educativas do IBM Bob.

Os modos nativos atuais distinguem três comportamentos fundamentais:

ASK
PLAN
AGENT

Não pense nisso apenas como botões de interface.

Pense como três níveis diferentes de relacionamento entre você e um agente.

A documentação do Bob define Ask como apropriado para explicações e análise sem modificações; Plan para investigar e elaborar estratégias antes da implementação; e Agent para tarefas que envolvem modificar código, executar comandos e implementar mudanças.

Isso deveria estar pregado na parede de todo CPD:

ENTENDER
ANTES DE
PLANEJAR

PLANEJAR
ANTES DE
ALTERAR


5. ASK — “Bob, explique essa tranqueira antes que alguém mexa nela”

Imagine que você recebeu:

PAYR001

Você não sabe o que faz.

O comportamento errado seria:

Refatore esse programa.

O comportamento inteligente começa com investigação:

Analise PAYR001.

Identifique:

- arquivos utilizados;
- copybooks;
- chamadas CALL;
- tabelas Db2;
- recursos CICS;
- acessos VSAM;
- códigos de retorno;
- possíveis dependências;
- pontos que parecem representar regras de negócio.

Não modifique nenhum arquivo.

Perceba a última frase:

Não modifique nenhum arquivo.

Essa frase vale ouro.

Estamos usando IA como analista, não como cirurgião.

Ela pode responder:

PAYR001
 |
 +-- COPY EMPREG
 |
 +-- COPY TAXAS
 |
 +-- DB2 EMPLOYEE
 |
 +-- CALL TAXCALC
 |
 +-- VSAM FUNCION
 |
 +-- CICS LINK PAYR020

Agora você começou a construir um mapa.

Esse é o papel ideal do Ask.



6. Easter egg nº 1 — Sherlock Holmes deveria ter trabalhado com legado

Uma grande parte da manutenção de sistemas antigos é investigação.

Você encontra:

       MOVE 17 TO WS-TIPO-CALCULO.

Por quê 17?

Ninguém sabe.

Você pesquisa o programa.

Depois o copybook.

Depois o JCL.

Depois uma tabela.

Depois encontra uma documentação de 1998.

E finalmente descobre:

Tipo 17 = cálculo especial utilizado durante fechamento de fevereiro.

Isso não é programação.

Isso é arqueologia industrial.

Bob pode ser um excelente Watson.

Mas ainda precisamos de Sherlock para perguntar:

“Por que fevereiro?”



7. PLAN — o momento mais importante ocorre antes da primeira alteração

Agora suponha que nossa missão seja mudar uma regra de juros.

Não diga:

Faça.

Peça:

Planeje a alteração necessária para modificar
a regra de juros do produto X.

Antes de qualquer implementação:

1. identifique os módulos afetados;
2. liste dependências;
3. identifique copybooks envolvidos;
4. localize testes existentes;
5. identifique possíveis impactos externos;
6. proponha uma estratégia;
7. liste riscos;
8. defina critérios de aceitação.

Bob pode retornar:

PLANO

1. Modificar CALCJURO.cbl
2. Alterar TAXAS.cpy
3. Revisar tabela DB2 TAXA_JUROS
4. Atualizar teste TC019
5. Executar regressão
6. Validar PAYR001 e PAYR020

O iniciante diz:

“Parece ótimo!”

O veterano grita do fundo do CPD:

“NÃO MEXE NO TAXAS.CPY!”

Por quê?

Porque o veterano sabe que aquele copybook é utilizado por 47 programas.

A IA talvez tenha identificado somente 13.

Ou talvez nem tenha acesso a todos os repositórios.

Esse momento é crucial.

Você responde:

Plano rejeitado parcialmente.

TAXAS.CPY é compartilhado por outros sistemas.

Não alterar o copybook.

Proponha uma solução local mantendo a interface atual.

Pronto.

A inteligência mais importante dessa interação talvez não tenha sido a inteligência artificial.

Foi o julgamento humano.



8. Eis o verdadeiro superpoder do profissional experiente

Muito se fala que IA diminuirá a importância da experiência.

Em sistemas empresariais antigos pode ocorrer justamente o contrário.

Porque um sistema legado é:

código
+
dados
+
procedimentos
+
infraestrutura
+
interfaces
+
regras empresariais
+
exceções
+
história
+
conhecimento tribal

IA pode ler muito código.

Mas talvez não saiba que:

“Esse job nunca deve rodar antes do fechamento da filial argentina.”

Talvez isso não esteja documentado.

Talvez esteja apenas na cabeça de alguém chamado Carlos.

Carlos trabalha ali desde 1994.

Todos chamam aquilo de:

REGRA DO CARLOS

Nenhum compilador conhece.

Nenhum modelo conhece.

Carlos conhece.

Esse tipo de contexto será extremamente valioso.



9. AGENT — agora Bob recebe a caixa de ferramentas

Depois que o plano foi investigado e aprovado, chegamos ao modo Agent.

Aqui as coisas ficam sérias.

Bob pode trabalhar com operações de leitura, edição, execução de comandos e ferramentas conectadas.

A relação passa de:

Humano pergunta
IA responde

para:

Humano define objetivo
      ↓
Agente investiga
      ↓
Agente modifica
      ↓
Agente executa
      ↓
Agente testa
      ↓
Humano revisa

Essa é uma mudança gigantesca.

Porque agora a IA não está apenas falando sobre o sistema.

Ela está fazendo coisas no sistema.



10. Programador, conheça uma palavra importante: autoridade

Considere dois agentes.

Agente A

Pode apenas ler arquivos.

Risco:

baixo

Agente B

Pode:

ler arquivos
editar arquivos
executar shell
chamar APIs
consultar serviços
abrir pull request
alterar configuração

Risco:

hmmmm...

Agora imagine:

Agente C

Pode:

acessar produção
alterar banco
ler secrets
fazer deploy
aprovar merge

O operador do mainframe desmaia.

É exatamente aqui que décadas de experiência em controle de acesso voltam a ficar modernas.


11. RACF encontra inteligência artificial

O mainframeiro olha para essa discussão e pergunta:

“Vocês descobriram autorização agora?”

🤣

No mundo z/OS aprendemos há décadas a perguntar:

QUEM É VOCÊ?
        ↓
O QUE VOCÊ PODE ACESSAR?
        ↓
PODE APENAS LER?
        ↓
PODE ALTERAR?
        ↓
PODE EXECUTAR?
        ↓
QUEM CONCEDEU?
        ↓
EXISTE LOG?

Agora substitua usuário por agente:

QUAL AGENTE?
        ↓
QUAIS FERRAMENTAS?
        ↓
QUAIS ARQUIVOS?
        ↓
QUAIS SERVIDORES MCP?
        ↓
PODE EXECUTAR COMANDOS?
        ↓
PODE ALTERAR REPOSITÓRIO?
        ↓
PODE PUBLICAR?
        ↓
QUEM APROVA?

O futuro da IA empresarial parece surpreendentemente parecido com uma conversa que um administrador RACF teria em 1995.

Easter egg:

Não dê SPECIAL para Bob.

Ele é gente boa.

Mas ninguém merece SPECIAL.


12. Least privilege — trate a IA como trataria qualquer outro ator do sistema

Uma arquitetura saudável poderia permitir:

Bob pode:

[X] ler código
[X] criar branch
[X] alterar branch de trabalho
[X] executar testes
[X] gerar documentação
[X] criar Pull Request

Bob não pode:

[ ] merge direto em main
[ ] acessar senha de produção
[ ] modificar tabela produtiva
[ ] fazer deployment produtivo
[ ] desligar JES2 porque "pareceu uma boa ideia"

Esse modelo é chamado de princípio do menor privilégio.

Não dê uma permissão porque o agente pode eventualmente precisar.

Dê somente aquilo que é necessário para a tarefa atual.


13. Human-in-the-loop — existe um humano entre a ideia e o estrago

Um fluxo simples:

IA propõe
    ↓
HUMANO REVISA
    ↓
IA EXECUTA
    ↓
HUMANO VALIDA

Esse é um modelo conhecido como:

Human in the Loop

O ser humano participa diretamente dos checkpoints.

Depois de ganhar maturidade, certas tarefas podem usar algo semelhante a:

Human on the Loop

O agente executa atividades dentro de limites predeterminados e o humano supervisiona.

Por exemplo:

Bob:
    criar teste             SIM
    rodar teste             SIM
    corrigir branch         SIM
    abrir PR                SIM
    merge em produção       NÃO

Não precisamos escolher entre:

humano faz tudo

e

robô faz tudo.

Existe uma enorme região intermediária.

É ali que provavelmente estará grande parte da engenharia empresarial dos próximos anos.


14. Subagents — quando Bob monta sua própria equipe

Agora nossa história fica ainda mais interessante.

Bob pode utilizar subagents, agentes independentes que executam tarefas focadas em janelas de contexto isoladas e devolvem um resumo ao agente principal. A documentação atual distingue inclusive subagentes explore, orientados à exploração somente-leitura, e general, capazes de usar ferramentas mais amplas. O usuário aprova a criação antes da execução.

Imagine:

                BOB
                 |
     +-----------+-----------+
     |           |           |
  AGENTE      AGENTE      AGENTE
   COBOL        DB2         TESTE
     |           |           |
 PAYR001       SQL       REGRESSÃO

O agente COBOL analisa dependências.

O agente Db2 investiga consultas.

O agente de testes verifica cobertura.

Todos retornam resumos.

Bob junta as peças.

Isso começa a parecer menos com:

“assistente de programação”

e mais com:

“equipe técnica virtual”.


15. Mas subagent não é Pokémon

Existe uma tentação:

Bob, crie 27 agentes.

Não.

Mais agentes não significam automaticamente resultado melhor.

Cada agente:

  • consome contexto;

  • executa ferramentas;

  • pode interpretar algo incorretamente;

  • aumenta custo;

  • aumenta coordenação.

O próprio Bob procura usar subagentes quando o trabalho é realmente autocontido e quando separar o contexto faz sentido, em vez de lançar agentes indiscriminadamente para qualquer leitura simples.

Regra Bellacosa:

Se uma tarefa exige dois minutos, não convoque os Vingadores.


16. MCP — Bob encontrou tomadas no CPD

Outra sigla importante:

MCP

Model Context Protocol.

De forma simplificada, MCP permite que um agente trabalhe com ferramentas e fontes externas através de uma interface padronizada.

Antes:

LLM
 |
 conversa

Depois:

              BOB
               |
              MCP
       +-------+-------+
       |       |       |
      Git     API    Sistema
       |       |       |
      Jira   Docs    Ferramentas

A documentação do Bob apresenta MCP justamente como mecanismo para estender o agente com ferramentas externas e integrações personalizadas.

Essa é uma mudança fundamental.

Porque um chatbot só poderia dizer:

“Você deveria abrir um ticket.”

Um agente conectado talvez possa:

abrir o ticket

A diferença entre conselho e ação é enorme.


17. Bob Shell — quando o polvo sai do editor

Em agosto de 2026, a IBM colocou o agente V2 também no Bob Shell, levando a arquitetura compartilhada do Bob para o terminal. A atualização também trouxe mudanças no Bobalytics, IDE e gerenciamento relacionado a MCP e revisão de edições.

Para um programador isso significa algo importante.

Antes:

IDE
 |
assistente

Agora podemos imaginar:

TERMINAL
   |
 Bob Shell
   |
   +-- build
   +-- test
   +-- git
   +-- scripts
   +-- ferramentas

E quem trabalha com mainframe sabe uma coisa:

quando algo chega ao terminal, começa a entrar no território da automação.


18. O futuro não é prompt engineering

Durante algum tempo todo mundo falava:

PROMPT ENGINEERING

Como se a habilidade definitiva fosse descobrir a frase mágica.

Algo parecido com:

“Escreva um programa extraordinário, pense passo a passo, seja genial e não erre.”

Não.

A evolução real parece mais próxima de:

PROMPT
   ↓
CONTEXTO
   ↓
PLANO
   ↓
DELEGAÇÃO
   ↓
EXECUÇÃO
   ↓
VALIDAÇÃO
   ↓
GOVERNANÇA
   ↓
OBSERVABILIDADE
   ↓
MÉTRICA

A habilidade passa de:

saber conversar com IA

para:

saber operar IA dentro de um processo de engenharia.


19. O portfólio do iniciante também precisa mudar

Imagine dois candidatos.

Candidato 1

GitHub:

CRUD de clientes
Clone do Netflix
Lista de tarefas
Calculadora

Tudo produzido parcialmente com IA.

Legal.

Agora candidato 2 cria:

cobol-modernization-lab/
 |
 +-- README.md
 +-- docs/
 |    +-- architecture.md
 |    +-- decisions.md
 |    +-- risks.md
 |
 +-- prompts/
 |    +-- analysis.md
 |    +-- plan.md
 |
 +-- src/
 |
 +-- tests/
 |
 +-- lessons-learned.md

No README:

Problema
↓
Análise inicial
↓
Plano sugerido pelo agente
↓
Plano revisado
↓
Decisões rejeitadas
↓
Implementação
↓
Testes
↓
Resultado

Quem você acha que dará mais assunto numa entrevista?


20. A melhor seção do README talvez seja: “onde Bob errou”

Sim.

Você leu corretamente.

Imagine:

## AI Recommendation Rejected

Bob sugeriu modificar COPY TAXAS.

A recomendação foi rejeitada porque o copybook
é compartilhado por múltiplas aplicações.

Decisão humana:

manter interface pública e implementar adaptação
local no programa CALCJURO.

Isso é maravilhoso.

Porque demonstra:

IA sugeriu
        ↓
VOCÊ ENTENDEU
        ↓
VOCÊ DISCORDOU
        ↓
VOCÊ EXPLICOU
        ↓
VOCÊ DECIDIU

A competência não está em aceitar a IA.

Está em saber quando não aceitar.


21. Uma entrevista técnica do futuro

Recrutador:

Você utiliza agentes de IA?

Candidato:

Sim.

Recrutador:

Conte uma decisão do agente que você rejeitou.

Silêncio.

O candidato que simplesmente gerava código morreu na praia.

Já outro responde:

O agente sugeriu alterar um contrato compartilhado. Analisei dependências, percebi risco de quebra em consumidores externos, rejeitei a solução e implementei um adapter preservando compatibilidade.

Pronto.

Temos uma conversa de engenharia.


22. O programador COBOL tem uma vantagem inesperada

COBOL ensina algo precioso:

software não existe isoladamente

Um programa está conectado a:

JCL
copybooks
VSAM
Db2
CICS
IMS
MQ
jobs
arquivos
procedimentos
controle
segurança
scheduler
processos empresariais

Por isso manutenção mainframe raramente permite a fantasia:

“Vou apenas reescrever esse módulo.”

Esse módulo talvez seja chamado às 03h17 por um job que ninguém mencionou.

Pode alimentar um arquivo que vai para outro banco.

Pode produzir uma saída utilizada por um sistema que pertence a outra diretoria.

Em sistemas corporativos:

dependência é a criatura que mora atrás da porta que ninguém abriu.


23. Passo a passo Bellacosa para usar um agente em COBOL

Vamos montar um procedimento.

Etapa 1 — Entender

Use Ask:

Explique este programa COBOL.

Mapeie:
- divisions;
- paragraphs;
- copybooks;
- CALLs;
- arquivos;
- SQL;
- CICS;
- códigos de retorno.

Não altere nada.

Etapa 2 — Mapear dependências

Pergunte:

Quais componentes externos podem ser afetados
por uma modificação neste módulo?

Não confie cegamente.

Confirme no repositório e nas ferramentas existentes.


Etapa 3 — Criar plano

Crie um plano para implementar a mudança X.

Inclua:
- arquivos afetados;
- risco;
- rollback;
- testes;
- dependências;
- critérios de sucesso.

Não implemente ainda.

Etapa 4 — Revisar manualmente

Leia tudo.

Pergunte:

Isso realmente faz sentido?

Se não entende algum item, não aprove.

Peça explicação.


Etapa 5 — Limitar escopo

Em vez de:

modernize o sistema

prefira:

altere somente o módulo CALCJURO
sem modificar interfaces públicas
nem copybooks compartilhados.

Etapa 6 — Executar

Agora sim:

Implemente o plano aprovado.

Etapa 7 — Testar

Nunca aceite:

“Parece correto.”

Use:

Compile.
Execute testes.
Analise return codes.
Compare resultados.

Em COBOL:

COMPILOU

não significa:

FUNCIONOU

e:

FUNCIONOU

não significa:

ESTÁ CORRETO

Etapa 8 — Revisar o diff

Pergunte:

O que mudou?
Por que mudou?
Quais comportamentos podem ser afetados?

Depois olhe você mesmo.


Etapa 9 — Documentar

Registre:

o que a IA sugeriu
o que foi aceito
o que foi rejeitado
por quê
quais testes foram realizados

Isso cria auditoria e aprendizado.


24. Nunca terceirize compreensão

Existe um anti-pattern perigoso:

não entendo
  ↓
pergunto IA
  ↓
IA responde
  ↓
continuo não entendendo
  ↓
mas executo mesmo assim

Isso é apenas terceirização da ignorância.

🤣

O fluxo correto:

não entendo
   ↓
IA explica
   ↓
pergunto novamente
   ↓
verifico
   ↓
entendo suficientemente
   ↓
decido

IA deveria diminuir sua ignorância.

Não escondê-la.


25. Curiosidade — COBOL já viveu uma revolução parecida

Nos anos 1950, programar significava trabalhar muito mais perto da máquina.

Linguagens de alto nível eram uma abstração revolucionária.

Algum programador Assembly poderia olhar COBOL e dizer:

“Agora qualquer incompetente escreve programa!”

Talvez dissesse:

“Esses jovens nem sabem registrador!”

Décadas depois acontece algo curioso.

Programadores modernos dizem:

“Com IA qualquer pessoa gera programa!”

A história gosta de rir.

Compiladores automatizaram a transformação:

linguagem humana-ish
        ↓
código de máquina

IA automatiza outra camada:

intenção humana
        ↓
representação técnica

Mas abstração nunca eliminou necessidade de engenharia.

Ela apenas permitiu construir sistemas maiores.


26. Quanto maior a abstração, maior o raio da explosão

Em Assembly, você poderia errar uma instrução.

Com COBOL, uma regra errada poderia afetar milhões de registros.

Com um pipeline automatizado, uma alteração pode chegar a centenas de servidores.

Com agentes:

UM OBJETIVO MAL DEFINIDO
          ↓
MÚLTIPLAS ALTERAÇÕES
          ↓
TESTES
          ↓
AUTOMAÇÃO
          ↓
PR

Velocidade amplifica coisas boas.

E coisas ruins.

Por isso:

AUTONOMIA ↑
=
GUARDRAILS ↑

27. Guardrail é a cerca elétrica em volta do robô

Guardrail é qualquer mecanismo que limita comportamento.

Exemplos:

não editar produção
não acessar determinados diretórios
não executar determinados comandos
não enviar dados sensíveis
não modificar secrets
não publicar automaticamente
exigir aprovação

Pense em uma locomotiva.

Ela é extremamente poderosa.

Mas só é útil porque existe trilho.

Um agente sem trilho não é uma locomotiva.

É um trem atravessando o estacionamento.


28. E finalmente chegamos às métricas

Depois que uma empresa compra IA para centenas de desenvolvedores, aparece o gerente financeiro.

Ele não pergunta:

“Bob é legal?”

Ele pergunta:

“Quanto custou?”

Depois:

“Quanto economizou?”

Depois:

“Como você sabe?”

E aqui começa a parte adulta.

Não basta medir:

linhas de código

Linhas de código são uma métrica terrível.

Você pode produzir 200 mil linhas de lixo.

Melhores indicadores incluem:

Lead Time
Cycle Time
Defect Rate
Change Failure Rate
MTTR
Test Coverage
Rework
Deployment Frequency
Tempo economizado
Custo por mudança

As versões atuais do ecossistema Bob incluem Bobalytics justamente como uma camada de visibilidade sobre uso e atividade; a atualização de agosto de 2026 adicionou novas visões para observar atividade diária e padrões de utilização.


29. Bobalytics encontra SMF no boteco

O mainframeiro vê analytics e novamente começa a rir.

Porque estamos acostumados com a pergunta:

“O que aconteceu?”

E alguém responde:

“Vamos olhar os registros.”

SMF.

RMF.

Logs.

Auditoria.

Accounting.

Histórico.

Agora o mesmo princípio chega à IA:

Quem utilizou?
Quanto utilizou?
Para quê?
Qual resultado?
Quanto custou?
Qual foi a produtividade?

No futuro talvez ninguém aceite:

“A IA ajudou bastante.”

Precisaremos dizer:

antes: 12 horas
depois: 5 horas

antes: 8 defeitos
depois: 3 defeitos

custo de IA: X
tempo preservado: Y

Aí temos ROI.


30. Cuidado com a “produtividade placebo”

Existe um fenômeno interessante.

Desenvolvedor:

“Estou produzindo 70% mais rápido!”

Pergunta:

“Como você mediu?”

Resposta:

“Senti.”

🤣

Isso não é métrica.

É horóscopo corporativo.

Talvez a IA realmente tenha melhorado produtividade.

Mas precisamos separar:

sensação de velocidade

de:

resultado empresarial

31. O futuro do profissional técnico

A escada provavelmente será algo semelhante a:

NÍVEL 1
"uso autocomplete"

NÍVEL 2
"gero código"

NÍVEL 3
"forneço contexto"

NÍVEL 4
"planejo com agente"

NÍVEL 5
"delego tarefas"

NÍVEL 6
"coordeno subagents"

NÍVEL 7
"conecto ferramentas"

NÍVEL 8
"governo permissões"

NÍVEL 9
"meço resultado"

NÍVEL 10
"assumo responsabilidade"

O último é o mais importante.

Porque quando alguma coisa der errado ninguém aceitará:

“Mas Bob fez.”

A pergunta será:

“Quem aprovou?”


32. O easter egg escondido no SYSOUT

Depois de terminar a alteração, nosso programador encontra no relatório:

IEF142I JOB PAYROLL STEP01 - STEP WAS EXECUTED

Tudo parece normal.

Mais abaixo aparece:

BOB0001I ARTIFICIAL INTELLIGENCE COMPLETED TASK
BOB0002I HUMAN REVIEW REQUIRED

E finalmente:

BOB9999I CAFE REQUIRED BEFORE PRODUCTION

Esse último ainda não existe.

Mas deveria.


33. O iniciante não deve abandonar fundamentos por causa da IA

Se você está começando em COBOL, ainda precisa aprender:

IDENTIFICATION DIVISION
DATA DIVISION
PROCEDURE DIVISION

PIC
MOVE
IF
EVALUATE
PERFORM
CALL
FILE STATUS
COMP
COMP-3
COPYBOOKS
JCL
VSAM
DB2
CICS

Por quê?

Porque se Bob gerar:

       MOVE WS-AMOUNT TO WS-BALANCE

você precisa entender o que aconteceu.

Se ele sugerir redefinir:

       05 WS-AMOUNT PIC S9(9)V99 COMP-3.

você precisa saber por que isso pode importar.

A IA não elimina fundamentos.

Ela aumenta a penalidade de não conhecê-los.


34. A regra do mestre Jedi do mainframe

Use IA para chegar mais rápido à pergunta difícil.

Não para fugir dela.

Se você gastava três horas procurando onde determinada regra estava implementada e Bob encontra em três minutos:

fantástico.

Use as duas horas e cinquenta e sete minutos economizadas para descobrir:

“Essa regra ainda deveria existir?”

Isso é valor.


35. Programação está mudando de escrever para dirigir

Podemos representar a mudança assim:

ONTEM

Humano
  ↓
Código
  ↓
Computador

Hoje:

Humano
  ↓
IA
  ↓
Código
  ↓
Computador

Amanhã:

              HUMANO
                 |
        arquitetura / intenção
                 |
                 ↓
              AGENTE
        +--------+--------+
        |        |        |
     subagent subagent subagent
        |        |        |
      código   testes   análise
        \        |        /
             ferramentas
                 |
              sistemas

O humano sobe um nível.

Mas não desaparece.


36. Talvez “programador” volte ao significado original

Existe uma ironia bonita aqui.

Programar significa essencialmente:

estabelecer uma sequência de ações para atingir um objetivo.

Durante décadas transformamos “programador” em:

pessoa que digita código.

Agentes podem fazer com que o programador volte a ser mais literalmente alguém que:

define objetivos
decompõe tarefas
estabelece restrições
coordena execução
verifica resultado

Ou seja:

talvez IA não esteja destruindo o conceito de programador.

Talvez esteja obrigando a palavra a recuperar seu significado.


37. Checklist Bellacosa antes de deixar Bob trabalhar

Antes:

[ ] Entendo o problema?
[ ] Sei qual é o resultado esperado?
[ ] Identifiquei o escopo?
[ ] Mapeei dependências?
[ ] Pedi um plano?
[ ] Revisei o plano?
[ ] Defini o que NÃO pode ser alterado?

Durante:

[ ] Estou acompanhando as alterações?
[ ] O agente está dentro do escopo?
[ ] Surgiu nova dependência?
[ ] Existem decisões que exigem humano?

Depois:

[ ] Compilou?
[ ] Testou?
[ ] Comparei comportamento?
[ ] Revisei diff?
[ ] Avaliei segurança?
[ ] Documentei decisões?
[ ] Existe rollback?

Se a resposta para metade for:

¯\_(ツ)_/¯

não vá para produção.


38. Epílogo — Bob pergunta se pode fazer deploy

Voltamos ao nosso CPD.

23h58.

PAYR001 foi analisado.

O plano foi criado.

Uma alteração perigosa em TAXAS.CPY foi rejeitada.

Bob modificou o módulo correto.

Os testes passaram.

O programador revisou o diff.

Bob então pergunta:

“Deseja fazer deployment?”

O programador olha para o relógio.

Olha para Bob.

Olha para o calendário.

É sexta-feira.

Ele responde:

NÃO.

Bob pergunta:

“Por quê?”

E o jovem programador finalmente demonstra que aprendeu a mais importante regra da computação corporativa:

“Porque eu posso ser iniciante, Bob, mas não sou maluco.”

☕

Na segunda-feira faremos a mudança.

Com aprovação.

Com backup.

Com rollback.

Com logs.

E com alguém responsável olhando.

Porque o futuro da programação não será decidido por quem consegue produzir mais código.

Será decidido por quem consegue comandar máquinas cada vez mais capazes sem entregar a elas aquilo que nunca deveria ter sido terceirizado: julgamento, responsabilidade e compreensão do negócio.

IBM Bob pode ser copiloto.

Pode ser investigador.

Pode ser planejador.

Pode ser executor.

Pode convocar subagentes.

Pode usar ferramentas.

Pode trabalhar pelo terminal.

Pode atravessar o MCP e conversar com outros sistemas.

Mas alguém ainda precisa ocupar a cadeira do comandante.

E se você está começando agora em COBOL, existe uma oportunidade extraordinária diante de você:

não aprenda apenas a escrever programas.

Aprenda a entender sistemas.

Aprenda por que aquele MOVE existe.

Aprenda quem chama aquele programa.

Aprenda o que acontece quando o job termina com RC=08.

Aprenda por que segurança existe.

Aprenda por que produção exige respeito.

Aprenda a perguntar.

Aprenda a planejar.

Aprenda a discordar da inteligência artificial.

Porque talvez a habilidade técnica mais valiosa da próxima década não seja saber dizer para um agente:

“Faça.”

Será saber olhar para o plano produzido por ele, apoiar a caneca de café sobre a mesa e responder:

“Não, Bob. Essa parte você não vai mexer.”

E explicar exatamente por quê.

☕ Bem-vindo ao Bellacosa Mainframe.

Artigo DIO - Bellacosa Mainframe

☕ E se amanhã um agente de IA pedir acesso ao seu código COBOL?

Leia o artigo completo publicado na DIO sobre IBM Bob, inteligência artificial, COBOL, mainframe e o futuro da engenharia de software.

☕ Carregando o artigo...

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

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