Translate

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

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

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.

quarta-feira, 22 de julho de 2026

Voyage to the Bottom of the Legacy System : Quando um Programador COBOL Descobre que as Economias do Mundo Estão Guardadas no Fundo de um Oceano de Código

Bellacosa Mainframe apresenta uma viagem ao fundo dos sistemas legados onde o cobol é o protagonista

☕ Um Café no Bellacosa Mainframe

Voyage to the Bottom of the Legacy System

Quando um Programador COBOL Descobre que as Economias do Mundo Estão Guardadas no Fundo de um Oceano de Código — e Quase Ninguém Ainda Possui o Mapa

Há uma frase que deveria estar impressa na entrada de cada banco, seguradora, fundo de pensão, bolsa de valores e grande instituição financeira do planeta:

“Conheço exatamente cinco pessoas que entendem como as economias do mundo realmente funcionam. Quatro delas estão aposentadas.”

Isso parece uma piada.

Parece exagero de consultor.

Parece uma daquelas frases dramáticas usadas para vender projetos de modernização, inteligência artificial, transformação digital e mais uma tonelada de apresentações em PowerPoint com setas coloridas. Também conhecida por Buzzwords e incentivando o uso de Balas de Prata.

Mas quem já desceu alguns níveis abaixo da interface elegante de um aplicativo bancário sabe que existe algo assustadoramente verdadeiro nessa afirmação.

O dinheiro moderno não repousa em cofres.

Ele repousa em registros.

Os registros repousam em arquivos, tabelas , mensagens, logs, programas e processos.

E boa parte desses processos ainda é executada por sistemas construídos em COBOL, JCL, CICS, IMS, Db2, Adabas, QSAM, VSAM, Assembler, MQ e outras criaturas que vivem nas profundezas do data center.

Para o programador COBOL iniciante, entrar nesse ambiente é como embarcar no submarino Seaview, da série clássica Voyage to the Bottom of the Sea.

Na superfície, tudo parece tranquilo.

O mar está calmo.

Os clientes consultam saldos.

As transferências acontecem.

Os cartões funcionam.

Os investimentos rendem.

As aposentadorias são pagas e nosso velhinhos aposentados felizes saindo das agencias com seu rico dinheiro na algibeira.

Mas, centenas de metros abaixo, existe uma estrutura monumental enfrentando pressão extrema, correntes invisíveis, monstros desconhecidos e compartimentos que ninguém abre desde 1900 e ventania.

E, em algum lugar da sala de máquinas, existe um programa chamado PGMFIN47 que ninguém ousa alterar. Causando tremores, calafrios e insonia na equipe da sustentação e deixando os operadores da produção em alerta vermelho em cada diaria.

Bem-vindo ao fundo do sistema legado.


1. O dinheiro não está no aplicativo

Quando um cliente abre o aplicativo do banco e vê um saldo de R$ 3.457,82, ele imagina que aquele número simplesmente “está lá”.

Mas aquele saldo é o resultado final de uma longa cadeia de decisões (logado e auditado).

Antes de aparecer na tela, ele pode ter passado por:

  • lançamentos de crédito e débito;

  • compensação;

  • reconciliação;

  • bloqueios;

  • tarifas;

  • impostos;

  • juros;

  • arredondamentos;

  • regras contratuais;

  • limites;

  • autorizações;

  • lotes noturnos;

  • eventos em tempo real;

  • ajustes manuais;

  • ordens judiciais;

  • validações antifraude;

  • integração com sistemas externos.

O valor exibido é apenas a ponta do periscópio.

Debaixo da água existe uma frota inteira de programas.

Um simples depósito pode ativar:

IF CONTA-ATIVA
    IF VALOR-DEPOSITO > ZERO
        ADD VALOR-DEPOSITO TO SALDO-CONTA
    ELSE
        MOVE 'VALOR INVALIDO' TO MENSAGEM-ERRO
    END-IF
END-IF

Bonito, simples e didático.

Mas um sistema real dificilmente termina aí.

Talvez a conta esteja bloqueada.

Talvez seja uma conta conjunta.

Talvez o depósito tenha sido realizado após o horário de corte.

Talvez haja incidência tributária.

Talvez exista um limite diário.

Talvez a origem do dinheiro exija análise.

Talvez o cliente esteja sujeito a uma regra antiga preservada por obrigação judicial.

O código começa simples e cresce como o submarino avançando para uma região do oceano onde os mapas ficam cada vez menos confiáveis.


2. O banco não guarda apenas dinheiro: ele guarda regras

Essa é uma das primeiras grandes lições para um programador COBOL iniciante.

Um sistema bancário não é apenas uma calculadora gigante.

Ele é uma máquina de aplicar regras.

Cada produto financeiro contém uma coleção de decisões.

Uma aplicação pode ter:

  • forma de cálculo;

  • taxa;

  • prazo;

  • carência;

  • vencimento;

  • tributação;

  • liquidez;

  • arredondamento;

  • herança;

  • transferência;

  • resgate antecipado;

  • penalidade;

  • exceção.

Essas regras podem ter origem em:

  • leis;

  • contratos;

  • resoluções;

  • circulares;

  • normas internas;

  • decisões judiciais;

  • aquisições;

  • fusões;

  • migrações;

  • acordos comerciais;

  • correções de incidentes antigos.

O programa COBOL é apenas uma das formas pelas quais essas regras foram cristalizadas.

Por isso, uma linha aparentemente estranha pode ser muito mais importante do que parece:

IF DATA-ADESAO < 19940701
    PERFORM CALCULO-ANTIGO
ELSE
    PERFORM CALCULO-NOVO
END-IF

Um iniciante pode pensar:

“Isso está feio. Vou simplificar.”

Só que a data de 1º de julho de 1994 pode estar relacionada a uma mudança monetária, regulatória, contratual ou operacional.

Remover a condição sem compreender sua origem é como abrir uma escotilha externa do submarino porque ela parece enferrujada.

A escotilha pode estar feia.

Mas talvez esteja impedindo o oceano inteiro de entrar.


3. Código não é a mesma coisa que conhecimento

Um programa pode mostrar o que acontece.

