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

Translate

sexta-feira, 1 de fevereiro de 2002

🧠 DEEP THOUGHT E A DUNGEON DO 42 — QUANDO O COBOL DESCOBRIU QUE A RESPOSTA CORRETA NÃO SERVE PARA NADA SE NINGUÉM SOUBER A PERGUNTA

 

Bellacosa Mainframe o perigo da tecnologia sem objetivo

☕ Um Café no Bellacosa Mainframe

🧠 DEEP THOUGHT E A DUNGEON DO 42 — QUANDO O COBOL DESCOBRIU QUE A RESPOSTA CORRETA NÃO SERVE PARA NADA SE NINGUÉM SOUBER A PERGUNTA

Tecnologia, COBOL, sistemas de informação, semiótica, automação, sistemas sociotécnicos, modernização, IA, agentes, conhecimento, responsabilidade — e o dia em que um programador COBOL descobriu que até o maior computador do Universo pode entregar uma resposta inútil quando ninguém sabe exatamente qual problema queria resolver.



🎬 PRÓLOGO — A RESPOSTA É 42

Imagine que você acabou de entrar em uma grande empresa como programador COBOL.

Primeiro emprego.

Primeiro crachá.

Primeiro acesso ao TSO.

Primeiro READY.

Primeira vez olhando para uma tela ISPF e pensando:

— Meu Deus... onde fui me meter?

Você recebe sua primeira missão.

Um programa COBOL antigo está apresentando comportamento estranho.

O líder técnico explica:

— Precisamos modernizar isso.

Você pergunta:

— Qual é o problema?

Silêncio.

Alguém responde:

— É COBOL.

Você insiste:

— Sim. Mas qual é o problema?

Novo silêncio.

Então começam as respostas:

— É antigo.

— Precisamos ir para cloud.

— Precisamos colocar APIs.

— Precisamos usar inteligência artificial.

— Precisamos de microsserviços.

— Precisamos de Kubernetes.

— Precisamos modernizar.

Você olha novamente para o programa.

Ele executa diariamente.

Processa milhões de registros.

O tempo de processamento está dentro da janela batch.

Não existem incidentes graves associados a ele.

O custo é conhecido.

A operação conhece o sistema.

E aparentemente ninguém consegue explicar exatamente qual problema está sendo resolvido pela modernização.

Nesse momento, uma voz grave ecoa pela sala:

42.

Todos olham assustados.

É Deep Thought.

O lendário computador de O Guia do Mochileiro das Galáxias acaba de entrar na War Room.

E ele tem uma péssima notícia:

vocês estão procurando respostas antes de descobrir a pergunta.

Pegue o café.

Abra o ISPF.

Hoje nossa dungeon não começa com COBOL.

Começa com algo muito mais perigoso:

uma solução procurando um problema.



🧙 CAPÍTULO 1 — A CHANTAGEM TECNOLÓGICA

Existe uma crença recorrente na indústria de tecnologia:

tecnologia nova é necessariamente melhor.

O mecanismo funciona mais ou menos assim:

Tecnologia nova
      ↓
Marketing
      ↓
Promessa de produtividade
      ↓
Medo de ficar para trás
      ↓
Compra
      ↓
Implantação
      ↓
Problemas inesperados
      ↓
Nova tecnologia prometendo resolver os problemas
      ↓
REPEAT

Esse medo ganhou até uma expressão moderna:

FOMO — Fear Of Missing Out.

O medo de ficar de fora.

A empresa olha para a concorrência usando inteligência artificial e pergunta:

— Por que ainda não temos IA?

Poucos perguntam:

— Qual problema nosso exige IA?

Essa diferença parece pequena.

Não é.

É a diferença entre engenharia e fetichismo tecnológico.

Podemos chamar esse fenômeno de chantagem tecnológica:

“Se você não comprar nossa nova tecnologia, sua empresa ficará ultrapassada.”

Ontem eram PCs.

Depois cliente-servidor.

Depois downsizing.

Depois Internet.

Depois SOA.

Depois cloud.

Depois containers.

Depois blockchain.

Depois inteligência artificial generativa.

Agora:

Agentic AI.

Não significa que essas tecnologias sejam ruins.

Pelo contrário.

Muitas transformaram profundamente a computação.

O problema começa quando a tecnologia deixa de ser meio e passa a ser objetivo.



⚔️ CAPÍTULO 2 — A SOLUÇÃO QUE SAIU PROCURANDO UM PROBLEMA

Imagine uma empresa que compra uma poderosa plataforma de inteligência artificial.

Contrato assinado.

Licenças compradas.

Consultoria contratada.

Infraestrutura instalada.

Então alguém pergunta:

— O que vamos fazer com isso?

Perceba a inversão.

O caminho saudável seria:

PROBLEMA
   ↓
ANÁLISE
   ↓
REQUISITOS
   ↓
ALTERNATIVAS
   ↓
TECNOLOGIA
   ↓
IMPLEMENTAÇÃO
   ↓
MEDIÇÃO

Mas o caminho frequentemente encontrado é:

TECNOLOGIA
   ↓
COMPRA
   ↓
PROJETO
   ↓
PROCURA POR CASO DE USO

Quando ouvimos:

“Agora precisamos encontrar casos de uso para justificar a plataforma.”

Deep Thought provavelmente responderia:

Porque começamos pela resposta.

Ainda não sabemos a pergunta.



🧠 CAPÍTULO 3 — DEEP THOUGHT E O MAIOR PROBLEMA DE REQUISITOS DO UNIVERSO

Em O Guia do Mochileiro das Galáxias, uma civilização constrói um computador gigantesco chamado Deep Thought.

Sua missão é encontrar a resposta para:

a Vida, o Universo e Tudo Mais.

Depois de um período absurdamente longo de processamento, Deep Thought finalmente anuncia a resposta:

42.

Problema resolvido?

Não.

Ninguém sabe exatamente qual era a pergunta.

Essa é uma das melhores metáforas acidentais sobre engenharia de requisitos.

Um computador pode executar perfeitamente:

INPUT
  ↓
ALGORITHM
  ↓
OUTPUT

Mas existe uma pergunta anterior:

O que estamos tentando descobrir?

E outra posterior:

O que significa o resultado?

Sem essas duas coisas, podemos possuir processamento perfeito e ainda assim produzir algo inútil.



🖥️ CAPÍTULO 4 — COMPUTADORES NÃO RESOLVEM PROBLEMAS

Calma.

Eles obviamente resolvem determinados problemas computacionais.

Mas existe uma distinção importante.

Computadores executam representações formalizadas de problemas.

Antes de chegar ao COBOL, alguma coisa precisa acontecer.

Imagine um banco.

A organização estabelece:

determinadas contas devem ser bloqueadas quando determinadas condições forem satisfeitas.

Depois isso vira regra de negócio.

Depois especificação.

Finalmente podemos ter:

IF SALDO-CLIENTE < ZERO
    MOVE 'B' TO STATUS-CONTA
END-IF.

Para a CPU isso é maravilhoso.

Temos uma condição.

Temos dados.

Temos uma ação.

Mas Deep Thought pergunta:

— Por que saldo negativo significa bloqueio?

Boa pergunta.

Talvez existam:

  • limites de crédito;

  • cheque especial;

  • clientes diferenciados;

  • transações contestadas;

  • depósitos ainda não compensados;

  • determinações judiciais;

  • exceções operacionais.

Portanto, antes daquele pequeno IF, existiu um mundo inteiro.

REALIDADE
   ↓
POLÍTICA
   ↓
REGRA DE NEGÓCIO
   ↓
ESPECIFICAÇÃO
   ↓
ALGORITMO
   ↓
COBOL

O programador normalmente encontra apenas o último andar dessa pirâmide.


🏺 CAPÍTULO 5 — O PROGRAMA COBOL É UM FÓSSIL ORGANIZACIONAL

Agora você encontra:

IF WS-TYPE = '7'
   AND WS-CODE NOT = '91'
   AND WS-FLAG = 'Y'
      PERFORM 8300-PROCESSAR
END-IF.

Sua primeira reação pode ser:

— Que porcaria é essa?

Cuidado.

Talvez você esteja diante de um fóssil.

WS-TYPE = '7' pode ter surgido em 1989.

WS-CODE NOT = '91' pode ter aparecido depois de uma fraude em 1997.

WS-FLAG = 'Y' pode representar uma exigência regulatória de 2008.

E o PERFORM pode ter sido alterado depois de uma fusão empresarial em 2014.

Você não está simplesmente lendo código.

Está praticando:

arqueologia organizacional.

Um sistema legado pode ser uma espécie de memória institucional executável.

Isso explica por que reescrever sistemas antigos é muito mais difícil do que traduzir linguagens.


🏰 CAPÍTULO 6 — SISTEMAS DE INFORMAÇÃO NÃO SÃO APENAS COMPUTADORES

Um erro comum de iniciantes é pensar:

Sistema de Informação
=
Hardware + Software + Banco de Dados

Na realidade temos algo muito maior:

             PESSOAS
                │
                │
PROCESSOS ── INFORMAÇÃO ── TECNOLOGIA
                │
                │
              REGRAS
                │
                │
             CULTURA

Existe ainda:

  • poder;

  • autoridade;

  • confiança;

  • experiência;

  • legislação;

  • comunicação;

  • exceções;

  • conhecimento tácito.

Isso é chamado de visão sociotécnica.

O computador é apenas uma parte do sistema.


📜 CAPÍTULO 7 — EXISTE UM SISTEMA QUE NÃO ESTÁ NO COMPUTADOR

Imagine um processo de crédito.

O manual diz:

Pedido
  ↓
Análise
  ↓
Score
  ↓
Aprovação

Esse é o sistema formal.

Mas na prática acontece:

Pedido
 ↓
Analista
 ↓
Consulta sistema
 ↓
Liga para gerente
 ↓
"Conheço esse cliente."
 ↓
Consulta documento antigo
 ↓
Conversa com supervisor
 ↓
Exceção
 ↓
Aprovação

Isso também é um sistema de informação.

Só que parte dele é informal.

O perigo aparece quando alguém automatiza somente:

Pedido → Score → Aprovação

e acredita ter automatizado todo o processo.

Não automatizou.

Automatizou apenas a parte que conseguiu formalizar.


🔒 CAPÍTULO 8 — “O SISTEMA NÃO DEIXA”

Quem nunca ouviu:

“Não posso fazer. O sistema não deixa.”

Essa frase merece atenção.

O computador não acordou naquela manhã e decidiu impedir alguma coisa.

Alguém:

  1. definiu uma política;

  2. transformou-a em regra;

  3. especificou uma condição;

  4. programou;

  5. testou;

  6. colocou em produção.

Portanto:

"O SISTEMA NÃO DEIXA"

normalmente significa:

"UMA DECISÃO HUMANA FOI
FORMALIZADA EM SOFTWARE"

Mas existe um efeito psicológico interessante.

Depois que a regra entra no computador, ganha aparência de autoridade.

— Por que meu pedido foi recusado?

— O sistema recusou.

Como se o computador fosse uma entidade independente.


📡 CAPÍTULO 9 — DADO NÃO É INFORMAÇÃO

Considere:

327

O que significa?

Nada.

Agora:

327 ms

Melhor.

Depois:

CICS RESPONSE TIME = 327 ms

Agora temos informação contextualizada.

Mas ainda falta alguma coisa.

Imagine que historicamente aquela transação responde entre 80 e 150 ms.

Agora:

BASELINE = 120 ms
ATUAL    = 327 ms

Um especialista interpreta:

Existe degradação.

Investigando, encontra:

Db2 LOCK CONTENTION
       ↓
WAIT
       ↓
CICS RESPONSE TIME
       ↓
327 ms

Veja a transformação:

327
 ↓
DADO

327 ms
 ↓
CONTEXTO

CICS = 327 ms
 ↓
INFORMAÇÃO

327 > BASELINE
 ↓
INTERPRETAÇÃO

Db2 contention
 ↓
CONHECIMENTO

Investigar locking
 ↓
AÇÃO

Esse caminho é fundamental para entender sistemas de informação.


🔤 CAPÍTULO 10 — SEMIÓTICA ENTRA NA SALA DO CPD

Semiótica estuda sinais e significados.

Isso parece filosofia distante de COBOL.

Não é.

Considere:

RC=12

Para o computador são bits.

Para JES pode representar um retorno.

Para o operador:

— O job falhou.

Para o programador:

— Preciso verificar a step.

Para o negócio:

— O processamento não terminou.

Para o cliente:

— Meu pagamento não apareceu.

O mesmo sinal produziu significados diferentes.

Podemos simplificar:

SINAL
 +
CONTEXTO
 +
INTÉRPRETE
 =