Nem sempre mostra por que acontece.

Considere:

IF WS-TIPO-CLIENTE = '09'
    MOVE 0 TO WS-TAXA
END-IF

A sintaxe é fácil.

O comportamento é claro.

Clientes do tipo 09 recebem taxa zero.

Mas por quê?

  • São funcionários?

  • São clientes judiciais?

  • São contas herdadas de outro banco?

  • São contratos especiais?

  • São beneficiários de uma legislação?

  • São contas de teste?

  • São clientes de uma campanha encerrada há vinte anos?

O código não responde automaticamente.

Esse é o ponto central de toda a discussão.

Existe uma diferença entre:

O que o sistema faz

e

Por que o sistema faz

A primeira pergunta pode ser respondida por análise de código.

A segunda exige contexto histórico, regulatório, comercial e humano.

Muitos projetos fracassam porque tratam essas duas perguntas como se fossem iguais.


4. A tripulação que conhece o fundo do oceano

Em grandes instituições, sempre existem profissionais que parecem possuir um sonar interno.

Eles olham um erro e dizem:

“Isso começou depois da conversão de arquivos de 2003.”

Ou:

“Esse campo não pode ficar em branco porque o sistema de previdência antigo usa espaço como indicador de benefício vitalício.”

Ou ainda:

“Não altere essa ordenação. O arquivo precisa chegar desse jeito porque o processo noturno compara registros por posição, não por chave.”

Esses profissionais não apenas conhecem o código.

Eles conhecem a história.

Eles lembram:

  • de incidentes;

  • de migrações;

  • de auditorias;

  • de exceções;

  • de soluções provisórias;

  • de clientes especiais;

  • de mudanças regulatórias;

  • de sistemas desativados que ainda deixam rastros.

Eles são a documentação viva da organização.

O problema é que muitos estão se aposentando.

Quando essas pessoas saem, a instituição não perde apenas mão de obra.

Ela perde contexto.

É como se o capitão do Seaview abandonasse o submarino levando consigo a única carta náutica da região.

Os motores continuam funcionando.

Os painéis continuam acesos.

Mas ninguém sabe exatamente o que existe adiante.


5. Conhecimento explícito e conhecimento tácito

Existem dois tipos principais de conhecimento dentro de uma organização.

Conhecimento explícito

É aquele que pode ser registrado.

Exemplos:

  • manuais;

  • diagramas;

  • wikis;

  • especificações;

  • normas;

  • comentários;

  • fluxos;

  • casos de teste;

  • atas de reunião;

  • registros de mudança.

Conhecimento tácito

É aquele que vive na experiência das pessoas.

Exemplos:

  • perceber que determinado erro costuma indicar arquivo incompleto;

  • saber qual sistema costuma atrasar o processamento;

  • reconhecer um padrão estranho em um relatório;

  • lembrar que uma exceção existe por causa de um processo judicial antigo;

  • saber quem deve ser consultado antes de alterar uma regra.

O conhecimento tácito é poderoso, mas frágil.

Ele não é facilmente pesquisável.

Não aparece em diagramas.

Não pode ser encontrado com CTRL+F.

E desaparece quando a pessoa muda de área, se aposenta ou simplesmente esquece.

O verdadeiro risco dos sistemas legados não está apenas em sua idade.

Está na distância crescente entre o comportamento do sistema e a compreensão humana desse comportamento.


6. O comentário mais perigoso do mainframe

Todo programador COBOL eventualmente encontra um comentário assim:

* NAO ALTERAR

Ou:

* CORRECAO TEMPORARIA

Ou o clássico:

* AJUSTE ESPECIAL

A pergunta imediata deveria ser:

Por quê?

Mas muitas vezes não existe resposta.

A correção temporária foi criada em 1996.

O autor saiu da empresa em 2008.

O sistema que gerava o problema foi desativado em 2014.

Mesmo assim, o código continua lá.

É possível que não seja mais necessário.

Também é possível que seja a única coisa impedindo um desastre.

Esse tipo de situação transforma manutenção em arqueologia.

O programador deixa de ser apenas desenvolvedor.

Ele se torna investigador.

Cada comentário é um fragmento de mapa.

Cada IF é uma pista.

Cada arquivo antigo é uma caixa-preta retirada de um naufrágio.


7. O problema nunca foi simplesmente o COBOL

É comum ouvir:

“O problema é que o sistema está em COBOL.”

Isso é uma simplificação confortável.

COBOL pode ser antigo, mas isso não significa que seja incapaz.

Ele continua sendo eficiente para processamento de grandes volumes de dados, regras de negócio, cálculos financeiros e operações transacionais.

O problema real costuma ser outro:

  • arquitetura não documentada;

  • dependências ocultas;

  • regras espalhadas;

  • ausência de testes;

  • falta de rastreabilidade;

  • conhecimento concentrado;

  • décadas de mudanças incrementais;

  • integrações pouco compreendidas.

Reescrever tudo em Java, C#, Python, Go ou qualquer outra linguagem não corrige automaticamente essas falhas.

Você pode transportar uma regra mal compreendida para uma tecnologia moderna e continuar tendo um sistema mal compreendido.

Agora ele terá contêineres, APIs e dashboards coloridos.

Mas continuará sendo um mistério.

É como trocar o casco do submarino sem saber por que alguns compartimentos precisam permanecer isolados.


8. Por que microserviços não são uma boia salva-vidas

Microserviços podem ser excelentes.

Eles ajudam a separar responsabilidades, escalar componentes, melhorar implantações e reduzir acoplamentos.

Mas não resolvem desconhecimento.

Imagine um programa legado com cinquenta regras pouco compreendidas.

A equipe decide dividi-lo em vinte microserviços.

Agora existem vinte componentes carregando regras pouco compreendidas.

Antes, o mistério estava em um programa.

Agora está distribuído pela rede.

Você também ganhou:

  • APIs;

  • autenticação;

  • latência;

  • filas;

  • observabilidade;

  • versionamento;

  • tolerância a falhas;

  • consistência distribuída;

  • retries;

  • circuit breakers.

Os microserviços não eliminaram o problema.