SIGNIFICADO

O computador manipula sinais.

O significado surge da interpretação.


🤖 CAPÍTULO 11 — ENTÃO CHEGOU A INTELIGÊNCIA ARTIFICIAL

Agora a discussão fica extraordinariamente moderna.

Um LLM recebe tokens.

Processa tokens.

Produz tokens.

Nós olhamos para a saída e dizemos:

“A IA respondeu.”

Mas existe diferença entre:

TEXTO PLAUSÍVEL

e:

INFORMAÇÃO VERDADEIRA

E existe outra diferença entre:

INFORMAÇÃO

e:

DECISÃO SEGURA

Por isso surgiram discussões sobre:

  • hallucination;

  • grounding;

  • RAG;

  • provenance;

  • explainability;

  • human-in-the-loop;

  • governança;

  • validação.

O problema filosófico de Deep Thought voltou usando GPU.


⚠️ CAPÍTULO 12 — AUTOMATION BIAS

Imagine uma tela:

FRAUD RISK: 93.17%

Aquilo parece preciso.

93,17%.

Duas casas decimais!

Só que um bom engenheiro pergunta:

  • O que significa 93,17%?

  • Qual população foi utilizada?

  • Qual é o falso positivo?

  • O modelo está calibrado?

  • Houve drift?

  • Quais dados estão faltando?

  • Quem decidiu o threshold?

  • Existe direito de revisão?

Existe um fenômeno chamado automation bias: nossa tendência de atribuir confiança excessiva a resultados produzidos por sistemas automatizados.

Quanto mais bonita a interface, maior pode ser a tentação.


🪞 CAPÍTULO 13 — O BANCO DE DADOS NÃO CONTÉM O CLIENTE

Imagine uma tabela:

CUSTOMER

ID
NAME
ADDRESS
BALANCE
RISK_SCORE
STATUS

Existe uma pessoa dentro do Db2?

Não.

Existe uma representação computacional dela.

A pessoa real possui história, intenções, relações, circunstâncias e contexto.

O banco contém apenas atributos considerados relevantes para determinada finalidade.

Isso significa:

o modelo não é a realidade.

Todo sistema informatizado reduz alguma coisa.

REALIDADE
████████████████████████████

MODELO
██████████████████

REGRA
██████████

SOFTWARE
██████

DADOS
████

Cada camada perde contexto.


☁️ CAPÍTULO 14 — MODERNIZAR NÃO É TROCAR COBOL POR JAVA

Aqui encontramos uma das maiores armadilhas da modernização.

A empresa possui:

PROCESSO DE 1987
      ↓
COBOL

Decide modernizar:

COBOL
  ↓
JAVA
  ↓
MICROSERVICES
  ↓
CONTAINER
  ↓
KUBERNETES

Fantástico.

Agora temos:

um processo de 1987 executando lindamente dentro de containers.

Modernização tecnológica não garante modernização organizacional.

Antes de reescrever o programa, deveríamos perguntar:

— Essa regra ainda é necessária?

— Esse processo ainda faz sentido?

— Essa informação ainda precisa ser coletada?

— Essa aprovação ainda controla algum risco?

— Essa exceção ainda existe?

Às vezes a melhor linha de código modernizada é aquela que descobrimos que pode ser eliminada.


🦖 CAPÍTULO 15 — LEGACY NÃO SIGNIFICA INÚTIL

Tecnologia antiga possui algo que tecnologia nova ainda não conseguiu comprar:

história operacional.

COBOL, CICS, Db2 e z/OS possuem décadas de:

  • documentação;

  • correções;

  • conhecimento;

  • práticas operacionais;

  • troubleshooting;

  • compatibilidade;

  • experiência.

Tecnologia nova oferece possibilidades fantásticas.

Mas também pode trazer:

  • bugs desconhecidos;

  • escassez de especialistas;

  • documentação imatura;

  • mudanças rápidas;

  • APIs instáveis;

  • dependências novas.

Portanto:

NOVO ≠ MELHOR

e:

VELHO ≠ RUIM

A pergunta correta é:

ADEQUADO?

Deep Thought aprova.


💰 CAPÍTULO 16 — O LOCK-IN MAIS PERIGOSO NÃO É TECNOLÓGICO

Todo mundo conhece vendor lock-in.

Mas existe outro:

conceptual lock-in.

Quando compramos determinada tecnologia, começamos a enxergar todos os problemas através dela.

Quem vende blockchain encontra blockchain em tudo.

Quem vende RPA encontra processos para robotizar.

Quem vende cloud encontra workloads para migrar.

Quem vende GenAI encontra copilots.

Quem vende Agentic AI encontra agentes.

É a velha história:

Quando sua única ferramenta é um martelo, muitos problemas começam misteriosamente a parecer pregos.

A ferramenta passou a definir o problema.

Esse é o momento de chamar Deep Thought.


🚨 CAPÍTULO 17 — DEBUGGING DA ORGANIZAÇÃO

Imagine:

CLIENTES RECEBERAM COBRANÇA DUPLICADA.

O programador procura o programa.

Isso é necessário.

Mas uma verdadeira investigação pergunta:

Por que duplicação era possível?

Por que não havia idempotência?

Por que reconciliação não detectou?

Por que monitoramento não alertou?

Por que reprocessamento foi autorizado?

Por que o operador acreditou que era seguro?

A documentação explicava isso?

Quem conhecia a exceção?

Qual decisão organizacional criou essa condição?

Você deixou de simplesmente depurar COBOL.

Agora está:

debugando a organização.

Essa é uma habilidade extraordinária para quem trabalha com sistemas críticos.


🧭 CAPÍTULO 18 — PASSO A PASSO ANTES DE AUTOMATIZAR

Antes de escolher tecnologia, faça este exercício.

PASSO 1 — Defina o problema

Não escreva:

“Precisamos de IA.”

Escreva:

“Recebemos 30 mil solicitações mensais e 40% são classificadas manualmente.”

Agora temos problema.

PASSO 2 — Descubra quem participa

Liste:

usuário
operador
cliente
gestor
auditoria
segurança
compliance
sistemas

PASSO 3 — Mapeie o processo real

Não apenas o manual.

Observe o que as pessoas realmente fazem.

PASSO 4 — Procure exceções

Pergunte:

“Quando vocês não seguem esse procedimento?”

Essa pergunta vale ouro.

PASSO 5 — Descubra conhecimento tácito

Pergunte ao operador experiente:

“Como você sabe que alguma coisa está errada?”

A resposta pode revelar conhecimento inexistente na documentação.

PASSO 6 — Defina o que pode ser formalizado

Nem todo julgamento humano precisa virar IF.

PASSO 7 — Defina risco

O que acontece quando a automação erra?

PASSO 8 — Escolha tecnologia

Só agora.

COBOL?

Java?

Python?

RPA?

IA?

Nada?

Sim.

“Nada” também é uma alternativa arquitetural válida.


🤖 CAPÍTULO 19 — AGENTES DE IA TORNAM TUDO MAIS SÉRIO

Antigamente:

HUMANO
 ↓
SISTEMA
 ↓
RESULTADO
 ↓
HUMANO

O humano interpretava antes de agir.

Com agentes podemos construir:

HUMANO
 ↓
AGENTE
 ↓
LLM
 ↓
API
 ↓
SISTEMA
 ↓
DECISÃO
 ↓
OUTRA API
 ↓
AÇÃO

Agora a pergunta muda.

Não basta perguntar:

“A resposta está correta?”

Precisamos perguntar:

“O sistema possui autoridade para agir?”

Isso introduz:

  • identidade;

  • autorização;

  • segregação de funções;

  • auditoria;

  • rollback;

  • limites;

  • aprovação;

  • rastreabilidade;

  • responsabilidade.

Para quem conhece RACF, pense assim:

Não basta o agente saber como executar uma operação.

Precisamos definir quem ele representa, qual recurso pode acessar e com qual autoridade.

IA também precisa de RACF emocional.

Easter egg encontrado. ☕


👑 CAPÍTULO 20 — RESPONSABILIDADE É O CAMPO QUE NÃO CABE NO COPYBOOK

Imagine:

DADO
 ↓
ALGORITMO
 ↓
RESULTADO
 ↓
INTERPRETAÇÃO
 ↓
DECISÃO
 ↓
AÇÃO
 ↓
CONSEQUÊNCIA

Existe mais uma etapa:

RESPONSABILIDADE

Quem responde?

O programador?

O usuário?

O fornecedor?

O gestor?

Quem aprovou?

Quem definiu a regra?

Quem forneceu os dados?

Quem autorizou a automação?

Sistemas críticos não podem terminar em:

MOVE '42' TO WS-RESPOSTA.

Precisamos saber por que 42 existe e o que alguém pretende fazer com ele.


🧪 CAPÍTULO 21 — O TESTE DE DEEP THOUGHT

Na próxima reunião em que alguém anunciar:

“Precisamos colocar IA nisso!”

não comece discutindo modelo.

Pergunte:

Qual problema estamos tentando resolver?

Depois:

Como sabemos que esse problema existe?

Depois:

Como medimos seu tamanho?

Depois:

Quem é afetado?

Depois:

Como resolvemos atualmente?

Depois:

Quais exceções existem?

Depois:

Que conhecimento não está documentado?

Depois:

Qual erro é aceitável?

Depois:

Quem interpreta a saída?

Depois:

Quem responde se estiver errada?

E finalmente faça a pergunta assassina:

O que acontece se não comprarmos tecnologia nenhuma?

Às vezes a resposta será:

Nada.

Parabéns.

Você talvez tenha acabado de economizar alguns milhões.


🎁 CURIOSIDADE — A TECNOLOGIA MAIS NOVA PODE SER A MAIS ARRISCADA

Existe uma expressão interessante:

bleeding edge.

Podemos imaginar:

BLEEDING EDGE
      ↓
LEADING EDGE
      ↓
MATURE
      ↓
LEGACY
      ↓
OBSOLETE

Observe uma coisa importante:

legacy e obsolete não são sinônimos.

Um sistema pode ser legado e continuar:

  • suportado;

  • confiável;

  • economicamente adequado;

  • seguro;

  • crítico.

Da mesma maneira, uma tecnologia novíssima pode ser completamente inadequada ao problema.

Idade é apenas uma variável.


🥚 EASTER EGG — JOB DEEPTHOT

Nos confins da spool existe um job misterioso:

//DEEPTHOT JOB (42),'UNIVERSE'
//STEP01   EXEC PGM=QUESTION
//SYSOUT   DD SYSOUT=*
//SYSIN    DD *
 LIFE
 UNIVERSE
 EVERYTHING