Eles adicionaram novas camadas ao oceano.

A modernização correta começa por entendimento, não por tecnologia.


9. “Show your work”: mostre como chegou ao resultado

Reguladores e auditores estão cada vez menos satisfeitos com a resposta:

“O sistema sempre funcionou assim.”

Eles querem evidências.

Querem saber:

  • qual regra foi aplicada;

  • qual dado foi usado;

  • quem alterou o programa;

  • quem aprovou;

  • qual teste foi executado;

  • qual requisito justificou a mudança;

  • qual impacto foi analisado;

  • como o resultado pode ser reproduzido.

Isso aparece em diferentes regulações, normas e políticas.

A mensagem geral é simples:

Mostre como chegou ao resultado.

Em matemática escolar, não basta escrever a resposta.

É preciso demonstrar o cálculo.

Em sistemas críticos, ocorre o mesmo.

Não basta o programa gerar o valor correto.

É preciso explicar:

  • o fluxo;

  • a decisão;

  • a origem;

  • a evidência;

  • a responsabilidade.

Essa exigência afeta tanto sistemas tradicionais quanto soluções com inteligência artificial.


10. O que reguladores estão enxergando

Durante décadas, muitas instituições conviveram com sistemas que funcionavam, mas eram pouco explicáveis.

Enquanto os resultados estavam corretos, o risco parecia aceitável.

Agora isso mudou.

Regulações relacionadas à proteção de dados, resiliência operacional, governança, risco e inteligência artificial aumentaram a pressão por:

  • transparência;

  • documentação;

  • rastreabilidade;

  • responsabilidade;

  • explicabilidade;

  • controle de mudanças;

  • gestão de terceiros;

  • continuidade operacional.

Um sistema que ninguém compreende completamente deixa de ser apenas um problema técnico.

Ele se torna um risco de conformidade.

Imagine um cálculo de benefício financeiro contestado por um cliente.

A instituição precisa responder:

Por que esse valor foi calculado?

Qual regra foi aplicada?

Em qual versão do programa?

Com quais dados?

Quem aprovou aquela regra?

Se a única resposta for:

“O senhor Antônio sabia, mas se aposentou há três anos”,

o problema já ultrapassou o departamento de tecnologia.


11. Por que o ChatGPT sozinho não salvará o submarino

Modelos de linguagem podem ajudar muito na análise de código.

Eles podem:

  • explicar trechos;

  • resumir programas;

  • sugerir documentação;

  • gerar casos de teste;

  • identificar estruturas;

  • converter pseudocódigo;

  • apontar possíveis inconsistências;

  • criar diagramas conceituais;

  • auxiliar novos profissionais.

Mas existe um limite essencial.

A IA só pode trabalhar com o contexto disponível.

Se determinada regra não está:

  • no código;

  • nos documentos;

  • nos testes;

  • nos tickets;

  • nos manuais;

  • nos registros;

  • nas conversas preservadas;

a IA não pode recuperar magicamente sua intenção original.

Ela pode inferir.

Mas inferência não é certeza.

Considere:

IF IDADE-CLIENTE > 65
    COMPUTE TAXA = TAXA * 0.75
END-IF

A IA pode dizer:

“O programa aplica desconto de 25% para clientes com mais de 65 anos.”

Isso descreve o comportamento.

Mas não explica:

  • se é obrigação legal;

  • se é benefício promocional;

  • se vale para todos os produtos;

  • se a idade correta deveria ser 60;

  • se a regra ainda está vigente;

  • se existem exceções.

A IA genérica entende a linha.

Não necessariamente entende o mundo que criou a linha.


12. IA genérica versus IA de domínio

Uma IA genérica conhece muitos assuntos.

Uma IA de domínio é construída ou enriquecida para compreender profundamente um contexto específico.

Em um ambiente bancário, uma solução realmente útil precisaria relacionar:

  • código COBOL;

  • copybooks;

  • JCL;

  • tabelas Db2;

  • arquivos VSAM;

  • transações CICS;

  • mensagens MQ;

  • normas internas;

  • legislação;

  • casos de teste;

  • tickets;

  • documentação;

  • histórico de mudanças;

  • entrevistas com especialistas.

Não basta alimentar um modelo com um único programa.

É preciso criar uma visão do ecossistema.

Essa abordagem pode envolver:

  • mecanismos de busca semântica;

  • catálogos de metadados;

  • grafos de dependência;

  • análise estática;

  • documentação recuperada;

  • bases vetoriais;

  • trilhas de auditoria;

  • validação humana;

  • controle de acesso.

A IA torna-se um sonar.

Ela ajuda a mapear o oceano.

Mas ainda é necessário um comandante humano para interpretar o que aparece na tela.


13. Passo a passo para compreender um sistema legado

Para o programador COBOL iniciante, a melhor estratégia não é tentar entender tudo de uma vez.

Um sistema crítico precisa ser explorado por camadas.

Passo 1 — Descubra a entrada

Pergunte:

  • O programa recebe arquivo?

  • Recebe COMMAREA?

  • Lê fila MQ?

  • Usa parâmetros?

  • Consulta banco?

  • É chamado por outro programa?

Identifique os dados de entrada.

Passo 2 — Descubra a saída

O programa:

  • grava arquivo;

  • atualiza tabela;

  • retorna código;

  • envia mensagem;

  • imprime relatório;

  • chama outro módulo?

Saber o que entra e o que sai ajuda a delimitar a responsabilidade.

Passo 3 — Mapeie os acessos

Procure:

  • SELECT;

  • FD;

  • EXEC SQL;

  • EXEC CICS;

  • CALL;

  • LINK;

  • XCTL;

  • READ;

  • WRITE;

  • REWRITE;

  • DELETE.

Esses comandos mostram conexões importantes.

Passo 4 — Identifique regras

Procure decisões:

IF
EVALUATE
PERFORM
COMPUTE
ADD
SUBTRACT
MULTIPLY
DIVIDE

Registre cada regra com linguagem simples.

Exemplo:

“Clientes com adesão anterior a julho de 1994 utilizam cálculo histórico.”

Passo 5 — Procure datas e códigos mágicos

Valores fixos são pistas.

IF WS-CODIGO = 47

Por que 47?

IF WS-DATA < 20010101

O que aconteceu em 2001?

Todo número mágico merece investigação.

Passo 6 — Leia o JCL

O JCL pode explicar mais do que o programa.

Ele mostra:

  • arquivos;

  • etapas;

  • ordenações;

  • parâmetros;

  • programas anteriores;

  • programas posteriores;

  • condições;

  • utilitários.

O programa é apenas um compartimento do submarino.

O JCL mostra a rota da missão.

Passo 7 — Converse com especialistas

Pergunte:

  • Que problema esse processo resolve?

  • O que acontece se ele falhar?

  • Quais clientes são afetados?

  • Quais exceções existem?

  • Que parte ninguém deve alterar?

  • Qual incidente antigo explica essa regra?

Grave ou documente as respostas de forma autorizada e organizada.

Passo 8 — Crie testes de caracterização

Antes de alterar o sistema, registre seu comportamento atual.

Forneça entradas conhecidas.

Capture saídas.

Esses testes funcionam como fotografias do sistema antes da reforma.

Passo 9 — Valide com o negócio

Não confie apenas na interpretação técnica.

Uma regra pode estar implementada de determinada forma e ainda assim não refletir a política atual.

A área de negócio precisa validar.

Passo 10 — Documente enquanto aprende

Não deixe para o final.

O final nunca chega.

Documente:

  • fluxo;

  • regras;

  • dependências;

  • dúvidas;

  • exceções;

  • responsáveis;

  • fontes;

  • testes.


14. Um mapa mínimo para cada programa

Todo programa importante deveria possuir uma ficha simples:

Identificação

  • Nome do programa;

  • sistema;

  • módulo;

  • responsável;

  • criticidade.

Objetivo

Uma frase clara:

“Calcula o valor líquido de resgate de contratos de previdência.”

Entradas

  • arquivos;

  • tabelas;

  • parâmetros;

  • mensagens;

  • chamadas.

Saídas

  • tabelas atualizadas;

  • arquivos gerados;

  • códigos de retorno;

  • mensagens.

Regras principais

Uma lista de regras de negócio compreensíveis.

Dependências

  • programas chamados;

  • transações;

  • filas;

  • bancos;

  • jobs.

Exceções

Casos especiais e históricos.

Evidências

  • documentos;

  • tickets;

  • legislação;

  • testes;

  • entrevistas.

Riscos

O que pode acontecer se houver alteração incorreta.

Essa ficha não precisa começar perfeita.

Ela precisa começar.


15. Testes são caixas-pretas de sobrevivência

Em sistemas pouco documentados, testes automatizados são fundamentais.

Um teste de caracterização não pergunta inicialmente se o comportamento está certo.

Ele registra o que o sistema faz hoje.

Exemplo:

Entrada:

IDADE = 67
SALDO = 10000
TIPO = 09

Saída atual:

TAXA = 0
VALOR-LIQUIDO = 10000

Mesmo que você ainda não saiba por que o tipo 09 recebe taxa zero, agora existe uma evidência do comportamento.

Depois, especialistas e analistas podem decidir se a regra deve continuar.

Sem testes, cada mudança é uma descida em águas desconhecidas.

Com testes, pelo menos existem boias marcando o caminho de volta.


16. O perigo da reescrita heroica

Existe um tipo de projeto que aparece ciclicamente:

“Vamos reescrever tudo.”

A proposta parece corajosa.

A equipe escolhe uma tecnologia moderna.

Cria uma nova arquitetura.

Desenha diagramas.

Depois começa a descobrir que o sistema antigo possui milhares de regras não documentadas.

A reescrita passa a exigir decisões sobre comportamentos que ninguém consegue explicar.

O novo sistema pode ficar mais bonito, mas incompleto.

Reescrever sem compreender é como construir outro submarino usando fotografias externas do antigo.

Você copia o formato.

Mas não entende os sistemas internos que o mantinham vivo sob pressão.


17. Estratégias de modernização mais seguras

Modernização não precisa significar destruição total.

Existem abordagens graduais.

Encapsular

Expor funções existentes por APIs sem reescrever imediatamente a lógica.

Refatorar

Melhorar a estrutura interna preservando o comportamento.

Extrair regras

Separar regras de negócio de partes técnicas.

Substituir por etapas

Migrar componentes de menor risco primeiro.

Manter onde faz sentido

Nem tudo precisa ser reescrito.

Um programa estável, eficiente, bem testado e compreendido pode continuar cumprindo sua função.

Criar observabilidade

Adicionar logs, métricas, rastreamento e evidências.

Preservar conhecimento

Transformar entrevistas, código, documentação e testes em uma base pesquisável.

A modernização madura pergunta:

“Qual problema precisamos resolver?”

A modernização imatura pergunta:

“Qual tecnologia está na moda?”


18. Curiosidades das profundezas do legado

Curiosidade 1 — Muitos sistemas antigos são extremamente rápidos

Programas batch bem construídos conseguem processar volumes gigantescos com eficiência impressionante.

Curiosidade 2 — O código antigo pode estar correto há décadas

Antigo não significa defeituoso.

Às vezes, o código permaneceu porque funciona.

Curiosidade 3 — A regra mais estranha pode ser a mais importante

Exceções esquisitas frequentemente revelam contratos, leis ou incidentes históricos.

Curiosidade 4 — O melhor documento pode estar no JCL

A sequência de steps mostra como o negócio realmente é processado.

Curiosidade 5 — Arquivos de teste antigos são tesouros

Eles revelam cenários, combinações e resultados esperados.

Curiosidade 6 — O nome do programa pode enganar

CALCJURO talvez calcule imposto, tarifa, comissão e arredondamento além de juros.

Curiosidade 7 — O sistema real ultrapassa o código

Parte da lógica pode estar em:

  • parâmetros;

  • tabelas;

  • procedimentos;

  • agendamentos;

  • configurações;

  • arquivos;

  • rotinas operacionais.


19. Dicas para o programador COBOL padawan

Não tenha vergonha de perguntar

O sistema pode ser mais velho do que sua carreira.