/*

Depois de milhões de anos de CPU:

IEF142I DEEPTHOT STEP01 - STEP WAS EXECUTED

ANSWER = 42

MAXCC = 0000

O job terminou perfeitamente.

MAXCC=0000.

Nenhum ABEND.

Nenhum dump.

Nenhum erro.

E mesmo assim...

ninguém sabe o que fazer com o resultado.

Esse talvez seja o exemplo perfeito de que:

EXECUÇÃO CORRETA
       ≠
PROBLEMA CORRETAMENTE RESOLVIDO

☕ EPÍLOGO — O PROGRAMADOR COBOL QUE APRENDEU A PERGUNTAR

Nosso jovem programador volta para a War Room.

Alguém pergunta:

— Então vamos migrar o programa?

Ele responde:

— Talvez.

— Java?

— Talvez.

— Cloud?

— Talvez.

— IA?

— Talvez.

O gerente começa a perder a paciência.

— Então qual é a sua recomendação?

O programador olha novamente para o programa COBOL de 35 anos.

Depois pergunta:

Qual problema estamos tentando resolver?

Silêncio.

Deep Thought sorri em algum lugar do Universo.

Porque naquele instante o iniciante deixou de ser simplesmente alguém que escreve COBOL.

Começou a pensar como engenheiro.

Tecnologia não existe isoladamente.

Computadores fazem parte de sistemas sociais.

Dados precisam de contexto.

Sinais precisam de interpretação.

Regras carregam decisões humanas.

Código carrega história.

Automação carrega responsabilidade.

IA não elimina esses problemas.

Amplifica-os.

E modernização não significa trocar uma linguagem velha por uma linguagem nova.

Significa compreender suficientemente bem o sistema para decidir conscientemente o que deve permanecer, o que deve mudar, o que deve ser automatizado e o que nunca deveria ter existido.

Talvez essa seja uma das maiores lições para qualquer programador COBOL entrando no mundo dos sistemas corporativos:

Não se apaixone primeiro pela resposta. Apaixone-se pelo problema.

Porque hardware muda.

Linguagens mudam.

Arquiteturas mudam.

Mainframes evoluem.

Cloud evolui.

IA evolui.

Os vendedores continuarão chegando com respostas extraordinárias.

Mas alguém ainda precisará fazer aquela pergunta incômoda na reunião:

“Qual era mesmo o problema?”

E quando ninguém souber responder...

há sempre uma resposta tecnicamente disponível.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. DEEP-THOUGHT.

       PROCEDURE DIVISION.

           MOVE 42 TO WS-ANSWER

           DISPLAY
             'THE ANSWER TO LIFE,'
             ' THE UNIVERSE AND EVERYTHING: '
             WS-ANSWER

           STOP RUN.

MAXCC=0000.

Resposta encontrada.

Projeto entregue.

Produção estável.

Só faltou um pequeno requisito:

descobrir a pergunta.

☕💻

EASTER EGG FINAL: se este artigo fosse um job de produção, eu verificaria o spool às 03:17. Deep Thought provavelmente estaria esperando por lá, tentando descobrir por que alguém abriu um incidente para corrigir um 42 que estava funcionando exatamente como especificado.

Máxima Bellacosa

O job pode terminar com MAXCC=0000, entregar 42 e ainda assim o projeto inteiro estar errado — porque ninguém perguntou se aquela era a pergunta que precisava ser respondida.


🌑 CID KAGENOU E A CAIXA-PRETA DOS AUTÔMATOS — QUANDO O COBOL DESCOBRIU QUE TAMBÉM ERA UMA MÁQUINA DE ESTADOS

 

Bellacosa Mainframe e a caixa preta do automatos

☕ Um Café no Bellacosa Mainframe

🌑 CID KAGENOU E A CAIXA-PRETA DOS AUTÔMATOS — QUANDO O COBOL DESCOBRIU QUE TAMBÉM ERA UMA MÁQUINA DE ESTADOS

Autômatos finitos, máquinas de estados, linguagens regulares, regex, engenharia reversa, CPU, COBOL, testes, protocolos, segurança — e o dia em que Shadow descobriu que não precisava abrir a caixa-preta para descobrir o segredo escondido dentro dela.



🎬 PRÓLOGO — HÁ ALGUMA COISA ESCONDIDA NESSA CAIXA

Imagine Cid Kagenou entrando em uma dungeon.

Nenhum monstro.

Nenhum artefato mágico.

Nenhuma princesa sequestrada.

Alpha olha desconfiada para o centro da sala.

Ali existe apenas uma pequena caixa preta.

Na frente dela:

  • um terminal de entrada;

  • uma pequena lâmpada;

  • um botão escrito RESET.

Beta examina o equipamento.

— Shadow-sama, devemos desmontá-lo?

Cid cruza os braços.

— Não.

Silêncio dramático.

Naturalmente, todos imaginam que Shadow descobriu algum segredo ancestral.

Na realidade, ele simplesmente não sabe como abrir a caixa.

Mas, como frequentemente acontece em The Eminence in Shadow, uma frase improvisada acaba contendo uma ideia surpreendentemente profunda:

Não precisamos conhecer o interior de uma máquina para estudar seu comportamento.

E é justamente assim que começa nossa excursão pela Teoria dos Autômatos.

Pegue seu café.

Aperte o cinto.

Nosso ônibus vai balançar um pouco.



🚌 CAPÍTULO 1 — O ÔNIBUS DE TURING CHEGA À DUNGEON

A inspiração desta viagem vem de A. K. Dewdney, autor de The Turing Omnibus, livro concebido como uma série de excursões por diferentes territórios da Ciência da Computação.

A metáfora é maravilhosa.

Em vez de imaginar Ciência da Computação como um gigantesco manual técnico, imagine um ônibus.

Em cada parada visitamos alguma região:

AUTÔMATOS
     ↓
LINGUAGENS FORMAIS
     ↓
ALGORITMOS
     ↓
LÓGICA
     ↓
COMPLEXIDADE
     ↓
COMPUTABILIDADE
     ↓
INTELIGÊNCIA ARTIFICIAL
     ↓
...

Na primeira excursão encontramos justamente uma criatura aparentemente humilde:

o autômato finito.

Não deixe o nome assustar.

Vamos desmontar o conceito — sem desmontar nossa caixa.



📦 CAPÍTULO 2 — SHADOW ENCONTRA UMA CAIXA-PRETA

Nossa máquina possui uma entrada capaz de receber dois sinais:

0
1

Também possui uma lâmpada.

Quando determinada sequência é fornecida, a lâmpada eventualmente acende.

Podemos representar a máquina assim:

             ┌──────────────────────┐
0 ou 1 ─────►│                      │
             │      CAIXA-PRETA     │────► 💡
RESET ──────►│                      │
             └──────────────────────┘

Não sabemos o que existe dentro.

Pode haver:

transistores
circuitos
flip-flops
microcontrolador
relés
magia negra
um COBOL de 1978

Para nossa análise, isso não importa.

Estamos interessados em:

ENTRADA → COMPORTAMENTO → SAÍDA

Essa é uma abstração extremamente importante na computação.

Um programa COBOL pode executar:

CALL 'PAGTO001'

Você não precisa necessariamente conhecer cada instrução existente em PAGTO001 para utilizar sua interface corretamente.

Da mesma maneira, quando consumimos uma API:

POST /pagamento

podemos trabalhar com o contrato da API sem conhecer toda sua implementação.

A primeira lição da dungeon é, portanto:

Implementação e comportamento são coisas diferentes.



🧪 CAPÍTULO 3 — ALPHA COMEÇA OS EXPERIMENTOS

Vamos alimentar nossa máquina.

Depois de pressionar RESET:

0

Nada.

1

Nada.

0

Nada.

1

💡

A lâmpada acendeu.

Descobrimos:

0101

parece ser uma sequência aceita.

Alpha repete imediatamente:

0101

Nada.

Beta começa a escrever um relatório de 847 páginas explicando que provavelmente se trata de um artefato demoníaco.

Até alguém lembrar:

RESET.

Pressionamos RESET.

Executamos novamente:

0101

💡

Funciona.

Isso revela uma informação gigantesca.

A máquina lembra alguma coisa do que aconteceu anteriormente.



🧠 CAPÍTULO 4 — O SEGREDO CHAMA-SE ESTADO

Se a saída dependesse somente do último símbolo recebido, bastaria analisar:

entrada atual

Mas nossa experiência demonstra que o comportamento depende também da história anterior.

Existe alguma espécie de memória.

Na teoria dos autômatos chamamos essa informação de:

ESTADO

Estado não significa necessariamente uma variável armazenada em RAM.

Uma definição muito melhor seria:

Estado é a informação relevante sobre o passado necessária para decidir o comportamento futuro.

Essa frase vale ouro.

Imagine uma porta eletrônica.

Ela poderia possuir:

LOCKED
UNLOCKED

Quando recebe:

CARD_VALID

pode fazer:

LOCKED → UNLOCKED

Quando alguém abre a porta:

UNLOCKED → LOCKED

Não precisamos registrar toda a biografia da pessoa:

acordou às 07:00
tomou café
pegou o carro
chegou ao escritório
tirou o cartão do bolso
...

Nada disso interessa à porta.

A informação relevante é:

LOCKED

ou:

UNLOCKED

O estado é, portanto, uma espécie de compressão do passado.


🌑 CAPÍTULO 5 — SHADOW GARDEN DESCOBRE A MÁQUINA DE ESTADOS

Imagine uma catraca.

Estados:

Q0 = LOCKED
Q1 = UNLOCKED

Entradas:

COIN
PUSH

Podemos definir:

LOCKED + COIN → UNLOCKED
LOCKED + PUSH → LOCKED

UNLOCKED + PUSH → LOCKED
UNLOCKED + COIN → UNLOCKED

Isso pode ser colocado numa tabela:

Estado atualEntradaNovo estado
LOCKEDCOINUNLOCKED
LOCKEDPUSHLOCKED
UNLOCKEDPUSHLOCKED
UNLOCKEDCOINUNLOCKED

Temos uma máquina de estados.

E provavelmente você já programou alguma sem saber.


🧙 CAPÍTULO 6 — A DEFINIÇÃO MATEMÁTICA

Um autômato finito determinístico costuma ser definido pela quíntupla:

M = (Q, Σ, δ, q0, F)

Calma.

Não invoque ainda o compilador COBOL.

Vamos traduzir.

Q — conjunto de estados

Por exemplo:

Q = {q0,q1,q2,q3,q4,q5}

Σ — alfabeto

São os símbolos aceitos como entrada.

No nosso exemplo:

Σ = {0,1}

δ — função de transição

A famosa letra grega delta determina:

estado atual + entrada → próximo estado

Formalmente:

δ : Q × Σ → Q

Por exemplo:

δ(q3,0)=q5
δ(q3,1)=q4

q0 — estado inicial

É onde começamos depois do RESET.

F — estados finais

São os estados considerados de aceitação.

Quando terminamos de processar a entrada em algum deles:

💡

A sequência foi aceita.


💾 CAPÍTULO 7 — DELTA DESCOBRE QUE DELTA NÃO É APENAS UMA PERSONAGEM

Imagine a surpresa da própria Delta ao descobrir que existe uma função matemática chamada δ.

Se estivermos em:

q3

e recebermos:

1

podemos ter:

δ(q3,1)=q4

Isso significa simplesmente:

ESTADO ATUAL = Q3
ENTRADA = 1
NOVO ESTADO = Q4

Não existe mistério.

Na prática, poderíamos implementar isso em COBOL.


💻 CAPÍTULO 8 — O AUTÔMATO ENTRA NO COBOL

Considere:

01 WS-STATE       PIC X(02).
01 WS-INPUT       PIC X.

MOVE 'Q0' TO WS-STATE.

EVALUATE TRUE

   WHEN WS-STATE = 'Q0'
        AND WS-INPUT = '0'
        MOVE 'Q1' TO WS-STATE

   WHEN WS-STATE = 'Q0'
        AND WS-INPUT = '1'
        MOVE 'Q0' TO WS-STATE

   WHEN WS-STATE = 'Q1'
        AND WS-INPUT = '0'
        MOVE 'Q1' TO WS-STATE

   WHEN WS-STATE = 'Q1'
        AND WS-INPUT = '1'
        MOVE 'Q2' TO WS-STATE

END-EVALUATE.

Parabéns.

Acabamos de implementar parte de um autômato finito.

Uma implementação mais organizada poderia separar:

READ-INPUT
PROCESS-TRANSITION
CHECK-FINAL-STATE

Observe como conceitos aparentemente matemáticos começam a aparecer naturalmente no COBOL.


🔄 CAPÍTULO 9 — O RESET É O INITIALIZE DA DUNGEON

O botão RESET possui uma importância enorme.

Ele coloca a máquina novamente em:

q0

Imagine testar:

0101

e depois:

0100101

sem RESET.

O segundo teste não começa realmente do zero.

A máquina pode estar carregando o estado produzido pelo primeiro.

Na prática estamos testando algo parecido com:

01010100101

Isso possui uma conexão direta com testes de software.

Um teste confiável deve começar de condições conhecidas.

Algo como:

GIVEN estado conhecido
WHEN evento acontece
THEN resultado esperado

Em COBOL isso poderia significar:

INITIALIZE WS-AREA
MOVE ZERO TO WS-COUNTER
MOVE '00' TO WS-STATUS

Estado residual é uma fonte clássica de bugs.


🔬 CAPÍTULO 10 — SHADOW COMEÇA A ENGENHARIA REVERSA

Executamos vários experimentos.

Descobrimos que a caixa aceita:

0101
0100101
0100100101
0100100100101

Vamos reorganizar:

01             01
01 001         01
01 001 001     01
01 001 001 001 01

Há claramente um padrão:

01 (001)* 01

O símbolo:

*

é chamado estrela de Kleene.

Significa:

zero ou mais repetições.

Portanto:

(001)*

pode produzir:

ε
001
001001
001001001
001001001001
...

ε representa a palavra vazia.

Consequentemente:

01(001)*01

produz:

0101
0100101
0100100101
0100100100101
...

Acabamos de entrar no território das linguagens regulares.


📜 CAPÍTULO 11 — REGEX NÃO NASCEU PARA VALIDAR E-MAIL

Quando alguém fala em expressão regular, muitos programadores imediatamente pensam:

^[0-9]{5}-[0-9]{3}$

CEP.

Ou alguma criatura monstruosa utilizada para validar endereço de e-mail.

Mas existe uma teoria matemática muito mais profunda por trás disso.

A relação fundamental é:

┌─────────────────────┐
│ EXPRESSÃO REGULAR   │
└──────────┬──────────┘
           │
           ⇅
┌─────────────────────┐
│ AUTÔMATO FINITO     │
└──────────┬──────────┘
           │
           ⇅
┌─────────────────────┐
│ LINGUAGEM REGULAR   │
└─────────────────────┘

Essas são diferentes maneiras de descrever a mesma classe fundamental de linguagens.

Uma regex pode ser transformada em um autômato.

Um autômato pode ser utilizado para reconhecer uma linguagem regular.

Essa relação aparece na implementação de scanners, parsers simples, ferramentas de busca e compiladores.


⚠️ CAPÍTULO 12 — CID PERCEBE O PROBLEMA DA INDUÇÃO

Agora surge uma questão maravilhosa.

Testamos:

0101
0100101
0100100101
0100100100101

Todas funcionaram.

Podemos afirmar que:

01(001)*01

é realmente a linguagem completa da máquina?

Não.

Talvez a máquina aceite apenas:

n <= 4

Talvez rejeite a quinta repetição.

Ou a número 847.

Ou talvez exista algum comportamento especial depois de 65.535 símbolos.

Experimentar alguns casos não demonstra automaticamente uma regra infinita.

Esse é um princípio extremamente importante também para testes.


🧪 CAPÍTULO 13 — “FUNCIONOU NO MEU TESTE”

O programador executa:

100 → OK
200 → OK
300 → OK
400 → OK

e declara:

— Funciona.

Shadow aparece atrás dele.

— Você testou 32767?

Silêncio.

— E 32768?

Mais silêncio.

— 99999999?

O programador começa a suar.

Testes demonstram comportamento para os casos efetivamente observados.

Não provam automaticamente comportamento universal.

É exatamente o problema encontrado na caixa-preta.


🕵️ CAPÍTULO 14 — MAS E SE SOUBERMOS QUANTOS ESTADOS EXISTEM?

Agora alguém nos fornece uma informação adicional:

A máquina possui seis estados.

Isso muda profundamente o problema.

Imagine:

q0
q1
q2
q3
q4
q5

Depois de transições suficientes, algum estado inevitavelmente precisará reaparecer.

Por quê?

Porque só existem seis possibilidades.

Se continuarmos andando:

q0 → q1 → q2 → q3 → q4 → q5 → ?

o próximo estado necessariamente será algum estado já existente.

Surge então um ciclo:

        ┌──────────────┐
        ↓              │
q2 → q3 → q4 → q5 ────┘

E ciclos explicam repetições.

Como:

(001)*

Aqui começamos a enxergar a intuição que posteriormente aparece em resultados como o Pumping Lemma.


🏰 CAPÍTULO 15 — EXISTEM MONSTROS QUE O AUTÔMATO NÃO CONSEGUE DERROTAR

Considere:

ab
aabb
aaabbb
aaaabbbb

A regra é:

aⁿbⁿ

Precisamos garantir:

quantidade de a = quantidade de b

Agora imagine:

aaaaaaaaaaaaaaaa....

Para saber quantos b deverão aparecer posteriormente, precisamos lembrar quantos a foram encontrados.

Mas nosso autômato possui memória finita.

Se existem apenas:

q0 q1 q2 q3 q4 q5

como representar:

1
2
3
4
...
1.000.000

quantidades diferentes?

Não consegue.

Encontramos uma fronteira computacional.


🪜 CAPÍTULO 16 — A ESCADA DAS MÁQUINAS

Quando precisamos de memória adicional, utilizamos modelos mais poderosos.

De forma simplificada:

AUTÔMATO FINITO
       ↓
AUTÔMATO COM PILHA
       ↓
MODELOS MAIS PODEROSOS
       ↓
MÁQUINA DE TURING

O autômato com pilha pode trabalhar com estruturas como:

((()))

Cada abertura:

(

pode empilhar alguma informação.

Cada fechamento:

)

remove algo da pilha.

Isso permite reconhecer estruturas que um simples autômato finito não consegue reconhecer.

E estamos nos aproximando da Hierarquia de Chomsky e da teoria das linguagens formais.

A pequena lâmpada começou a ficar perigosamente interessante.


🖥️ CAPÍTULO 17 — ESTÁVAMOS ESTUDANDO UMA CPU?

Existe uma bela provocação no texto original adaptado:

estivemos estudando o funcionamento de uma CPU simples.

Precisamos colocar uma pequena ressalva técnica.

Uma CPU moderna não é simplesmente aquele pequeno DFA.

Entretanto, componentes de hardware e circuitos sequenciais podem ser modelados por máquinas de estados.

Imagine:

FETCH
  ↓
DECODE
  ↓
EXECUTE
  ↓
MEMORY
  ↓
WRITEBACK
  ↓
FETCH

O processador possui estados internos.

Sinais e resultados influenciam as próximas transições.

Assim, a teoria dos autômatos possui ligação genuína com projeto de hardware.


🏧 CAPÍTULO 18 — VOCÊ ESTÁ CERCADO POR MÁQUINAS DE ESTADOS

Olhe ao redor.

Um elevador:

STOPPED
MOVING_UP
MOVING_DOWN
DOOR_OPEN
DOOR_CLOSING

Um caixa eletrônico:

IDLE
 ↓
CARD_INSERTED
 ↓
PIN_VALIDATED
 ↓
AUTHENTICATED
 ↓
TRANSACTION
 ↓
EJECT_CARD

Uma aplicação:

LOGGED_OUT
 ↓
AUTHENTICATING
 ↓
LOGGED_IN
 ↓
SESSION_EXPIRED

Um pedido:

CREATED
 ↓
PAID
 ↓
PROCESSING
 ↓
SHIPPED
 ↓
DELIVERED

Até muitos protocolos de rede podem ser entendidos como máquinas de estados.


💳 CAPÍTULO 19 — O AUTÔMATO ENTRA NO MAINFRAME

Agora imagine processamento de cartões.

Uma transação poderia atravessar:

RECEIVED
    ↓
VALIDATED
    ↓
AUTHORIZED
    ↓
CAPTURED
    ↓
SETTLED

Ou:

RECEIVED
    ↓
VALIDATED
    ↓
DECLINED

Isso poderia estar espalhado por:

COBOL
CICS
Db2
VSAM
IBM MQ
batch
APIs

Mas conceitualmente temos uma máquina de estados.

Um programa poderia fazer:

EVALUATE WS-STATUS

   WHEN 'RECEIVED'
        PERFORM 2000-VALIDATE

   WHEN 'VALIDATED'
        PERFORM 3000-AUTHORIZE

   WHEN 'AUTHORIZED'
        PERFORM 4000-CAPTURE

   WHEN 'CAPTURED'
        PERFORM 5000-SETTLEMENT

END-EVALUATE.

O programador COBOL está implementando teoria dos autômatos sem necessariamente perceber.


⚔️ CAPÍTULO 20 — A TRANSIÇÃO PROIBIDA

Aqui aparece uma aplicação extremamente útil para manutenção de sistemas legados.

A documentação diz:

CREATED → PAID → SHIPPED

Mas encontramos:

CREATED → SHIPPED

Pergunta:

essa transição é válida?

Talvez tenhamos encontrado o bug.

Em vez de olhar apenas para milhares de linhas COBOL, podemos tentar descobrir:

ESTADOS
EVENTOS
TRANSIÇÕES
ESTADOS FINAIS

Um programa de 12.000 linhas talvez possa ser resumido como:

14 estados
43 transições
11 eventos
5 estados finais

Isso é ouro para engenharia reversa.


🔥 CAPÍTULO 21 — WAR ROOM ÀS 03:17

03:17.

Naturalmente.

O telefone toca.

Produção caiu.

No log:

03:17:00 RECEIVED
03:17:01 VALIDATED
03:17:02 AUTHORIZED
03:17:03 CAPTURED
03:17:04 ERROR

O programador procura:

IF
EVALUATE
GO TO
PERFORM

O DBA examina Db2.

O especialista CICS olha dumps.

O pessoal de infraestrutura examina CPU.

Shadow permanece no fundo da sala.

Até fazer uma pergunta:

CAPTURED → ERROR é uma transição permitida?

Silêncio.

Talvez o problema não esteja em uma instrução individual.

Talvez exista uma transição de negócio impossível.

E aí está nosso easter egg das 03:17.


🛡️ CAPÍTULO 22 — O AUTÔMATO VIRA RED TEAM

Máquinas de estados também ajudam a pensar segurança.

Imagine:

DISCONNECTED
     ↓ LOGIN
AUTHENTICATING
     ↓ SUCCESS
AUTHENTICATED

Mas alguém descobre:

DISCONNECTED
     ↓ EVENTO-X
ADMIN

Isso é interessantíssimo.

O atacante encontrou uma transição que não deveria existir.

Problemas semelhantes aparecem em:

protocolos
autenticação
workflows
APIs
sistemas distribuídos
model-based testing
fuzzing
engenharia reversa

Uma excelente estratégia de segurança é perguntar:

Quais estados existem e quais transições deveriam ser impossíveis?


🤖 CAPÍTULO 23 — A CAIXA-PRETA ENCONTRA A INTELIGÊNCIA ARTIFICIAL

Existe ainda uma conexão conceitual com IA.

Nosso experimento faz:

ENTRADAS
   ↓
OBSERVAÇÕES
   ↓
HIPÓTESE
   ↓
MODELO

Em aprendizado de máquina fazemos, em sentido muito amplo:

DADOS
   ↓
PADRÕES
   ↓
MODELO

Naturalmente um LLM moderno não deve ser confundido com o pequeno autômato da nossa dungeon.

Mas existe uma pergunta epistemológica comum:

Quanto podemos descobrir sobre um sistema observando somente seu comportamento externo?

Essa questão reaparece quando trabalhamos com sistemas proprietários, serviços remotos e modelos aos quais não temos acesso interno.

A caixa-preta continua conosco.


🔧 CAPÍTULO 24 — COMO USAR ESSA IDEIA NUM COBOL LEGADO

Agora uma dica extremamente prática.

Você recebe um programa desconhecido.

Não comece tentando entender todas as linhas simultaneamente.

PASSO 1 — descubra as entradas

Procure:

arquivos
COMMAREA
MQ
parâmetros
Db2
VSAM
SYSIN

PASSO 2 — identifique os estados

Procure campos como:

STATUS
STATE
SITUATION
TYPE
PHASE
STAGE
FLAG

PASSO 3 — encontre onde mudam

Pesquise:

MOVE 'XX' TO WS-STATUS

ou:

SET STATUS-APPROVED TO TRUE

PASSO 4 — construa uma tabela

Por exemplo:

EstadoEventoPróximo estado
RECEIVEDVALIDVALIDATED
RECEIVEDINVALIDREJECTED
VALIDATEDAPPROVEAUTHORIZED
VALIDATEDDENYDECLINED

PASSO 5 — desenhe o diagrama

Você pode descobrir uma arquitetura lógica que ninguém documentou.

PASSO 6 — procure transições impossíveis

Pergunte:

REJECTED → SETTLED ?
CANCELLED → AUTHORIZED ?
SHIPPED → CREATED ?

Esses caminhos merecem investigação.


🧠 CAPÍTULO 25 — O VERDADEIRO PODER DA ABSTRAÇÃO

Observe tudo que removemos da caixa:

voltagem
resistores
transistores
temperatura
fiação
material
clock
fabricante

E preservamos:

Q
Σ
δ
q0
F

Esse processo chama-se abstração.

Não estamos dizendo que detalhes físicos não existem.

Estamos dizendo:

para responder determinada pergunta, eles não são necessários.

Isso aparece em toda a computação.

Quando trabalhamos com COBOL:

arquivo lógico

podemos não precisar conhecer imediatamente a geometria física do disco.

Quando usamos Db2:

SELECT ...

não precisamos controlar manualmente cada bloco armazenado.

Quando utilizamos MQ:

PUT
GET

trabalhamos sobre uma abstração.

Camadas de abstração são uma das razões pelas quais conseguimos construir sistemas gigantescos.


☕ EPÍLOGO — SHADOW DESCOBRE O QUE SIGNIFICA COMPUTAR

Nossa excursão começou com:

0
1
RESET
💡

Parecia quase infantil.

Mas então descobrimos:

caixa-preta
     ↓
estado
     ↓
transição
     ↓
autômato
     ↓
linguagem
     ↓
expressão regular
     ↓
limites de memória
     ↓
linguagens formais
     ↓
computabilidade

Essa é a beleza da Ciência da Computação.

COBOL é importante.

Python é importante.

Java é importante.

Assembler é importante.

Mas existe um universo abaixo das linguagens:

LÓGICA
AUTÔMATOS
ALGORITMOS
LINGUAGENS FORMAIS
COMPLEXIDADE
COMPUTABILIDADE
INFORMAÇÃO

Um programador pode passar décadas escrevendo programas sem visitar profundamente esse território.

Mas quando começa a estudá-lo, algo muda.

Ele deixa de enxergar apenas:

IF
MOVE
PERFORM
EVALUATE

e começa a enxergar:

ESTADOS
TRANSIÇÕES
LINGUAGENS
MODELOS
INVARIANTES
LIMITES

E isso muda inclusive a maneira de investigar um COBOL legado.

Aquele monstro de 15.000 linhas talvez não seja simplesmente um amontoado de PERFORM, IF, copybooks e tabelas Db2.

Talvez escondido lá dentro exista algo muito mais elegante:

             ┌─────────────┐
             │  RECEIVED   │
             └──────┬──────┘
                    ↓
             ┌─────────────┐
             │  VALIDATED  │
             └──────┬──────┘
                ┌───┴───┐
                ↓       ↓
          AUTHORIZED  DECLINED
                ↓
            CAPTURED
                ↓
             SETTLED

Uma máquina de estados.

Uma descendente conceitual daquela pequena caixa-preta.

E talvez essa seja a grande lição deixada pela primeira parada do ônibus de Dewdney.

Não precisamos começar abrindo a máquina.

Primeiro podemos observar.

Experimentar.

Modelar.

Formular hipóteses.

Descobrir estados.

Mapear transições.

Procurar ciclos.

Encontrar exceções.

E somente depois descer às entranhas da implementação.

Alpha observa o diagrama.

Beta termina o volume 37 de As Crônicas Secretas da Máquina de Estados de Shadow-sama.

Delta continua indignada porque roubaram seu nome para uma função matemática.

Cid olha para a caixa-preta.

A lâmpada acende.

0100100101

Ele sorri.

— Exatamente como eu havia previsto.

Não havia previsto coisa nenhuma.

Mas desta vez estava correto.

Um Café no Bellacosa Mainframe

Porque algumas vezes compreender 15.000 linhas de COBOL começa desenhando seis círculos e algumas flechas em um pedaço de papel.

sexta-feira, 21 de dezembro de 2001

Fushigi Yūgi: Eikoden - Quando um Programador COBOL Descobre que Restaurar um Backup Antigo Também Pode Restaurar Bugs que Nunca Deveriam Voltar

 

Bellacosa Mainframe apresenta fushigi yugi eikoden

☕ Um Café no Bellacosa Mainframe

Fushigi Yūgi: Eikoden (ふしぎ遊戯 永光伝) sem Mistérios

Quando um Programador COBOL Descobre que Restaurar um Backup Antigo Também Pode Restaurar Bugs que Nunca Deveriam Voltar

Depois do anime original, do primeiro OVA e de Dai Ni Bu, parecia que finalmente todos os JOBs haviam terminado com RC=0000.

Miaka e Taka (a reencarnação de Tamahome) finalmente construíram uma vida juntos.

Os Guerreiros de Suzaku seguiram seus caminhos.

O livro dos Quatro Deuses parecia definitivamente fechado.

Mas...

Todo profissional de mainframe conhece aquela cena.

Você termina um projeto gigantesco.

Arquiva toda a documentação.

Fecha os chamados.

Então alguém pergunta:

"Será que conseguimos restaurar aquele backup de três anos atrás?"

Cinco minutos depois...

O ambiente inteiro voltou a executar rotinas antigas.

É exatamente essa a proposta de Fushigi Yūgi: Eikoden.

Não é apenas uma continuação.

É uma reflexão sobre pessoas que vivem presas ao passado enquanto tentam reescrever uma história que já encontrou seu final.


Ficha Técnica

Título Original: ふしぎ遊戯 永光伝 (Fushigi Yūgi: Eikoden)

Título Internacional: Fushigi Yūgi: Eikoden

Baseado em: Light novels de Megumi Nishizaki, ilustradas por Yuu Watase

Universo Original: Fushigi Yūgi

Estúdio: Studio Pierrot

Direção: Nanako Shimazaki

Roteiro: Hiroaki Satō

Lançamento:

  • 21 de dezembro de 2001

  • 25 de junho de 2002 (último episódio)

Formato

OVA (Original Video Animation)

Quantidade de episódios

4 episódios (Wikipedia)


Gênero

  • Isekai

  • Fantasia

  • Romance

  • Drama

  • Shōjo

  • Sobrenatural


Classificação

14 anos.

Possui violência moderada, temas psicológicos, conflitos emocionais e elementos sobrenaturais.


Sinopse

Três anos após os acontecimentos da história principal, Miaka e Taka vivem felizes e esperam seu primeiro filho.

Enquanto isso, uma estudante chamada Mayo Sakaki, solitária e profundamente infeliz, encontra o lendário Livro dos Quatro Deuses.

Consumida pelo desejo de escapar da própria realidade, Mayo entra no livro e passa a acreditar que pode substituir Miaka como sacerdotisa de Suzaku.

Sua obsessão ameaça alterar o equilíbrio entre os dois mundos.


Resumo da História

Diferentemente das animações anteriores, Eikoden muda completamente o ponto de vista.

Agora acompanhamos uma protagonista diferente.

Mayo representa uma garota comum que deseja fugir da realidade.

Ao entrar no livro, ela encontra exatamente aquilo que sempre sonhou:

Um mundo onde acredita poder ser especial.

Mas logo percebe que viver dentro de uma fantasia não significa apagar suas dores.

Enquanto tenta tomar o lugar de Miaka, acaba colocando em risco toda a estabilidade conquistada pelos Guerreiros de Suzaku.


Os Personagens

Mayo Sakaki

A nova protagonista.

Insegura.

Solitária.

Carente.

Sua maior batalha acontece dentro de si mesma.

É provavelmente a personagem mais controversa de toda a franquia.


Miaka Yūki

Agora adulta.

Casada.

Grávida.

Representa maturidade.

Sua evolução desde o anime original fica evidente.


Taka (Tamahome)

A reencarnação de Tamahome.

Mais experiente e protetor.

Sua prioridade deixa de ser a aventura.

Agora é proteger sua família.


Os Guerreiros de Suzaku

Retornam para ajudar a enfrentar a nova crise.

Mais do que guerreiros, tornam-se guardiões da história que ajudaram a construir.


O que há de diferente?

Praticamente tudo.

Até então, a franquia acompanhava Miaka.

Agora seguimos Mayo.

A aventura deixa de ser uma missão para salvar um reino.

Passa a ser uma jornada sobre aceitar a própria realidade.

A fantasia funciona quase como uma terapia emocional.


As Aventuras

Mayo atravessa novamente o universo dos Quatro Deuses.

No caminho enfrenta:

  • ilusões

  • demônios

  • falsas esperanças

  • manipulações

  • entidades espirituais

  • conflitos internos

Cada obstáculo simboliza uma parte de sua própria personalidade.


Temáticas

Escapismo

Até que ponto fugir da realidade resolve nossos problemas?


Identidade

É possível ser feliz tentando viver a vida de outra pessoa?


Aceitação

O verdadeiro crescimento começa quando aceitamos quem somos.


Maturidade

Miaka representa alguém que deixou de sonhar apenas consigo.

Agora pensa na família.


Responsabilidade

Toda escolha possui consequências.

Mesmo dentro de um mundo mágico.


O Grande Diferencial

Enquanto a série original era sobre descobrir um novo mundo...

Eikoden fala sobre descobrir a si mesmo.

É um drama psicológico muito mais intimista.

Os conflitos externos existem.

Mas são apenas reflexos dos conflitos internos.


As Mensagens Ocultas

O Livro

Não representa apenas um portal.

Representa a tentação de viver em uma realidade idealizada.


Mayo

Simboliza qualquer pessoa que acredita que a felicidade sempre está na vida dos outros.


Miaka

Representa exatamente o oposto.

Ela aprendeu que felicidade exige responsabilidade.

Não apenas desejos.


Suzaku

Agora deixa de ser apenas um deus.

Passa a simbolizar esperança e renascimento.


O Paralelo Mainframe

Imagine um banco que decide restaurar um backup de produção de cinco anos atrás.

O ambiente antigo parece maravilhoso.

Não havia APIs.

Não havia cloud.

Não havia auditorias modernas.

Tudo parecia mais simples.

Até perceberem que:

  • existem milhares de vulnerabilidades;

  • as regras de negócio mudaram;

  • os usuários evoluíram;

  • o mundo não é mais o mesmo.

Eikoden mostra exatamente isso.

Não podemos viver presos à nostalgia.

Sistemas precisam evoluir.

Pessoas também.


Impacto Cultural

Entre as animações de Fushigi Yūgi, Eikoden costuma ser a mais divisiva. Muitos elogiam sua proposta de explorar um novo ponto de vista e o amadurecimento de Miaka, enquanto outros consideram Mayo uma protagonista difícil de simpatizar. Ainda assim, a OVA teve importância por adaptar uma das light novels derivadas da franquia e por encerrar a cronologia animada clássica. (Wikipedia)


Curiosidades

  • Foi baseada em duas light novels escritas por Megumi Nishizaki, com ilustrações de Yuu Watase, e não diretamente no mangá. (Wikipedia)

  • Foi a primeira animação da franquia a utilizar amplamente coloração e pintura digital, marcando uma mudança tecnológica em relação às OVAs anteriores. (Wikipedia)

  • A direção ficou a cargo de Nanako Shimazaki, diferente das animações anteriores dirigidas por Hajime Kamegaki. (Wikipedia)

  • A protagonista Mayo divide opiniões até hoje entre os fãs, sendo um dos aspectos mais debatidos da obra. (Reddit)


Nota Bellacosa Mainframe

CritérioNota
Desenvolvimento Psicológico⭐⭐⭐⭐⭐
Romance⭐⭐⭐⭐☆
Continuação do Universo⭐⭐⭐⭐☆
Originalidade⭐⭐⭐⭐⭐
Fantasia⭐⭐⭐⭐☆
Aventura⭐⭐⭐☆☆
Qualidade Visual⭐⭐⭐⭐⭐
Impacto Emocional⭐⭐⭐⭐☆

Vale a pena assistir?

Sim, mas com expectativas corretas.

Quem espera uma nova grande aventura como a série original provavelmente encontrará um ritmo mais lento e introspectivo. Já quem aprecia histórias sobre amadurecimento, identidade e as consequências das escolhas verá em Eikoden um epílogo interessante para o universo de Fushigi Yūgi.


Veredicto Final

Fushigi Yūgi: Eikoden encerra a cronologia clássica da franquia propondo uma pergunta diferente das obras anteriores: o que acontece quando alguém deseja viver a história de outra pessoa? Em vez de focar apenas na fantasia, a OVA explora temas como escapismo, amadurecimento e aceitação, mostrando que a verdadeira jornada nem sempre é atravessar um portal, mas aprender a valorizar a própria realidade.

No universo do Bellacosa Mainframe, a conclusão é inevitável:

"Todo programador já sonhou em restaurar aquela versão antiga do sistema, quando tudo parecia mais simples. Mas a experiência ensina que nem todo backup merece voltar à produção. Eikoden nos lembra que evoluir significa seguir em frente. Porque os melhores sistemas não vivem presos às versões antigas — eles carregam sua história, aprendem com ela e continuam evoluindo sem perder a essência."

sábado, 15 de dezembro de 2001

Inuyasha the Movie: Affections Touching Across Time : Quando um Programador COBOL Descobre que Alguns Bugs Foram Introduzidos Antes Mesmo do Primeiro IPL

 

Bellacosa Mainframe apresenta inuyasha the movie affections touching across time

☕ Um Café no Bellacosa Mainframe

Inuyasha the Movie: Affections Touching Across Time (犬夜叉 時代を越える想い) sem Mistérios

Quando um Programador COBOL Descobre que Alguns Bugs Foram Introduzidos Antes Mesmo do Primeiro IPL... e Agora Precisa Debugar Cinco Séculos de Dependências

"Existem sistemas cujo problema não nasceu na última atualização. Ele foi criado na primeira versão e permaneceu escondido durante séculos. O primeiro filme de Inuyasha conta exatamente esse tipo de incidente."


Introdução

Em 2001, apenas um ano após a estreia do anime de Inuyasha, o estúdio Sunrise lançou o primeiro longa-metragem da franquia.

O objetivo não era continuar diretamente o mangá de Rumiko Takahashi, mas oferecer uma aventura inédita que ampliasse o universo da série, explorando um inimigo antigo ligado aos acontecimentos do passado.

O resultado foi Inuyasha the Movie: Affections Touching Across Time, um filme que mistura ação, romance e fantasia, aprofundando a relação entre Inuyasha e Kagome enquanto apresenta um vilão original.

Para muitos fãs, este longa consolidou a franquia como uma das mais importantes do início dos anos 2000.


Dados Técnicos

Título Original

犬夜叉 時代を越える想い

Inuyasha: Toki wo Koeru Omoi

Tradução aproximada:

"Sentimentos que Atravessam o Tempo"

Título internacional:

Inuyasha the Movie: Affections Touching Across Time


Autora Original

Rumiko Takahashi (高橋留美子)

Criadora de:

  • Inuyasha

  • Ranma ½

  • Urusei Yatsura

  • Maison Ikkoku

  • Mermaid Saga

  • Mao


Estúdio

Sunrise

(atualmente Bandai Namco Film Works)


Diretor

Toshiya Shinohara


Roteiro

Katsuyuki Sumisawa


Lançamento

15 de dezembro de 2001

Japão


Duração

99 minutos


Gênero

  • Fantasia

  • Aventura

  • Romance

  • Ação

  • Sobrenatural

  • Drama


Classificação

Aproximadamente

12–14 anos

Contém:

  • batalhas

  • violência moderada

  • monstros

  • sangue leve

  • temas sobrenaturais


Sinopse

Depois de séculos aprisionado...

o poderoso yokai chinês

Menōmaru

retorna.

Seu objetivo é completar o plano iniciado por seu pai:

destruir o legado deixado por Inu no Taishō, pai de Inuyasha e Sesshomaru.

Enquanto isso...

Kagome começa a perceber que seus sentimentos por Inuyasha estão se tornando cada vez mais profundos.

A aventura rapidamente se transforma numa batalha entre passado e presente.


Resumo

O filme apresenta um inimigo completamente novo.

Menōmaru deseja vingar a derrota do pai.

Para isso tenta controlar:

  • Inuyasha

  • Kagome

  • o poder demoníaco

  • a Pérola de Shikon

A luta torna-se tanto física quanto psicológica.


A História

Muitos anos antes da série...

o Grande Cão Demônio derrotou o poderoso:

Hyōga

um antigo guerreiro demoníaco vindo do continente asiático.

Antes de morrer...

Hyōga deixa um filho.

Menōmaru

Séculos depois...

Menōmaru desperta.

Ele descobre que Inu no Taishō morreu.

Então decide concluir a vingança iniciada pelo pai.

Sua estratégia consiste em despertar completamente o sangue demoníaco de Inuyasha e usá-lo contra seus próprios aliados.


Os Personagens

Inuyasha

Precisa enfrentar seu lado demoníaco.

Mostra um enorme crescimento emocional.


Kagome

Tem papel muito mais importante do que apenas arqueira.

Seu vínculo espiritual torna-se fundamental para salvar Inuyasha.


Menōmaru

Primeiro grande vilão cinematográfico da franquia.

Representa vingança herdada.

Seu objetivo não é conquistar.

É destruir um legado.


Sesshomaru

Participação menor.

Mas extremamente marcante.

Sempre elegante.

Sempre poderoso.


Miroku

Continua oferecendo equilíbrio entre humor e inteligência.


Sango

Mantém seu papel de guerreira estratégica.


Shippo

Responsável por momentos leves em meio ao drama.


O Que Tem de Diferente?

Ao contrário da série de TV, o filme concentra toda a narrativa em um único conflito, com ritmo mais acelerado e foco na relação entre Inuyasha e Kagome.

Além disso, apresenta um antagonista ligado diretamente ao passado da família de Inuyasha, explorando aspectos pouco desenvolvidos naquele momento do anime.


Temáticas

Amor

Kagome finalmente compreende seus sentimentos.


Herança

Filhos carregam conflitos iniciados pelos pais.


Passado

Nem toda guerra termina quando alguém morre.


Escolhas

O sangue demoníaco não define quem Inuyasha é.


Vingança

O ódio pode atravessar gerações.


As Aventuras

A jornada leva o grupo a enfrentar Menōmaru e seus servos, explorando castelos antigos, florestas amaldiçoadas e batalhas que colocam Inuyasha à beira de perder o controle sobre sua natureza demoníaca.

Kagome assume um papel decisivo ao impedir que ele seja consumido pelo ódio, reforçando que a maior força do protagonista não está apenas em sua espada, mas também nos laços que construiu.


Mensagens Ocultas

O Passado Continua Executando

Mesmo quando ninguém percebe.


Poder Sem Controle

Sempre cobra um preço.


Amor Também Salva

Não apenas espadas.


O Ódio é Herdado

Mas não precisa continuar.


O Tempo Não Cura Tudo

Alguém precisa enfrentar os problemas.


Impacto Cultural

O primeiro filme foi um enorme sucesso entre os fãs da franquia e abriu caminho para outros três longas-metragens.

Também demonstrou que Inuyasha possuía um universo forte o suficiente para histórias inéditas, sem depender exclusivamente do mangá.

A animação recebeu elogios pela qualidade superior à da televisão, pela trilha sonora cinematográfica de Kaoru Wada e pelas cenas de ação.


Censura

O filme sofreu poucas alterações fora do Japão.

As principais mudanças envolveram:

  • redução de sangue em algumas transmissões televisivas;

  • adaptações de classificação indicativa;

  • pequenos ajustes em diálogos nas dublagens internacionais.

A versão em DVD e Blu-ray preserva praticamente todo o conteúdo original.


Mangás

O filme não adapta um arco do mangá.

Sua história é original, criada especialmente para o cinema com supervisão da equipe responsável pelo anime.

Posteriormente recebeu adaptações em formato de anime comic e materiais promocionais.


Light Novels

Não existe uma light novel canônica baseada neste filme.


Games

Embora o filme não tenha gerado um jogo exclusivo, elementos de Menōmaru e de sua história apareceram em materiais promocionais e influenciaram personagens e eventos de alguns jogos da franquia.

Os principais títulos relacionados continuam sendo:

  • Inuyasha: A Feudal Fairy Tale (PlayStation)

  • Inuyasha: The Secret of the Cursed Mask (PlayStation 2)

  • Inuyasha: Feudal Combat (PlayStation 2)

  • Inuyasha: Secret of the Divine Jewel (Nintendo DS)


Curiosidades

  • Foi o primeiro longa da franquia a estrear nos cinemas japoneses.

  • A trilha sonora de Kaoru Wada recebeu novos arranjos orquestrais exclusivos para o filme.

  • Menōmaru é um personagem original criado especificamente para o cinema.

  • A qualidade da animação é visivelmente superior à da série de TV, com cenários mais detalhados e batalhas mais elaboradas.


Easter Eggs

  • A história amplia a mitologia em torno de Inu no Taishō, mostrando que sua influência alcançava além do Japão.

  • O despertar da forma demoníaca de Inuyasha antecipa conflitos internos que seriam aprofundados na série principal.

  • O título "Affections Touching Across Time" simboliza tanto o romance entre Inuyasha e Kagome quanto a permanência dos laços familiares e das consequências das ações passadas.


Avaliação Bellacosa Mainframe

AspectoNota
História⭐⭐⭐⭐☆ (4,5/5)
Ação⭐⭐⭐⭐⭐ (5/5)
Romance⭐⭐⭐⭐☆ (4,5/5)
Animação⭐⭐⭐⭐⭐ (5/5)
Trilha Sonora⭐⭐⭐⭐⭐ (5/5)
Vilão⭐⭐⭐⭐☆ (4,5/5)
Fidelidade ao universo⭐⭐⭐⭐⭐ (5/5)

Nota Final: 9,3/10

É um excelente ponto de entrada para os filmes de Inuyasha e uma aventura que amplia o universo da série sem contradizer sua essência.


☕ Bellacosa Mainframe

Imagine um sistema COBOL implantado em 1520.

Durante cinco séculos ninguém mexeu em determinados módulos.

Todo mundo acredita que funcionam perfeitamente.

Até que um dia aparece um incidente crítico.

Depois da investigação, a equipe descobre que o defeito não foi criado pela última alteração.

Nem pela anterior.

Nem pela equipe atual.

O bug foi introduzido pelo arquiteto original do sistema, centenas de anos atrás.

Menōmaru representa esse incidente histórico que ressurge quando todos acreditavam que estava resolvido.

Inuyasha é o módulo crítico que precisa decidir se continuará executando rotinas antigas ou adotará uma nova lógica de funcionamento.

Kagome atua como a analista que compreende tanto a arquitetura moderna quanto o legado histórico, tornando-se a ponte entre duas gerações de tecnologia.

No fim, Affections Touching Across Time ensina uma lição que qualquer profissional de mainframe reconhece: os problemas mais difíceis raramente nascem na última atualização. Eles costumam estar escondidos em decisões tomadas há muito tempo, esperando apenas o momento certo para reaparecer em produção.

quinta-feira, 13 de setembro de 2001

Andaças por Montevideu

Viagem a Montevideu 


O ano 2001 foi um ano totalmente marcante, tanto que esta viagem a capital do Uruguay foi eclipsado pelos atentados de 11/9. Minha viagem era para o dia 12, porem devido ao caos que foi o day after do ataque as Torres Gémeas de Nova York, fomos remarcados para o dia 13.



Com a segurança alta nos aeroportos, a vigilância constante esta viagem na ida não foi tão interessante quanto eu desejava.

Chegando em Montevideu transcorreu tudo tranquilo, os colegas uruguaios eram muito simpáticos sendo grandes anfitriões, após o expediente fazíamos diversas actividades e aproveitávamos para conhecer a capital platina.

Provamos o churrasco uruguaio, cerveja e conhecemos a vida nocturna neste pequeno pais.

Agora a melhor surpresa estava no retorno na semana seguinte, meu voo era American Airline, justamente uma companhia que perdera avião no atentando, éramos 6 passageiro num voo de quase 300 passageiros. Que mordomia, que simpatia ate o piloto véu agradecer o voto de confiança em voar com AA.

sexta-feira, 1 de junho de 2001

📚 MYNE E A BIBLIOTECA PERDIDA DO MAINFRAME — QUANDO O COBOL DESCOBRIU QUE CÓDIGO SEM DOCUMENTAÇÃO TAMBÉM PODE VIRAR UM LIVRO ESQUECIDO

 

Bellacosa Mainframe e a documentação de software

☕ Um Café no Bellacosa Mainframe

📚 MYNE E A BIBLIOTECA PERDIDA DO MAINFRAME — QUANDO O COBOL DESCOBRIU QUE CÓDIGO SEM DOCUMENTAÇÃO TAMBÉM PODE VIRAR UM LIVRO ESQUECIDO

Documentação, COBOL, auditoria, Configuration Management, Git, runbooks, dívida documental, conhecimento institucional, IA generativa — e o dia em que Myne descobriu que o maior risco do sistema não estava no programa, mas na cabeça do único programador que sabia como ele funcionava.



🎬 PRÓLOGO — MYNE ENCONTROU UM PROGRAMA COBOL

Myne abriu os olhos.

Não estava em Ehrenfest.

Não havia templo.

Não havia Ferdinand.

Não havia sequer uma biblioteca.

Diante dela existia uma tela preta com letras verdes.

READY

DSN SYSTEM(DB2P)

IKJ56700A ENTER USERID -

— Onde estão os livros?

Um velho programador apontou para milhares de datasets.

HLQ.PROD.COBOL
HLQ.PROD.COPYLIB
HLQ.PROD.JCL
HLQ.PROD.PROCLIB
HLQ.PROD.PARMLIB

Myne arregalou os olhos.

— Então... isso tudo é conhecimento?

— Mais ou menos.

— Onde está a documentação?

Silêncio.

O programador olhou para o teto.

Outro fingiu que estava analisando um dump.

Um terceiro tomou café.

Finalmente alguém respondeu:

— Pergunta para o Carlos.

Myne imediatamente percebeu que havia encontrado um problema muito mais grave do que a falta de livros.

A empresa possuía milhares de programas.

Mas parte importante do conhecimento necessário para compreendê-los estava armazenada em um dispositivo extremamente sofisticado, porém perigosamente volátil:

a memória dos funcionários.

Bem-vindo, jovem programador COBOL, à dungeon da documentação.



📜 CAPÍTULO 1 — CÓDIGO NÃO É DOCUMENTAÇÃO

Existe uma frase muito repetida no desenvolvimento:

“O código é a documentação.”

Ela contém alguma verdade, mas também pode esconder uma armadilha.

Veja:

       IF WS-TIPO-CLIENTE = 'E'
           PERFORM 8200-CALCULO-ESPECIAL
       END-IF.

Mesmo um iniciante consegue perceber o comportamento básico.

Se WS-TIPO-CLIENTE for igual a E, o programa executa 8200-CALCULO-ESPECIAL.

Ótimo.

Mas agora Myne começa a fazer perguntas.

— O que significa E?

— Especial.

— O que é um cliente especial?

— Não sei.

— Quem decidiu isso?

— Não sei.

— Por que ele recebe cálculo diferente?

— Também não sei.

— Desde quando?

— Talvez 2004.

— Posso remover?

— NÃO!

E encontramos a diferença entre código e conhecimento.

O código descreve muito bem aquilo que o computador precisa executar.

Mas nem sempre preserva:

  • por que determinada decisão foi tomada;

  • qual requisito originou a regra;

  • quem solicitou a alteração;

  • quais impactos foram considerados;

  • quais sistemas dependem dela;

  • quais procedimentos operacionais existem;

  • como recuperar o sistema quando algo dá errado.

Imagine encontrar:

      * ALTERADO JOAO 14/06/2004

Excelente.

Descobrimos que João esteve ali.

Infelizmente, João não deixou pistas sobre aquilo que estava pensando.

Myne suspira.

Um livro que diz apenas:

“Capítulo alterado por João.”

não preserva conhecimento suficiente para reconstruir sua história.



🧠 CAPÍTULO 2 — A EMPRESA POSSUI UMA MEMÓRIA

Uma organização também possui memória.

Só que ela não fica em um único lugar.

Pode estar espalhada por:

Código-fonte
     │
     ├── COBOL
     ├── JCL
     ├── COPYBOOKS
     ├── procedimentos
     ├── tickets
     ├── diagramas
     ├── e-mails
     ├── Wikis
     ├── runbooks
     ├── atas
     ├── manuais
     └── pessoas

O último elemento merece atenção especial.

Imagine:

CONHECIMENTO DO SISTEMA XPTO

20% documentação
30% código
50% Carlos

Temos um problema.

Carlos pode:

  • sair da empresa;

  • mudar de departamento;

  • entrar de férias;

  • esquecer detalhes;

  • aposentar-se;

  • simplesmente não estar disponível durante um incidente.

Isso transforma Carlos em algo parecido com um Single Point of Failure humano.

Existe inclusive uma expressão informal usada em engenharia de software: bus factor.

Ela procura representar quantas pessoas poderiam ficar indisponíveis antes que um projeto perdesse conhecimento crítico.

Se a resposta for:

uma,

temos enorme concentração de conhecimento.

Myne ficaria horrorizada.

Para alguém que passou a vida tentando preservar livros, colocar conhecimento crítico exclusivamente na memória humana seria equivalente a possuir apenas um exemplar de um livro importantíssimo e guardá-lo ao lado de uma lareira.



⚔️ CAPÍTULO 3 — POR QUE PROGRAMADORES NÃO GOSTAM DE DOCUMENTAR?

Durante décadas, gestores perguntaram:

Como fazer os programadores documentarem?

É uma pergunta compreensível.

Mas pode ser a pergunta errada.

É fácil responder:

— Programador não gosta de escrever.

Alguns realmente não gostam.

Outros têm dificuldade para transformar raciocínio técnico em texto compreensível.

Mas existe um problema organizacional muito mais interessante.

Imagine dois programadores.

Programador A

Codificação ............ 8 horas
Testes ................. 3 horas
Documentação ........... 2 horas
-------------------------------
Total .................. 13 horas

Programador B

Codificação ............ 8 horas
Testes ................. 2 horas
Documentação ........... 0 horas
-------------------------------
Total .................. 10 horas

Se a empresa medir produtividade apenas pela velocidade da entrega, quem parece melhor?

B.

Portanto, não documentar pode ser perfeitamente racional dentro de um sistema de incentivos mal construído.

A empresa publica:

“Documentação é fundamental.”

Mas o projeto comunica:

PRAZO > DOCUMENTAÇÃO

E o funcionário aprende rapidamente qual regra realmente vale.

Myne percebe algo importante:

cultura organizacional não é aquilo que está escrito no manual. É aquilo que a organização recompensa, tolera e pune.



🏰 CAPÍTULO 4 — DOCUMENTAÇÃO NÃO DEVERIA SER UMA TAREFA POSTERIOR

Um projeto tradicional frequentemente funciona assim:

REQUISITO
    ↓
ANÁLISE
    ↓
DESENVOLVIMENTO
    ↓
TESTE
    ↓
PRODUÇÃO
    ↓
"Esquecemos da documentação."

Nesse modelo, documentação virou a última obrigação antes da libertação do programador.

Resultado?

Ele está cansado.

O prazo terminou.

Outro projeto já começou.

O gerente quer implantação.

E alguém pergunta:

— Você pode escrever o manual?

Nasce então o clássico:

MANUAL_SISTEMA_FINAL.DOC

Seguido, meses depois, por:

MANUAL_SISTEMA_FINAL2.DOC
MANUAL_SISTEMA_NOVO.DOC
MANUAL_SISTEMA_NOVO_FINAL.DOC
MANUAL_SISTEMA_NOVO_FINAL_OK.DOC

Isso não é versionamento.

É arqueologia digital.

A solução conceitual é colocar documentação dentro do ciclo de desenvolvimento:

REQUISITO
    ↓
DESIGN
    ↓
CÓDIGO
    +
DOCUMENTAÇÃO
    ↓
TESTE
    +
TESTE DA DOCUMENTAÇÃO
    ↓
REVIEW
    ↓
DEPLOY

Agora surge uma regra poderosa:

mudança no sistema pode significar mudança na documentação.

Não necessariamente toda alteração muda todo documento.

Mas toda alteração deveria provocar a pergunta:

Quais informações precisam ser atualizadas por causa desta mudança?


🔗 CAPÍTULO 5 — UMA ALTERAÇÃO COBOL NUNCA ESTÁ SOZINHA

O iniciante frequentemente imagina:

PROGRAMA COBOL

Mas sistemas corporativos são ecossistemas.

Uma alteração pode atingir:

REQUISITO
   │
   ├── COBOL
   ├── COPYBOOK
   ├── JCL
   ├── PROC
   ├── VSAM
   ├── Db2
   ├── CICS
   ├── MQ
   ├── API
   ├── batch
   ├── procedimento operacional
   ├── troubleshooting
   └── manual do usuário

Imagine aumentar um campo:

05 CLIENTE-ID PIC 9(06).

para:

05 CLIENTE-ID PIC 9(08).

Parece simples.

Mas Myne pergunta:

— O copybook compartilhado mudou?

— Sim.

— Arquivos VSAM?

— Talvez.

— Layout de interface?

— Sim.

— Programa consumidor?

— Também.

— Documentação?

Silêncio novamente.

Essa é a essência da análise de impacto.

Documentação não está fora do sistema.

Ela faz parte do conjunto de artefatos que descrevem o sistema.


🧙 CAPÍTULO 6 — MYNE DESCOBRE CONFIGURATION MANAGEMENT

Chegamos a um conceito importante para quem está começando no mainframe:

Configuration Management.

Simplificando bastante, Configuration Management procura responder perguntas como:

O que existe?
Qual versão existe?
Qual versão está em produção?
Quem alterou?
Quando alterou?
Por que alterou?
O que depende disso?
Qual era a configuração anterior?

Você provavelmente já percebeu que isso não interessa somente ao código.

Imagine:

RUNBOOK-PAGAMENTOS

Versão: 4.7
Sistema: PAY001
Owner: Payments Operations
Aprovador: Production Control
Última revisão: 23/09/2026
Próxima revisão: 23/03/2027
Change: CHG-98472
Status: APPROVED

Agora temos algo auditável.

Podemos perguntar:

Qual procedimento estava válido em 14 de março?

E recuperar aquela versão.

Essa capacidade é essencial.


💀 CAPÍTULO 7 — ÀS 03:17, A DOCUMENTAÇÃO VIRA PRODUÇÃO

03:17.

Sim, jovem padawan.

Você encontrou o easter egg.

O telefone toca.

INCIDENTE CRÍTICO
SISTEMA DE PAGAMENTOS

O operador consulta o procedimento.

1. Localizar JOB PAYR001.
2. Cancelar execução.
3. Executar PAYREC01.
4. Verificar mensagem PAY003I.

Ele está prestes a executar o passo 3 quando alguém grita:

— NÃO EXECUTA!

— Por quê?

— PAYREC01 foi aposentado.

— Quando?

— Ano passado.

— O procedimento manda executar.

Silêncio.

A documentação está oficialmente publicada.

Mas descreve um sistema que já não existe.

Temos então duas verdades:

VERDADE EXECUTÁVEL
        ≠
VERDADE DOCUMENTADA

Esse fenômeno poderia ser chamado de documentation drift ou deriva documental.

E aqui aparece uma conclusão contraintuitiva:

documentação errada pode ser pior que documentação inexistente.

Se não houver documentação, o operador sabe que precisa investigar.

Quando existe um procedimento aparentemente oficial, ele pode confiar nele.


🧪 CAPÍTULO 8 — DOCUMENTAÇÃO TAMBÉM PRECISA SER TESTADA

Essa ideia é extraordinariamente importante.

Considere:

1. Entre no SDSF.
2. Localize o job.
3. Execute comando X.
4. Confirme mensagem Y.
5. Reinicie componente Z.

Um especialista lê e afirma:

— Perfeito.

Mas entregue isso a alguém que nunca executou o procedimento.

Ele pergunta:

— Em qual painel?

— Como localizo o job?

— Qual comando?

— Onde aparece Y?

— E se Y não aparecer?

Descobrimos cinco buracos em trinta segundos.

Portanto, documentação operacional pode possuir algo parecido com teste funcional.

Uma pessoa representativa do público-alvo tenta realizar a tarefa utilizando somente as instruções.

Isso revela:

  • passos ausentes;

  • pressupostos ocultos;

  • terminologia inadequada;

  • ambiguidades;

  • comandos errados;

  • dependências não documentadas.

Myne aprovaria.

Não basta imprimir o livro.

Precisamos verificar se o leitor consegue utilizá-lo.


📚 CAPÍTULO 9 — MAIS DOCUMENTAÇÃO NÃO SIGNIFICA MELHOR DOCUMENTAÇÃO

Existe outra pergunta antiga:

Quanto devemos documentar?

Resposta errada:

Tudo.

Outra resposta errada:

O mínimo possível.

O objetivo é:

DOCUMENTAÇÃO NECESSÁRIA
        +
CORRETA
        +
ATUAL
        +
ENCONTRÁVEL
        +
COMPREENSÍVEL
        +
ADEQUADA À TAREFA

Um manual de 900 páginas pode ser praticamente inútil durante um incidente.

O operador talvez precise de duas páginas.

Diferentes necessidades exigem diferentes documentos:

NecessidadeInformação
compreender arquiteturaArchitecture Overview
desenvolverDeveloper Guide
operarRunbook
investigar falhaTroubleshooting Guide
integrarInterface/API Specification
recuperar desastreDisaster Recovery Procedure
utilizar aplicaçãoUser Guide
modificarDesign/Change Documentation
aprender sistemaOnboarding Guide
auditarevidências e histórico

A antiga ideia de colocar tudo no gigantesco Manual do Sistema frequentemente cria documentos impossíveis de consumir.


🗺️ CAPÍTULO 10 — DOCUMENTAÇÃO PRECISA SER ENCONTRÁVEL

Myne finalmente recebe uma boa notícia.

— Temos documentação!

— Onde?

— Share.

— Qual?

— Não lembro.

— Nome?

— Alguma coisa como PAY...

Depois de vinte minutos:

\\server\departamento\projetos\old\sistemas\pagamentos\
documentacao\backup\antigo\

Myne quase desmaia.

Informação que existe mas não pode ser encontrada possui valor operacional próximo de zero.

Portanto, governança documental envolve também:

  • taxonomia;

  • pesquisa;

  • nomes consistentes;

  • metadados;

  • owners;

  • classificação;

  • links;

  • relacionamentos;

  • controle de versão.

Bibliotecas descobriram isso séculos atrás.

Não basta possuir livros.

Precisamos saber onde eles estão e como encontrá-los.


🏛️ CAPÍTULO 11 — CENTRALIZAR OU DESCENTRALIZAR?

O problema já existia décadas atrás.

Deveríamos possuir um departamento central de documentação?

Ou documentadores dentro das equipes?

Centralizado

          DOCUMENTAÇÃO
               │
     ┌─────────┼─────────┐
     ↓         ↓         ↓
 SISTEMA A  SISTEMA B  SISTEMA C

Excelente para:

  • padrões;

  • qualidade;

  • independência;

  • governança;

  • consistência.

Mas pode ficar distante da tecnologia.

Descentralizado

TIME A → documentação A
TIME B → documentação B
TIME C → documentação C

Excelente proximidade.

Mas pode produzir três dialetos diferentes.

Uma solução interessante é o modelo federado:

          GOVERNANÇA CENTRAL
                 │
       padrões e ferramentas
                 │
       ┌─────────┼─────────┐
       ↓         ↓         ↓
     TIME A    TIME B    TIME C
       │         │         │
     OWNER     OWNER     OWNER

O centro define regras.

As equipes preservam conhecimento local.


👑 CAPÍTULO 12 — TODO DOCUMENTO PRECISA DE UM DONO

Uma regra simples evita enorme quantidade de caos:

todo documento relevante deve possuir owner.

Owner não significa necessariamente autor.

O owner responde pela validade.

Pense assim:

DOCUMENTO
   ↓
OWNER
   ↓
REVISÃO
   ↓
APROVAÇÃO
   ↓
PUBLICAÇÃO
   ↓
USO
   ↓
NOVA REVISÃO
   ↓
ARQUIVAMENTO

Documento sem proprietário tende a virar órfão.

E órfãos digitais envelhecem silenciosamente.


🧹 CAPÍTULO 13 — DOCUMENTO OBSOLETO PRECISA MORRER

Esse ponto é pouco discutido.

Criar documentação é importante.

Mas aposentar documentação também é.

Imagine encontrar:

RUNBOOK-PAY-2019
RUNBOOK-PAY-2021
RUNBOOK-PAY-NOVO
RUNBOOK-PAY-FINAL
RUNBOOK-PAY-ATUAL

Qual é válido?

Se ninguém souber, temos risco operacional.

Um processo maduro deveria permitir estados como:

DRAFT
REVIEW
APPROVED
PUBLISHED
SUPERSEDED
ARCHIVED

Assim sabemos que determinado documento existe historicamente, mas não deve mais orientar operações atuais.

Myne chamaria isso de diferença entre:

arquivo histórico e livro de uso corrente.


💳 CAPÍTULO 14 — DÍVIDA DOCUMENTAL

Programadores conhecem Technical Debt.

Mas existe outra dívida:

Documentation Debt.

Toda mudança não refletida na documentação cria um pequeno débito.

No começo ninguém percebe.

Mudança 1 → documento quase correto
Mudança 2 → pequeno erro
Mudança 3 → faltam dois procedimentos
Mudança 4 → diagrama incorreto
Mudança 5 → ninguém confia mais

Finalmente acontece algo curioso:

“Não consulte a Wiki porque está desatualizada.”

Pronto.

A organização perdeu confiança em seu próprio repositório de conhecimento.

Podemos imaginar:

Documentation Debt ↑

MTTR ↑
Onboarding ↑
Dependência de especialistas ↑
Retrabalho ↑
Risco operacional ↑
Risco de auditoria ↑

O custo economizado ontem reaparece com juros.


🔍 CAPÍTULO 15 — ENTRA O AUDITOR

Agora o auditor chega.

Um auditor fraco pergunta:

— Vocês possuem documentação?

A equipe mostra cinquenta PDFs.

Check.

Auditor satisfeito.

Myne não.

Um auditor melhor pergunta:

“Mostre uma alteração recente em produção.”

Escolhemos:

CHG-98472

Agora reconstruímos:

REQUISITO
    ↓
ANÁLISE
    ↓
CHANGE
    ↓
ALTERAÇÃO COBOL
    ↓
TESTE
    ↓
APROVAÇÃO
    ↓
DEPLOY
    ↓
DOCUMENTAÇÃO
    ↓
COMUNICAÇÃO

Depois fazemos o contrário.

Escolhemos um programa em produção:

PAYB0031

E perguntamos:

Qual versão?
Qual change colocou isso aqui?
Quem aprovou?
Quais testes existem?
Qual requisito originou?
Qual documentação foi atualizada?

Isso é rastreabilidade.

Não estamos procurando papel.

Estamos procurando evidência de controle.


⚔️ CAPÍTULO 16 — O AUDITOR PROCURA A EMPRESA REAL

Existe uma diferença fundamental entre:

PROCESSO DOCUMENTADO

e:

PROCESSO REAL

O manual diz:

Em incidentes críticos consultar RUNBOOK-PAY.

O auditor entrevista operadores.

— O que você faz quando PAY cai?

— Chamo o Zé.

— E o runbook?

— Ah... aquilo está velho.

Bingo.

Encontramos uma diferença entre governança formal e comportamento operacional.

A empresa pensa que possui:

INCIDENTE
   ↓
RUNBOOK
   ↓
RESOLUÇÃO

Na realidade possui:

INCIDENTE
   ↓
WhatsApp
   ↓
"CHAMA O ZÉ"

Zé virou middleware humano.

E não possui redundância.


🤖 CAPÍTULO 17 — MYNE CONHECE A INTELIGÊNCIA ARTIFICIAL

Então chega 2026.

Myne encontra uma máquina extraordinária.

Ela recebe:

  • COBOL;

  • JCL;

  • copybooks;

  • diagramas;

  • tickets;

  • commits;

  • logs.

E produz explicações.

— Ela escreve livros?!

Quase.

IA generativa pode ajudar enormemente na documentação.

Por exemplo, pode transformar:

       EVALUATE WS-STATUS
          WHEN 'A'
             PERFORM 1000-ATIVO
          WHEN 'B'
             PERFORM 2000-BLOQUEADO
          WHEN OTHER
             PERFORM 9000-ERRO
       END-EVALUATE.

em uma explicação preliminar.

Pode ainda:

  • resumir código;

  • explicar campos;

  • gerar diagramas preliminares;

  • converter tickets em release notes;

  • comparar versões;

  • identificar documentação possivelmente afetada;

  • criar perguntas para revisão;

  • produzir rascunhos de runbooks.

Fantástico.

Mas existe uma armadilha gigantesca.


☠️ CAPÍTULO 18 — IA PODE DOCUMENTAR PERFEITAMENTE UMA COISA ERRADA

Imagine a IA afirmar:

“O campo E representa cliente empresarial.”

Texto bonito.

Gramática impecável.

Completamente errado.

Na verdade:

E = CLIENTE ESPECIAL

Esse é um novo tipo de risco.

Antigamente tínhamos documentação ruim obviamente ruim.

Agora podemos possuir documentação errada extremamente convincente.

Portanto:

IA
 ↓
RASCUNHO
 ↓
SME TÉCNICO
 ↓
USUÁRIO
 ↓
VALIDAÇÃO
 ↓
APROVAÇÃO
 ↓
PUBLICAÇÃO

Nunca:

IA
 ↓
PRODUÇÃO

A inteligência artificial reduz o custo de produção.

Ela não transfere responsabilidade pela verdade.


🧰 CAPÍTULO 19 — DOCUMENTATION AS CODE

Agora Myne encontra Git.

E quase pede Ferdinand em casamento novamente.

Porque finalmente os livros possuem histórico automático.

Podemos organizar:

docs/
├── architecture/
├── development/
├── operations/
├── troubleshooting/
├── interfaces/
└── security/

Uma alteração começa:

git checkout -b CHG-98472

O programador altera:

src/PAYB0031.cbl

e também:

docs/operations/payment-runbook.md

Então:

CODE
  +
DOC
  ↓
PULL REQUEST
  ↓
REVIEW
  ↓
PIPELINE
  ↓
RELEASE

Isso é poderoso porque aproxima documentação do mesmo fluxo utilizado pelo software.

Temos:

  • versionamento;

  • histórico;

  • autoria;

  • comparação;

  • revisão;

  • aprovação;

  • automação.

Código e conhecimento começam a viajar juntos.


🧪 CAPÍTULO 20 — UM PASSO A PASSO PARA O PROGRAMADOR COBOL

Você recebeu uma alteração.

Não pense apenas:

“Qual linha COBOL vou mudar?”

Faça algo parecido com isto.

Passo 1 — descubra o motivo

Pergunte:

Qual problema estamos resolvendo?

Passo 2 — descubra o impacto

Liste:

COBOL?
COPYBOOK?
JCL?
Db2?
VSAM?
CICS?
MQ?
API?
batch?
usuário?
operação?

Passo 3 — localize documentação relacionada

Procure:

Architecture
Developer Guide
Runbook
Interface Specification
User Guide
Troubleshooting

Passo 4 — altere código e conhecimento juntos

Não espere três meses.

Passo 5 — teste ambos

O programa funciona?

A instrução também?

Passo 6 — peça revisão

Técnico revisa tecnologia.

Usuário revisa significado.

Operação revisa execução.

Passo 7 — preserve rastreabilidade

Relacione:

REQUISITO → CHANGE → CÓDIGO → TESTE → DOCUMENTAÇÃO

Passo 8 — retire informação obsoleta

Não deixe armadilhas históricas disponíveis como instrução atual.


🧙‍♀️ CAPÍTULO 21 — MYNE CRIA AS DEZ REGRAS DA BIBLIOTECA DO MAINFRAME

Depois de observar aquela organização, Myne escreve:

I. Código não substitui contexto.

II. Toda mudança deve avaliar impacto documental.

III. Todo documento crítico precisa de owner.

IV. Documentação precisa possuir versão.

V. Informação precisa ser encontrável.

VI. Procedimentos críticos precisam ser testados.

VII. Documento obsoleto precisa ser claramente aposentado.

VIII. IA pode escrever rascunhos; humanos continuam responsáveis pela verdade.

IX. Conhecimento crítico não pode existir somente na cabeça de uma pessoa.

X. Documentação faz parte do produto.

Ferdinand lê.

Fica em silêncio.

— Onze regras seriam mais completas.

Myne fecha o livro.

— Dez ficam melhores num slide.


☕ EPÍLOGO — O ÚLTIMO LIVRO DE CARLOS

Alguns meses depois, Carlos anunciou aposentadoria.

Ninguém entrou em pânico.

Durante meses, a equipe havia transformado seu conhecimento em:

Architecture Guides
Runbooks
Troubleshooting Guides
Decision Records
Diagramas
README
Procedimentos
Histórico de mudanças

Mais importante: outras pessoas haviam utilizado e testado aquele conhecimento.

No último dia, Carlos deixou sobre a mesa uma pequena folha.

Myne encontrou.

Nela estava escrito:

03:17

Se PAYB0031 apresentar S0C7 depois do fechamento,
não reinicie imediatamente.

Verifique primeiro o arquivo PAY.IN.TRANS.

E não acredite no procedimento de 2019.

Myne sorriu.

Digitalizou a informação.

Criou um ticket.

Atualizou o troubleshooting.

Relacionou ao sistema.

Mandou revisar.

E destruiu a folha.

Porque finalmente aquela empresa havia compreendido algo que bibliotecários sabem há séculos:

conhecimento que não pode ser encontrado não está verdadeiramente disponível.

Conhecimento que não pode ser verificado não é confiável.

Conhecimento que depende de uma única pessoa não pertence realmente à organização.

E conhecimento que não acompanha a evolução do sistema lentamente se transforma em ficção.

Para um programador COBOL iniciante, talvez essa seja uma das lições mais importantes da carreira.

Você não herdará apenas programas.

Herdará decisões tomadas por pessoas que talvez nunca conheça.

Encontrará campos criados antes de você nascer.

COPYBOOKs compartilhados por dezenas de aplicações.

JCLs cujo comentário mais recente terá quinze anos.

Regras de negócio que sobreviveram a três presidentes da empresa, quatro arquiteturas e seis gerações de programadores.

Um dia alguém também encontrará o seu código.

E encontrará algo como:

      *---------------------------------------------------------*
      * CHG-98472 - 23/09/2026                                 *
      * ALTERADA REGRA DE CLIENTE ESPECIAL.                    *
      * MOTIVO: NOVA REGRA CONTRATUAL.                          *
      * DOCUMENTACAO: DOC/PAYMENTS/RULES-CLIENTE-ESPECIAL.MD    *
      *---------------------------------------------------------*

Essa pessoa talvez nunca saiba seu nome.

Mas saberá por que aquilo existe.

E existe algo profundamente bonito nisso.

Porque mainframes são máquinas construídas para sobreviver ao tempo.

COBOL também.

Mas sistemas de cinquenta anos não sobrevivem apenas porque o hardware continua funcionando.

Eles sobrevivem porque sucessivas gerações de profissionais conseguem receber, compreender, modificar e transmitir conhecimento.

Somos temporários.

O sistema pode continuar.

O código fica.

As decisões ficam.

A documentação deveria ficar também.

E talvez Myne, olhando para milhões de linhas COBOL preservadas durante décadas, finalmente percebesse que havia encontrado uma biblioteca muito diferente daquela que sempre sonhou construir.

Uma biblioteca na qual alguns livros são executáveis.

E onde esquecer de atualizar uma página pode, às 03:17 da manhã, derrubar produção.

Bem-vindo à Biblioteca do Mainframe.

Seu próximo commit também é uma página da história.

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