Ninguém espera compreensão instantânea.

Evite assumir

Confirme.

O nome de um campo nem sempre reflete seu uso atual.

Não altere números mágicos sem investigar

Datas, códigos e percentuais fixos quase sempre possuem uma história.

Leia os dados

Um copybook pode revelar mais do domínio do que várias páginas de documentação.

Aprenda o negócio

O melhor programador de sistemas financeiros não é apenas quem domina PERFORM.

É quem entende:

  • contrato;

  • saldo;

  • juros;

  • imposto;

  • compensação;

  • liquidação;

  • risco;

  • exceção.

Crie diagramas simples

Não espere uma arquitetura perfeita.

Comece com:

Arquivo → Job → Programa → Db2 → Relatório

Depois aprofunde.

Registre dúvidas

Uma dúvida esquecida vira um problema futuro.

Preserve a voz dos veteranos

Entrevistas estruturadas podem recuperar histórias que nunca foram escritas.

Não confunda confiança com certeza

Um sistema pode parecer simples porque você ainda não descobriu suas exceções.


20. Easter eggs do Bellacosa Mainframe

Todo grande sistema legado possui seus easter eggs.

Não necessariamente piadas escondidas, mas pequenos sinais de sua história.

Pode ser:

  • um campo com nome de projeto extinto;

  • uma data que marca uma mudança econômica;

  • um código de retorno que ninguém mais usa;

  • um comentário com iniciais de um programador;

  • uma condição criada para um único cliente;

  • uma rotina chamada FINAL-FINAL;

  • um programa chamado NOVO criado em 1989;

  • uma variável chamada TEMP usada há trinta anos.

E existe o easter egg supremo:

* RETIRAR DEPOIS DA MIGRACAO

A migração ocorreu em 1997.

A linha continua em produção.

Ao encontrá-la, o programador iniciante deve resistir à tentação de apagar.

Primeiro investigue.

Talvez seja apenas um fóssil.

Talvez seja a coluna estrutural secreta do submarino.


21. A inteligência artificial como novo sonar

Usada corretamente, a IA pode acelerar enormemente o trabalho de compreensão.

Ela pode ajudar a:

  • resumir programas;

  • explicar parágrafos;

  • sugerir nomes melhores;

  • encontrar padrões repetidos;

  • correlacionar copybooks;

  • gerar perguntas para especialistas;

  • criar documentação inicial;

  • propor testes;

  • identificar regras candidatas;

  • montar mapas de chamadas.

Mas o fluxo seguro é:

  1. A IA analisa.

  2. O especialista revisa.

  3. O negócio valida.

  4. O teste comprova.

  5. A documentação registra.

  6. A governança aprova.

A IA não deve ser tratada como oráculo.

Ela é um instrumento de navegação.

Um sonar pode indicar uma grande massa à frente.

Mas cabe à tripulação decidir se é uma montanha submarina, um navio naufragado ou um monstro marinho de um episódio de 1966.


22. Onde estamos indo

O futuro não será simplesmente “COBOL versus IA”.

Nem “mainframe versus cloud”.

Nem “monólito versus microserviços”.

O futuro mais provável será híbrido.

Sistemas críticos continuarão executando regras maduras.

APIs facilitarão integração.

Cloud fornecerá elasticidade e novos serviços.

IA ajudará na compreensão.

Grafos mapearão dependências.

Testes automatizados protegerão comportamentos.

Documentação viva conectará código, regra, requisito e evidência.

O objetivo não é apagar o passado.

É tornar o passado compreensível.

Porque somente aquilo que pode ser compreendido pode ser modernizado com segurança.


23. O verdadeiro risco sistêmico

Falamos muito sobre:

  • ataques;

  • falhas de hardware;

  • indisponibilidade;

  • fraude;

  • ransomware;

  • bugs;

  • desastres naturais.

Mas existe um risco mais silencioso:

A organização continuar operando sistemas que ninguém consegue explicar.

Esse risco cresce lentamente.

Primeiro sai um especialista.

Depois outro.

A documentação envelhece.

As equipes mudam.

Os fornecedores trocam.

As tecnologias são empilhadas.

Até que, um dia, ocorre um incidente.

E todos percebem que o sistema ainda funciona, mas a instituição já não sabe completamente por quê.

Esse é o verdadeiro Voyage to the Bottom of the Legacy System.

A descida não é em direção ao fundo do mar.

É em direção às camadas de decisões acumuladas por décadas.


Conclusão: não desligue os motores antes de encontrar o mapa

O maior patrimônio de um banco não está apenas em seus cofres, prédios, servidores ou aplicações.

Está no conhecimento que conecta tudo isso.

COBOL não é apenas uma linguagem antiga.

Em muitos ambientes, ele é o idioma em que décadas de decisões financeiras foram registradas.

O perigo não é o código ser velho.

O perigo é ninguém mais conseguir explicar suas escolhas.

Para o programador iniciante, a missão não é apenas aprender PIC, MOVE, PERFORM, EVALUATE e EXEC SQL.

A missão é aprender a fazer perguntas.

Por que essa regra existe?

De onde vem esse valor?

Quem depende desse processamento?

Qual documento comprova esse comportamento?

O que acontece se eu alterar?

Que parte do negócio este código representa?

No fundo do oceano, coragem sem mapa é imprudência.

No fundo do sistema legado, modernização sem compreensão é apenas uma forma mais cara de se perder.

Portanto, antes de reescrever, compreenda.

Antes de apagar, investigue.

Antes de automatizar, documente.

Antes de confiar na IA, forneça contexto.

E antes que o último especialista se aposente, sente-se ao lado dele, abra o código, prepare o café e pergunte:

“Pode me explicar por que esse IF existe?”

Talvez a resposta salve não apenas um programa.

Talvez salve parte das economias do mundo.

Mensagem recebida via telegrafo

Seja um mainframer, aprenda COBOL e participe desta missão nas profundezas do CPD, os famosos Centros de Processamento de Dados.


segunda-feira, 20 de julho de 2026

Yoichi Ochiai (落合陽一) : O Homem que Tentou Compilar o Mundo Físico em Código

 

Bellacosa Mainframe homenagem a Yoichi Ochiai


☕ Um Café no Bellacosa Mainframe

Yoichi Ochiai (落合陽一)

O Homem que Tentou Compilar o Mundo Físico em Código

"Quando um Engenheiro Descobre que Hardware, Software e Natureza Talvez Sejam Apenas Diferentes Versões do Mesmo Programa..."


Quem é Yoichi Ochiai?

Imagine alguém que mistura...

  • Alan Turing

  • Hayao Miyazaki

  • Steve Jobs

  • Nikola Tesla

  • um pesquisador da IBM Research

  • um artista digital

...e coloca tudo isso dentro da mesma pessoa.

Esse é Yoichi Ochiai.

Nascido em 1987, em Tóquio, pertence a uma geração que nunca viu separação entre computadores e mundo físico.

Enquanto muitos pesquisadores perguntavam:

"Como fazer computadores melhores?"

Ochiai perguntava:

"E se o computador deixar de ser um objeto e virar parte da natureza?"

Essa pergunta define praticamente toda sua carreira. (Yoichi Ochiai)


Formação

Graduou-se e concluiu doutorado extremamente cedo.

Especializou-se em:

  • Computação

  • Óptica Computacional

  • Inteligência Artificial

  • Realidade Aumentada

  • Levitação acústica

  • Interfaces Homem-Máquina

Hoje atua como professor na Universidade de Tsukuba e também mantém atividades de pesquisa e empreendedorismo. (Yoichi Ochiai)


O conceito que mudou sua carreira

Digital Nature

Segundo Ochiai,

não existe mais uma divisão clara entre

  • mundo digital

e

  • mundo físico.

No futuro:

uma árvore poderá conter sensores.

Uma pedra poderá responder.

Uma janela poderá ser uma tela.

Uma parede poderá conversar.

O computador desaparece.

A computação permanece.

É quase como imaginar um sistema operacional rodando no planeta inteiro.


O que ele pesquisa?

Entre dezenas de áreas:

  • IA

  • computação espacial

  • holografia

  • realidade aumentada

  • realidade mista

  • interfaces naturais

  • levitação por ultrassom

  • computação óptica

  • arte generativa

  • robótica

  • acessibilidade

Sua carreira é multidisciplinar por definição. (Ochiai Laboratory)


Trabalhos mais conhecidos

Embora não produza mangás, seus projetos chamam tanta atenção quanto uma grande obra de ficção científica.

Fairy Lights in Femtoseconds

Usa lasers ultrarrápidos para criar pontos luminosos no ar.

Literalmente.

Luz flutuando.

Parecia magia.

Mas era física.


Levitação Acústica

Talvez seu trabalho científico mais famoso.

Utiliza ondas ultrassônicas para suspender pequenos objetos.

Sem fios.

Sem ímãs.

Sem contato físico.

É um dos trabalhos que ajudaram a popularizar pesquisas sobre manipulação acústica. (arXiv)


Expo Osaka 2025

Foi um dos produtores temáticos da Expo 2025.

Criou instalações imersivas que misturam:

  • arquitetura

  • IA

  • computação

  • arte

  • filosofia oriental

Tudo baseado na ideia de Digital Nature. (Yoichi Ochiai)


Livros

Entre seus livros mais conhecidos:

  • Digital Nature

  • Magic Century

  • Survival Strategy in the AI Era

  • Future Changed by Generative AI

  • The World Atlas of 2030

Misturam filosofia, tecnologia e futuro da sociedade. (Yoichi Ochiai)


Prêmios

A lista impressiona.

Entre eles:

🏆 World Technology Award

🏆 Prix Ars Electronica

🏆 STARTS Prize

🏆 SXSW Creative Experience Awards

🏆 MIT Technology Review Innovators Under 35 Japan

🏆 Apollo 40 Under 40 Art & Tech

Pouquíssimos pesquisadores transitam com destaque entre ciência e arte dessa maneira. (Yoichi Ochiai)


Personagens?

Como não é mangaká,

ele não possui personagens clássicos.

Mas, metaforicamente, seus "personagens" são:

  • partículas de luz

  • ondas sonoras

  • algoritmos

  • IA

  • robôs

  • hologramas

  • pessoas interagindo com tecnologia

Ou seja...

o protagonista é o próprio futuro.


Polêmicas

Ochiai costuma gerar debates por defender uma integração profunda entre IA e sociedade.

Entre as discussões:

  • excesso de automação;

  • impacto da IA sobre empregos;

  • questões filosóficas sobre o que é "natural";

  • visão otimista em contraste com críticos da tecnologia.

São debates intelectuais, e não grandes escândalos pessoais conhecidos. (Yoichi Ochiai)


Curiosidades

Ele concluiu o doutorado muito rapidamente.

Foi considerado um dos jovens pesquisadores mais brilhantes do Japão.


Trabalha entre arte e engenharia.

Para ele:

não existe diferença.


É empresário.

Além da carreira acadêmica, atua no desenvolvimento de tecnologias aplicadas por meio da Pixie Dust Technologies. 


Participa de políticas públicas

Já integrou conselhos ligados à inovação, cultura digital e tecnologia no Japão, influenciando discussões sobre o futuro da sociedade conectada. (Yoichi Ochiai)


Easter Eggs Bellacosa Mainframe

Easter Egg 1

Digital Nature lembra muito o conceito do z/OS:

O sistema operacional praticamente desaparece...

...mas está coordenando tudo.


Easter Egg 2

Para um programador COBOL,

um programa conversa com:

  • CICS

  • Db2

  • MQ

  • VSAM

Para Ochiai,

o programa conversa com:

  • árvores

  • luz

  • vidro

  • pessoas

  • cidades


Easter Egg 3

Se IBM criasse um laboratório dentro de um anime cyberpunk,

provavelmente pareceria um laboratório do Yoichi Ochiai.


O legado

Embora não desenhe mangás,

Yoichi Ochiai desenha algo talvez ainda maior:

uma visão de futuro.

Ele pertence à rara categoria de pessoas capazes de reunir:

  • arte;

  • ciência;

  • engenharia;

  • filosofia;

  • inteligência artificial;

  • design;

  • computação.

Seu trabalho inspira pesquisadores, artistas e engenheiros a imaginar um mundo onde a tecnologia deixa de ser apenas uma ferramenta e passa a integrar o ambiente de forma quase invisível — uma espécie de "sistema operacional" da realidade.


 

segunda-feira, 13 de julho de 2026

Capítulo 13 — Os Profetas da IA e o Próximo Funeral

Bellacosa Mainframe e os profetas da ia o proximo funeral?

☕ Um Café no Bellacosa Mainframe

Capítulo 13 — Os Profetas da IA e o Próximo Funeral

Será que Estamos Cometendo Exatamente o Mesmo Erro Outra Vez?

Uma reflexão sobre os paralelos entre as previsões feitas contra o mainframe nas décadas de 1980 e 1990 e as atuais previsões absolutas envolvendo Inteligência Artificial, AGI e agentes autônomos.

Por


Comparação entre os profetas da Inteligência Artificial e as previsões sobre o fim do Mainframe
A história mostra que previsões tecnológicas absolutas costumam ignorar a capacidade das plataformas de evoluir, integrar-se e coexistir.

"Quem não estuda a História da Computação está condenado a repetir as mesmas previsões... apenas trocando o nome da tecnologia da moda."

— Bellacosa Mainframe

Os paralelos históricos

Nas décadas de 1980 e 1990, manchetes afirmavam que Client/Server, Downsizing ou Internet eliminariam o mainframe. Em 2026, previsões semelhantes aparecem envolvendo IA generativa, AGI e agentes autônomos, frequentemente apresentadas como substituições inevitáveis de tecnologias anteriores.

A história da computação sugere cautela: novas tecnologias costumam transformar ecossistemas existentes e criar novas possibilidades, mas isso não significa que plataformas consolidadas desapareçam de forma automática.

Integração em vez de substituição

No ecossistema IBM Z, recursos de Inteligência Artificial, watsonx, aceleração por hardware, APIs, automação e análise de dados já convivem com COBOL, CICS, Db2 e z/OS, ampliando capacidades sem eliminar décadas de conhecimento corporativo.

A grande lição

O futuro da computação provavelmente será construído por integração entre IA, engenharia de software, sistemas corporativos e conhecimento de negócio. A história recomenda prudência diante de previsões definitivas sobre vencedores e perdedores.


2026...

Chegamos ao presente.

Você pode imaginar que este artigo terminou.

Na verdade...

Ele está apenas começando.

Porque existe algo extremamente curioso.

Ao terminar de ler todas aquelas manchetes da década de 1990...

Comecei a sentir uma estranha sensação de déjà vu.

Troque apenas algumas palavras.

Em vez de "Client/Server", escreva "IA Generativa".

No lugar de "Workstations", coloque "LLMs".

Onde estiver "Open Systems", escreva "AI Native".

Substitua "Downsizing" por "AI Transformation".

Agora leia novamente.

Assustador, não é?

Parece que estamos revivendo exatamente o mesmo roteiro.


As manchetes mudaram

Em 1991 diziam:

"O último mainframe será desligado."

Hoje ouvimos:

"O último programador escreverá código em poucos anos."

Em 1993:

"O Mainframe está caminhando para a extinção."

Em 2026:

"Programação será totalmente automatizada."

Em 1989:

"COBOL acabou."

Hoje:

"Ninguém mais precisará aprender linguagens."

As frases são diferentes.

O comportamento humano continua exatamente igual.


Bellacosa Mainframe e a nova panaceia para todos os males IA

A nova religião

Nos anos 90 existia uma palavra mágica.

Client/Server.

Hoje temos outra.

IA.

Antes bastava colocar "Open" no nome.

Hoje basta colocar "AI".

AI Search.

AI Platform.

AI Analytics.

AI Database.

AI Network.

AI Refrigerator.

AI Coffee Machine.

Daqui a pouco teremos:

AI Powered Coffee for DevOps Engineers Enterprise Edition Ultra Cloud Native.

Provavelmente alguém conseguirá vender.


Não me entenda errado...

Existe uma diferença importante.

Este capítulo não é uma crítica à Inteligência Artificial.

Muito pelo contrário.

Ela representa uma das maiores revoluções tecnológicas desde a Internet.

Talvez maior.

Ela realmente muda a forma de trabalhar.

Aumenta produtividade.

Automatiza tarefas.

Explica código.

Cria documentação.

Auxilia em testes.

Produz imagens.

Analisa contratos.

Resume reuniões.

Traduz idiomas.

Descobre padrões invisíveis.

A IA não é um hype vazio.

Ela é uma inovação real.

O problema...

Nunca foi a tecnologia.

O problema continua sendo o exagero.


A História ensina prudência

Quando estudamos Wolfgang Spruth percebemos algo extraordinário.

Nenhuma daquelas manchetes era completamente absurda.

Todas enxergavam tendências verdadeiras.

Os PCs realmente cresceram.

O Client/Server realmente revolucionou empresas.

A Internet realmente mudou o planeta.

Linux realmente conquistou os datacenters.

O erro nunca esteve na tendência.

O erro apareceu na conclusão.

Confundir:

"Vai crescer."

Com

"Vai eliminar tudo."


O que a IA realmente fará?

Se aprendemos alguma coisa com quarenta anos de História...

Talvez possamos fazer previsões um pouco melhores.

A IA provavelmente:

✔ escreverá muito código.

✔ automatizará documentação.

✔ ajudará arquitetos.

✔ reduzirá tarefas repetitivas.

✔ explicará sistemas legados.

✔ traduzirá COBOL para linguagem natural.

✔ auxiliará migrações.

✔ encontrará defeitos.

✔ sugerirá otimizações.

✔ escreverá testes.

Tudo isso já está acontecendo.

Mas existe uma enorme diferença entre:

Aumentar produtividade.

E substituir completamente profissionais.


O COBOL talvez seja um dos maiores beneficiados

Essa afirmação costuma surpreender muita gente.

Mas faz sentido.

Imagine um sistema com:

Quarenta milhões de linhas de COBOL.

Documentação incompleta.

Autores aposentados.

Regras espalhadas.

Agora imagine um agente de IA capaz de:

Explicar programas.

Criar diagramas.

Encontrar dependências.

Gerar documentação.

Sugerir testes.

Localizar impactos.

Explicar COPYBOOKs.

Interpretar SQL.

Descrever JCL.

A IA não elimina o COBOL.

Ela torna o COBOL muito mais acessível.

Pela primeira vez um Padawan poderá conversar com décadas de conhecimento acumulado.

Isso é extraordinário.


O IBM Z entendeu antes de muita gente

Enquanto parte do mercado ainda discutia se IA e Mainframe poderiam conviver...

A IBM já estava construindo exatamente essa integração.

O IBM z17 incorpora aceleração dedicada para cargas de Inteligência Artificial.

O watsonx oferece governança, modelos corporativos e ferramentas para IA generativa.

O Db2 evolui incorporando recursos inteligentes.

O CICS continua sendo a plataforma ideal para decisões transacionais em tempo real.

O z/OS recebe novas capacidades de automação.

O BOB, o Zowe, o Ansible e pipelines DevOps tornam o desenvolvimento cada vez mais moderno.

A IBM fez exatamente o que sempre fez.

Não perguntou:

"Como competir com a IA?"

Perguntou:

"Como colocar IA dentro da plataforma?"

Existe uma enorme diferença entre essas duas perguntas.


O verdadeiro patrimônio continua sendo o conhecimento

Uma IA pode escrever código.

Excelente.

Mas quem valida se aquele código atende à legislação brasileira?

Quem sabe como funciona uma compensação bancária?

Quem conhece uma regra tributária criada em 1997 e modificada vinte e três vezes?

Quem entende por que determinado campo possui exatamente sete posições?

Quem sabe por que aquele JCL executa antes das seis da manhã?

A IA pode ajudar.

Muito.

Mas conhecimento de negócio continua sendo um patrimônio humano.


O Padawan conversa com a IA

Nosso Padawan senta diante do computador.

Abre um agente de IA.

Pergunta:

— Explique este programa COBOL.

A IA responde em segundos.

Depois explica o SQL.

Depois o JCL.

Depois desenha o fluxo.

Depois sugere melhorias.

O Padawan sorri.

O velho mestre observa.

O aluno pergunta:

— Mestre...

A IA vai substituir você?

O mestre toma um gole de café.

Responde calmamente.

— Não.

Ela vai me tornar um professor muito melhor.


O novo Jedi da Engenharia

Durante muito tempo imaginamos duas possibilidades.

Ou a IA substituiria os profissionais.

Ou os profissionais ignorariam a IA.

Existe uma terceira opção.

Muito mais interessante.

Profissionais que utilizam IA.

Arquitetos assistidos por IA.

DBAs assistidos por IA.

Sysprogs assistidos por IA.

Programadores COBOL assistidos por IA.

Essa talvez seja a verdadeira revolução.

Não homem contra máquina.

Mas homem com máquina.


A sexta grande lição

Depois de estudar Forbes.

New York Times.

InfoWorld.

Business Week.

Wolfgang Spruth.

IBM Z.

z17.

watsonx.

BOB.

COBOL.

Db2.

CICS.

z/OS.

Existe uma conclusão inevitável.

Toda geração acredita viver uma transformação sem precedentes.

E, de certa forma...

Está certa.

Mas toda geração também acredita que essa transformação eliminará completamente tudo o que veio antes.

E aí costuma errar.

A História da Computação mostra outro padrão.

As grandes revoluções não destroem as fundações.

Elas constroem novos andares sobre elas.


Um conselho para o Padawan de 2036

Talvez você esteja lendo este artigo dez anos depois.

Se for o caso...

Faça um favor para mim.

Quando aparecer uma nova tecnologia dizendo que eliminará completamente a Inteligência Artificial...

Lembre-se deste artigo.

Lembre-se de Stewart Alsop.

Lembre-se do New York Times.

Lembre-se da Forbes.

Lembre-se de Wolfgang Spruth.

E sorria.

Porque você já conhecerá esse roteiro.


A última provocação

Talvez o maior erro da década de 1990 não tenha sido declarar a morte do Mainframe.

Talvez tenha sido esquecer uma regra extremamente simples da Engenharia.

Tecnologias não competem apenas entre si.

Elas competem contra problemas reais.

Enquanto existir um problema que exija:

Disponibilidade.

Escalabilidade.

Confiabilidade.

Segurança.

Consistência.

Governança.

Desempenho transacional.

Sempre existirá espaço para plataformas capazes de resolver esses desafios.

Hoje chamamos essa plataforma de IBM z17.

Amanhã poderá ter outro nome.

Mas sua missão continuará exatamente a mesma.


Epílogo Final

O Professor Wolfgang Spruth preservou as manchetes.

Nós preservamos as lições.

Agora a responsabilidade passa para você.

Da próxima vez que ouvir alguém afirmar:

"Esta tecnologia vai acabar com todas as outras."

Não discuta.

Não ironize.

Não responda imediatamente.

Faça exatamente o que um bom engenheiro faz.

Observe.

Meça.

Estude.

Espere.

Porque a História da Computação já nos ensinou uma verdade extraordinária.

As tecnologias realmente revolucionárias raramente precisam anunciar a morte das anteriores.

Elas simplesmente resolvem problemas tão bem...

Que acabam encontrando seu próprio lugar na História.

E talvez seja exatamente por isso que, mais de sessenta anos depois do System/360, um jovem Padawan ainda pode abrir um editor, escrever um programa COBOL, submetê-lo por um JCL, acessar o Db2 através do CICS, utilizar um agente de IA baseado em watsonx para documentar o código e executá-lo em um IBM z17.

Se isso não é evolução...

Talvez nunca tenhamos entendido o verdadeiro significado dessa palavra.


Que a Engenharia esteja com você.

Sempre.

Bellacosa Mainframe e o Funeral que nunca aconteceu


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

A MORTE DO COBOL

O Funeral que Nunca Aconteceu

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

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

README.TXT

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

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

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

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

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

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