☕ 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 março de 2002

🧙‍♂️ LLOYD DE SALOUM E A DUNGEON DA MICROINFORMÁTICA — QUANDO O PC VIROU BUSINESS COMPUTER

 

Bellacosa Mainframe e a auditoria em computadores

☕ Um Café no Bellacosa Mainframe

🧙‍♂️ LLOYD DE SALOUM E A DUNGEON DA MICROINFORMÁTICA — QUANDO O PC VIROU BUSINESS COMPUTER

COBOL, mainframe, PCs, Winchester, Lotus 1-2-3, antivírus, backup, auditoria, Shadow IT, ITAM, CMDB, Cloud e IA — e o dia em que Lloyd descobriu que o aplicativo secreto do Financeiro era mais perigoso que um demônio ancestral.



🎬 PRÓLOGO — LLOYD ENCONTROU UM PC DEBAIXO DA MESA

— Lloyd-sama, temos um problema.

Lloyd de Saloum levantou os olhos.

Aquilo normalmente significava uma excelente oportunidade para aprender alguma magia nova.

— Um demônio?

— Não.

— Uma maldição?

— Também não.

— Um artefato mágico proibido?

— Pior. Encontramos um computador no Financeiro que ninguém da Informática sabia que existia.

Os olhos de Lloyd brilharam.

— Interessante!

O pobre auditor percebeu imediatamente que havia cometido um erro.

Poucos minutos depois, Lloyd estava ajoelhado diante da máquina.

Na tela:

C:\>

No disco rígido havia planilhas, documentos, programas em dBASE, arquivos de clientes, backups de backups, executáveis de procedência desconhecida e um diretório chamado:

C:\NOVO\FINAL\BACKUP\VELHO

— Fascinante!

— Lloyd-sama, isso não deveria estar aqui.

— Por quê?

Essa pergunta aparentemente inocente nos leva a uma das transformações mais importantes da história da informática corporativa.

Durante décadas, empresas construíram regras rigorosas para controlar computadores centrais, aplicações COBOL, arquivos, bancos de dados, usuários, backups e mudanças.

Então chegaram os microcomputadores.

E milhares de usuários descobriram que podiam fazer muita coisa sem pedir autorização ao velho CPD.

Nascia uma revolução.

E, junto com ela, uma enorme dungeon chamada:

AUDITORIA DE MICROINFORMÁTICA.



🏰 CAPÍTULO 1 — QUANDO O COMPUTADOR MORAVA NO CASTELO

Para entender a auditoria de microinformática, nosso jovem programador COBOL precisa voltar algumas décadas.

Em uma empresa tradicional, o processamento de dados era altamente centralizado.

Podíamos ter algo parecido com:

                    ┌─────────────────┐
                    │    MAINFRAME    │
                    │                 │
                    │ COBOL           │
                    │ CICS            │
                    │ IMS             │
                    │ DB2             │
                    │ VSAM            │
                    └────────┬────────┘
                             │
                 ┌───────────┴───────────┐
                 │                       │
             TERMINAL                TERMINAL
                 │                       │
              Usuário                 Usuário

O terminal normalmente não era um computador independente como conhecemos hoje.

Ele era uma janela para o sistema central.

O processamento estava no mainframe.

Os programas estavam sob controle da área de tecnologia.

Os dados estavam em datasets, bancos ou arquivos administrados.

Havia procedimentos para produção.

Havia operadores.

Havia controle de acesso.

Havia backup.

Havia processos de mudança.

Mesmo que tudo isso não fosse perfeito, existia uma importante característica:

centralização.

Se Lloyd perguntasse:

— Onde está a folha de pagamento?

Provavelmente alguém poderia responder:

— Na aplicação XPTO, executada no mainframe, usando estes programas COBOL, estes arquivos e este banco de dados.

Isso é governança.

Então alguém colocou um computador sobre uma mesa.



🖥️ CAPÍTULO 2 — O PC ESCAPOU DO CPD

O Personal Computer mudou completamente a relação entre usuário e tecnologia.

Agora um departamento podia ter poder computacional próprio.

Financeiro podia criar planilhas.

Engenharia podia comprar aplicativos.

Recursos Humanos podia montar uma pequena base de dados.

Vendas podia desenvolver um sistema departamental.

O computador deixou de ser somente uma janela para o grande computador central.

Ele próprio processava informações.

Imagine:

                 MAINFRAME
                     │
            Sistemas Corporativos
                     │
        ─────────────┼─────────────
                     │
                    LAN
                     │
        ┌────────────┼────────────┐
        │            │            │
    Financeiro     Vendas     Engenharia
        │            │            │
       PC           PC           PC
        │            │            │
     Lotus        dBASE      Aplicativo

Parece maravilhoso.

E realmente foi uma revolução de produtividade.

Mas existe uma pergunta:

quem controla tudo isso?

O programador COBOL acostumado ao mainframe talvez estranhasse.

No ambiente centralizado, para colocar uma aplicação importante em produção, normalmente existiam processos.

No PC departamental alguém poderia simplesmente criar:

C:\CONTAS\FATURA.DBF

E, seis meses depois, aquele arquivo estar participando do fechamento financeiro da empresa.

Sem que ninguém tivesse percebido quando uma experiência virou aplicação crítica.

Essa transformação é fundamental para entender todo o nosso tema.

O PC estava deixando de ser apenas Personal Computer.

Estava virando:

Business Computer.

BC.

Computador de negócios.



🧙 CAPÍTULO 3 — LLOYD DESCOBRE QUE A MAGIA FUNCIONA SEM AUTORIZAÇÃO

Lloyd provavelmente adoraria microcomputadores.

Porque eles representavam liberdade.

Você podia experimentar.

Instalar.

Programar.

Criar.

Testar.

Automatizar.

O problema empresarial aparece quando confundimos:

liberdade para experimentar

com:

liberdade para criar processos corporativos sem governança.

Imagine João, funcionário do Financeiro.

Todo mês ele recebe um arquivo e leva oito horas para produzir determinado relatório.

João aprende dBASE.

Cria uma pequena aplicação.

Agora leva vinte minutos.

Fantástico!

Depois outras pessoas começam a usar.

Dois anos depois:

Programa do João
       ↓
Relatório financeiro
       ↓
Fechamento mensal
       ↓
Diretoria
       ↓
Decisão empresarial

Parabéns.

João acabou de criar um sistema crítico.

Só existe um pequeno problema.

Ninguém sabe disso.



👻 CAPÍTULO 4 — O ANCESTRAL DO SHADOW IT

Hoje usamos a expressão Shadow IT para tecnologia utilizada fora da governança ou visibilidade formal da organização.

Mas Shadow IT não nasceu com Cloud.

Muito antes de alguém criar uma máquina virtual escondida na AWS, havia aplicações escondidas em PCs.

Podia ser:

Lotus 1-2-3
Excel
Access
dBASE
FoxPro
Clipper
Macros
scripts
executáveis locais

O usuário não estava necessariamente tentando sabotar a empresa.

Na maioria dos casos queria resolver um problema.

Essa distinção é importante.

Shadow IT frequentemente nasce de uma combinação de:

necessidade urgente
        +
tecnologia acessível
        +
processo corporativo lento
        =
solução paralela

O auditor inteligente não deveria simplesmente perguntar:

— Quem foi o irresponsável que fez isso?

Deveria perguntar:

— Por que a organização precisou disso?

Porque uma aplicação clandestina também pode ser sintoma de outro problema.

Talvez o departamento de TI demore oito meses para atender uma necessidade que o negócio precisa resolver em oito dias.


💰 CAPÍTULO 5 — AUDITORIA NÃO É CAÇA ÀS BRUXAS

Existe uma visão pobre de auditoria:

encontrar alguém fazendo algo errado.

Uma boa auditoria é muito mais interessante.

Ela procura compreender:

PROCESSO
   ↓
RISCO
   ↓
CONTROLE
   ↓
EVIDÊNCIA
   ↓
EXCEÇÃO
   ↓
IMPACTO
   ↓
AÇÃO

Suponha que encontramos dez computadores com determinado software instalado.

O auditor não deveria imediatamente gritar:

— IRREGULARIDADE!

Primeiro precisamos entender.

As dez licenças existem?

São necessárias?

São utilizadas?

Existem vinte licenças compradas e apenas dez usadas?

Outro departamento pretende comprar cinco?

Perceba a mudança.

A auditoria pode descobrir economia.

Departamento A:

20 licenças compradas
10 utilizadas
10 ociosas

Departamento B:

10 utilizadas
precisa de mais 5

Sem inventário, B compra cinco novas licenças.

Com governança, talvez seja possível reaproveitar licenças disponíveis, dependendo das condições contratuais do produto.

Auditoria também é otimização de recursos.


📦 CAPÍTULO 6 — O SOFTWARE QUE NINGUÉM USAVA

Outra preocupação clássica era encontrar software instalado e não utilizado.

Isso parece pequeno até multiplicarmos pelo tamanho da empresa.

Imagine 3.000 computadores.

Agora imagine software pago instalado em centenas deles sem necessidade.

Dinheiro parado.

O mesmo vale para hardware.

Uma área pode possuir computadores subutilizados enquanto outra solicita equipamentos novos.

Daí a necessidade de conhecer:

  • localização;

  • departamento;

  • usuário responsável;

  • fabricante;

  • modelo;

  • configuração;

  • número de série;

  • software instalado;

  • situação operacional;

  • manutenção;

  • movimentações.

Hoje chamamos grande parte desse universo de IT Asset Management — ITAM.

Para software existe Software Asset Management — SAM.

O velho inventário da microinformática evoluiu.

Mas a pergunta continua:

O que possuímos, onde está, quem usa, quanto custa e ainda precisamos disso?


🗃️ CAPÍTULO 7 — O CADASTRO DIZ 327, MAS LLOYD CONTOU 319

Aqui entramos no coração da auditoria.

Imagine o cadastro:

MICROCOMPUTADORES: 327

Lloyd percorre a empresa e encontra:

MICROCOMPUTADORES: 319

Faltam oito.

Isso não significa automaticamente fraude.

Podem estar:

  • em manutenção;

  • transferidos;

  • emprestados;

  • armazenados;

  • descartados;

  • substituídos;

  • roubados;

  • simplesmente cadastrados incorretamente.

Mas existe uma diferença.

E diferenças precisam ser explicadas.

É por isso que o texto original insiste tanto em:

bater cadastro de hardware e software com o existente.

Hoje chamaríamos isso de reconciliação.

O que nossa base acredita existir precisa ser comparado ao que realmente existe.

Esse princípio aparece em CMDBs modernas.


🧠 CAPÍTULO 8 — A EMPRESA TEM CÓDIGO, MAS PERDEU A MEMÓRIA

Agora chegamos a uma das questões mais profundas:

Como preservar a memória da empresa diante do turnover?

Voltemos ao João.

João criou uma aplicação.

Durante quinze anos recebeu solicitações:

— João, cliente XPTO precisa de tratamento diferente.

João altera.

Depois:

— João, quando o produto for 37, calcule assim.

João altera.

Depois:

— João, operações realizadas depois das 17h precisam entrar no próximo ciclo.

João altera.

Quinze anos depois existe isto:

IF CLIENTE = 'XPTO'
   ...
END-IF

A empresa possui o código.

Mas por que XPTO é diferente?

João sabe.

O programa não.

Então João se aposenta.

💀

Essa situação não é exclusividade da microinformática.

Programador COBOL conhece perfeitamente esse fenômeno.

Podemos possuir o fonte de um programa de 1989 e ainda assim não possuir todo o conhecimento necessário para compreender por que ele foi construído daquela maneira.

Existe diferença entre:

CÓDIGO

e:

CONHECIMENTO

Código registra o que acontece.

Documentação, histórico, requisitos, tickets e conhecimento humano ajudam a explicar por que acontece.


📝 CAPÍTULO 9 — DOCUMENTAÇÃO NÃO É DECORAÇÃO

Por isso “documentação inexistente” aparece como risco.

Imagine encontrar:

CALCULA.EXE

Perguntas:

Quem desenvolveu?

Qual linguagem?

Onde está o fonte?

Qual versão está em produção?

Quais arquivos utiliza?

Quem pode alterar?

Existe procedimento de instalação?

Como recuperar?

Qual é a regra de negócio?

Quem é responsável?

Sem respostas, temos uma espécie de artefato mágico.

Funciona.

Ninguém sabe exatamente como.

Lloyd adoraria.

O auditor teria pesadelos.


💾 CAPÍTULO 10 — WINCHESTER NÃO É ARQUIVO MORTO

Para os Padawans que nasceram na era do SSD: “Winchester” tornou-se uma forma popular de chamar o disco rígido.

E havia um problema.

O usuário descobria espaço em disco e começava a guardar tudo.

Logo apareciam estruturas dignas de arqueologia:

C:\
 ├── TESTE
 ├── TESTE2
 ├── TESTEVELHO
 ├── BACKUP
 ├── BACKUP2
 ├── NOVO
 ├── NOVO2
 ├── FINAL
 └── FINAL_AGORA_VAI

Parece antigo?

Abra uma pasta corporativa moderna.

Talvez encontre:

Contrato_Final.docx
Contrato_Final2.docx
Contrato_Final_Novo.docx
Contrato_Final_Revisado.docx
Contrato_Final_Revisado_FINAL.docx
Contrato_Final_Revisado_FINAL_v3.docx

Mudamos de storage.

O ser humano permaneceu compatível com versões anteriores.

Essa é a verdadeira retrocompatibilidade.


🧹 CAPÍTULO 11 — FRAGMENTAÇÃO, DEFRAG E ARQUEOLOGIA DOS DISCOS

O texto original também menciona arquivos fragmentados.

Nos discos magnéticos, um arquivo podia acabar armazenado em partes espalhadas pelo disco.

Simplificando:

Arquivo A:

[10][11][12] ........ [58] .... [97]

Um disco mecânico possui partes móveis.

O cabeçote precisa acessar diferentes posições.

Quanto mais espalhados os dados, potencialmente maior o trabalho necessário para determinadas operações.

Daí a popularização de ferramentas de desfragmentação.

Quem viveu DOS e Windows antigos provavelmente lembra de utilitários como DEFRAG, além de ferramentas de diagnóstico e manutenção de disco.

Mas atenção:

não devemos transportar automaticamente essa prática para SSDs modernos.

SSDs funcionam de maneira diferente, não possuem cabeçote mecânico e utilizam mecanismos como wear leveling e TRIM.

Aqui existe uma lição fantástica para auditoria:

o princípio pode sobreviver mesmo quando o controle técnico fica obsoleto.

O princípio era:

manter armazenamento saudável, organizado e adequadamente administrado.

A implementação mudou.


🦠 CAPÍTULO 12 — O DEMÔNIO VIAJAVA DE DISQUETE

Outra preocupação era antivírus.

Durante a era da microinformática, disquetes eram excelentes meios de transporte para dados.

E para vírus.

Um disquete passava por:

PC A
 ↓
PC B
 ↓
PC C
 ↓
casa
 ↓
PC D
 ↓
empresa

O malware ganhava transporte gratuito.

Com o tempo vieram vírus de arquivos, boot sector, macrovírus e inúmeras outras famílias.

Hoje a pergunta:

“Existe antivírus?”

é insuficiente.

Em um ambiente moderno poderíamos investigar:

EDR/XDR
patch management
hardening
MFA
least privilege
application control
telemetria
SIEM
resposta a incidentes
gestão de vulnerabilidades

A pergunta fundamental permanece:

Conseguimos prevenir, detectar, investigar e responder a comportamento malicioso no endpoint?


🔐 CAPÍTULO 13 — O PC DESCOBRIU QUE PRECISAVA DE RACF

Aqui temos um choque cultural delicioso para quem conhece mainframe.

O mainframe corporativo já possuía uma longa tradição de controles de acesso.

No mundo IBM Z podemos pensar em mecanismos como RACF e outros componentes de segurança.

Mas muitos PCs antigos foram concebidos originalmente para um contexto bastante diferente.

O usuário ligava a máquina e encontrava:

C:\>

Não existia necessariamente aquele mesmo modelo corporativo robusto de identidade, autorização e auditoria.

Quando o PC começou a processar informações importantes, surgiu uma pergunta inevitável:

Como transportar os conceitos de segurança existentes nos ambientes corporativos para a microinformática?

Não significava instalar RACF em DOS.

Significava transportar princípios.

MAINFRAME                  ENDPOINT

Identidade       →         Conta do usuário
Autorização      →         Permissões
Dataset          →         Arquivo/pasta
Auditoria        →         Logs
Backup           →         Backup endpoint
Change control   →         Gestão de software
Inventário       →         Asset Management

A tecnologia muda.

O objetivo do controle permanece.


🌐 CAPÍTULO 14 — MICRO E MAINFRAME SE ENCONTRAM

Outro item importantíssimo era a ligação micro/mainframe.

Primeiro o PC podia funcionar quase como terminal.

Depois começaram transferências de arquivos.

Depois vieram redes, client/server, aplicações gráficas e integrações cada vez mais sofisticadas.

Hoje podemos ter:

Notebook
   ↓
Browser
   ↓
Aplicação Web
   ↓
API Gateway
   ↓
API
   ↓
z/OS Connect
   ↓
CICS
   ↓
COBOL
   ↓
Db2

O usuário talvez nem saiba que existe COBOL.

Ele aperta:

CONFIRMAR PAGAMENTO

e, alguns milissegundos depois, uma transação pode estar chegando a uma aplicação no mainframe.

A velha pergunta:

“Como o micro se conecta ao mainframe?”

evoluiu para:

“Como endpoints, canais digitais, aplicações distribuídas, APIs, cloud e parceiros acessam os serviços corporativos?”

É a mesma árvore genealógica.


💽 CAPÍTULO 15 — BACKUP NÃO É COPIAR PARA BACKUP2

Lloyd encontra uma pasta:

C:\BACKUP

— Excelente! Há backup!

Não necessariamente.

Talvez ela esteja no mesmo disco.

Se o disco morrer:

ORIGINAL  → morreu
BACKUP    → morreu junto

Um verdadeiro backup exige planejamento.

O documento original já perguntava:

  • periodicidade;

  • responsável;

  • local de guarda;

  • como recuperar.

A última questão vale ouro:

como recuperar?

Backup que nunca foi testado é uma promessa.

Em ambientes modernos adicionamos conceitos como:

RPO — Recovery Point Objective

Quanto dado podemos tolerar perder?

RTO — Recovery Time Objective

Quanto tempo podemos tolerar ficar sem o serviço?

Além disso:

  • retenção;

  • cópias off-site;

  • criptografia;

  • imutabilidade;

  • testes de restauração;

  • proteção contra ransomware;

  • estratégia 3-2-1 quando apropriada.

A evolução conceitual é interessante:

BACKUP
   ↓
RECOVERY
   ↓
DISASTER RECOVERY
   ↓
BUSINESS CONTINUITY
   ↓
CYBER RESILIENCE

Não queremos simplesmente possuir cópias.

Queremos conseguir continuar ou recuperar o negócio.


⚡ CAPÍTULO 16 — CONFIG.SYS E AUTOEXEC.BAT: NÃO MEXA NO GRIMÓRIO

Quem viveu DOS provavelmente sorriu ao encontrar:

CONFIG.SYS
AUTOEXEC.BAT

Esses arquivos participavam da configuração do ambiente.

Alterações podiam carregar drivers, modificar memória, definir variáveis, caminhos e executar comandos durante a inicialização.

Era perfeitamente possível alguém “otimizar” a máquina e quebrar alguma coisa.

Isso nos leva a outro conceito moderno:

Configuration Management.

Configuração também é ativo.

Hoje não estamos preocupados com AUTOEXEC.BAT da mesma maneira.

Estamos preocupados com:

políticas
registry
GPO
MDM
containers
YAML
Terraform
Ansible
Kubernetes manifests
cloud configuration

Novamente:

o arquivo mudou.

O problema continuou.


📚 CAPÍTULO 17 — O CATÁLOGO DE SOFTWARE

O documento propõe manter um catálogo de software.

Excelente ideia.

Imagine três departamentos.

Todos precisam resolver o mesmo problema.

Cada um contrata um fornecedor diferente.

Resultado:

Área A → Sistema X
Área B → Sistema Y
Área C → Sistema Z

Agora temos três contratos, três tecnologias, três equipes, três processos de suporte e três integrações.

Talvez exista justificativa.

Mas talvez ninguém soubesse que uma solução já existia.

Um catálogo corporativo ajuda a responder:

Já temos alguma coisa que faz isso?

Esse conceito evoluiu para catálogos de aplicações, portfolios de aplicações e ferramentas de Application Portfolio Management.


🧪 CAPÍTULO 18 — COMO LLOYD FARIA UMA AUDITORIA

Vamos transformar tudo em um pequeno laboratório.

Etapa 1 — Conheça a história

Pergunte:

Quando começou a microinformática?

Por quê?

Quem decidiu?

Havia estratégia?

Compra ou aluguel?

Existia padronização?

Etapa 2 — Conheça as políticas

Descubra quais normas deveriam ser cumpridas.

Sem critério não existe avaliação consistente.

Etapa 3 — Obtenha o inventário

Precisamos saber o que a organização acredita possuir.

Etapa 4 — Vá a campo

Agora verificamos o que realmente existe.

Etapa 5 — Compare

REGISTRO
   versus
REALIDADE

Etapa 6 — Teste controles

Não pergunte somente:

— Existe backup?

Peça evidência.

Não pergunte somente:

— Existe antivírus?

Verifique.

Não pergunte somente:

— Existe documentação?

Leia.

Etapa 7 — Investigue diferenças

Toda divergência precisa de contexto.

Etapa 8 — Avalie risco

Uma diferença cadastral em um PC isolado não possui necessariamente o mesmo impacto que uma aplicação não documentada processando milhões em operações financeiras.

Etapa 9 — Recomende ações

A recomendação deve atacar causa e risco, não apenas o sintoma.


🕵️ CAPÍTULO 19 — O AUDITOR QUE PROCURA CAUSA, NÃO CULPADO

Imagine encontrar um PC sem proteção adequada.

Auditoria superficial:

“Usuário em desacordo com a norma.”

Auditoria investigativa:

Por que isso aconteceu?

Descobrimos que o agente deveria ser instalado automaticamente.

Por que não foi?

A máquina estava fora do inventário.

Por quê?

Foi transferida entre departamentos sem atualização cadastral.

Agora temos uma cadeia:

Transferência inadequada
        ↓
Inventário incorreto
        ↓
Gestão não identifica endpoint
        ↓
Controle não é aplicado
        ↓
Endpoint fica desprotegido

O computador sem proteção era apenas o último sintoma.

A verdadeira descoberta está no processo quebrado.

Isso é muito mais valioso.


☁️ CAPÍTULO 20 — O PC VIROU CLOUD

Agora chegamos à ironia histórica.

Décadas atrás:

“O departamento comprou um PC sem informar o CPD.”

Depois:

“Instalaram um software sem informar TI.”

Depois:

“Colocaram um servidor Linux embaixo da mesa.”

Depois:

“Criaram uma VM.”

Depois:

“Contrataram SaaS no cartão corporativo.”

Depois:

“Criaram recursos na Cloud.”

Agora:

“Colaram dados corporativos numa IA generativa.”

Percebeu?

O objeto mudou.

O padrão permanece:

TECNOLOGIA FICA MAIS ACESSÍVEL
             ↓
USUÁRIO GANHA AUTONOMIA
             ↓
INOVAÇÃO ACELERA
             ↓
GOVERNANÇA PERDE VISIBILIDADE
             ↓
RISCO APARECE
             ↓
NOVOS CONTROLES SÃO CRIADOS

É praticamente um ciclo histórico da tecnologia empresarial.


🤖 CAPÍTULO 21 — SHADOW AI: O NOVO LOTUS 1-2-3 CLANDESTINO

E chegamos a 2026.

Um funcionário descobre uma ferramenta de IA.

Começa usando para corrigir textos.

Depois resume documentos.

Depois analisa contratos.

Depois envia código.

Depois envia dados de clientes.

Depois constrói um agente.

Em algum momento a experiência pessoal pode virar processo empresarial.

A auditoria moderna deveria perguntar:

Qual ferramenta?
Quem autorizou?
Qual contrato?
Qual modelo?
Quais dados entram?
Onde são processados?
Existe retenção?
Existe logging?
Existe DLP?
Quem revisa as respostas?
Há integração com sistemas?
Quais permissões o agente possui?
Existe supervisão humana?
Como desligamos isso?

Compare com a auditoria antiga:

Qual software?
Quem comprou?
Onde está instalado?
Quem utiliza?
Quais arquivos acessa?
Existe documentação?
Existe backup?
Quem é responsável?

Lloyd provavelmente sorriria.

— É o mesmo feitiço!

Exatamente.


🧠 CAPÍTULO 22 — DO PERSONAL COMPUTER AO PERSONAL AGENT

Existe ainda uma evolução curiosa.

O PC democratizou processamento.

A Web democratizou publicação.

Cloud democratizou infraestrutura.

SaaS democratizou software corporativo.

Low-code democratizou desenvolvimento.

IA generativa democratizou parte da produção intelectual e automação.

Agentes começam a democratizar execução autônoma de tarefas.

Portanto a pergunta histórica da auditoria fica ainda mais importante:

Quanto de liberdade podemos oferecer sem perder governança, segurança e responsabilidade?

Não existe resposta simples.

Bloquear tudo destrói produtividade.

Liberar tudo cria riscos.

A solução normalmente está entre os extremos:

AUTONOMIA
    +
GUARDRAILS
    +
OBSERVABILIDADE
    +
RESPONSABILIDADE

🧙‍♂️ CAPÍTULO 23 — O QUE UM PROGRAMADOR COBOL TEM A VER COM ISSO?

Tudo.

Você talvez pense:

“Bellacosa, eu só quero programar COBOL.”

Então guarde esta lição.

Um programa não existe isoladamente.

Seu COBOL participa de um ecossistema:

Usuário
 ↓
Canal
 ↓
Aplicação
 ↓
API / MQ / CICS
 ↓
COBOL
 ↓
Db2 / IMS / VSAM
 ↓
Batch
 ↓
Outros sistemas

Cada seta possui:

  • identidade;

  • autorização;

  • configuração;

  • logs;

  • documentação;

  • dependências;

  • recuperação;

  • responsáveis.

Um excelente programador não conhece somente sintaxe.

Ele começa a entender o sistema ao redor do programa.


🏺 CAPÍTULO 24 — SEU PROGRAMA COBOL É UM ARTEFATO HISTÓRICO

Imagine abrir um programa:

       IF WS-CUSTOMER-CODE = 317
           PERFORM SPECIAL-PROCESSING
       END-IF.

Não remova imediatamente.

Pergunte:

Por quê?

Talvez exista uma regra contratual de 1997.

Talvez o cliente nem exista mais.

Talvez seja código morto.

Talvez seja absolutamente crítico.

O auditor e o mantenedor de legado compartilham uma virtude:

desconfiança metodológica.

Não significa suspeitar das pessoas.

Significa não confundir aparência com evidência.

O código compila?

Ótimo.

Mas está correto?

Tem teste?

Tem documentação?

Quem depende dele?

Qual impacto de uma alteração?

Essa mentalidade transforma um digitador de COBOL em engenheiro de sistemas.


🕒 CAPÍTULO 25 — O EASTER EGG DAS 03:17

Lloyd encontra uma documentação antiga:

“Não executar antes das 03:17.”

— Por quê?

Silêncio.

Ninguém sabe.

O programador original se aposentou.

O analista que conhecia o processo saiu.

O documento não explica.

Lloyd, naturalmente, executa às 03:16.

A dungeon inteira começa a tremer.

😂

Esse é o easter egg, mas também contém uma lição séria.

Uma organização pode preservar:

O QUE FAZER

e perder:

POR QUE FAZER

Esse segundo conhecimento é frequentemente muito mais difícil de reconstruir.

Por isso bons comentários, documentação, versionamento, tickets, decisões arquiteturais e transferência de conhecimento são tão importantes.


🗺️ CAPÍTULO 26 — A EVOLUÇÃO COMPLETA DA DUNGEON

Podemos finalmente montar nosso mapa:

MAINFRAME CENTRALIZADO
        ↓
MICROCOMPUTADOR
        ↓
REDES LOCAIS
        ↓
CLIENT/SERVER
        ↓
INTERNET
        ↓
WEB
        ↓
VIRTUALIZAÇÃO
        ↓
CLOUD
        ↓
SAAS
        ↓
LOW-CODE
        ↓
GENERATIVE AI
        ↓
AI AGENTS

A cada camada, a tecnologia fica mais acessível.

E surge novamente a pergunta:

Quem governa?


☕ EPÍLOGO — LLOYD FINALMENTE ENTENDEU O VERDADEIRO FEITIÇO

Depois de examinar computadores, discos, aplicativos, números de série, backups, documentação e cadastros, Lloyd chegou a uma conclusão.

A auditoria de microinformática nunca foi realmente sobre contar computadores.

Também não era sobre procurar arquivos pessoais no Winchester.

Nem sobre descobrir quem havia instalado três processadores de texto diferentes.

Era sobre uma coisa muito maior:

descobrir se a empresa continuava conhecendo e controlando a tecnologia da qual havia passado a depender.

Nos tempos do mainframe, boa parte desse universo estava centralizada.

O PC distribuiu poder computacional.

A rede conectou esse poder.

A Internet expandiu as fronteiras.

Cloud distribuiu infraestrutura.

SaaS distribuiu aplicações.

Low-code distribuiu desenvolvimento.

IA distribuiu capacidade cognitiva.

Agentes começam a distribuir capacidade de ação.

E toda vez que distribuímos poder tecnológico, precisamos redistribuir também:

RESPONSABILIDADE
CONTROLE
CONHECIMENTO
SEGURANÇA
OBSERVABILIDADE

Caso contrário teremos sistemas funcionando perfeitamente...

...que ninguém sabe que existem.

Lloyd fechou o velho computador.

— Então encontramos o demônio?

O auditor balançou a cabeça.

— Não exatamente.

— Encontramos uma aplicação crítica sem documentação?

— Sim.

— Sem responsável?

— Sim.

— Sem backup testado?

— Sim.

— Fora do inventário?

— Sim.

— E ninguém sabe quem criou?

— Exatamente.

Lloyd sorriu.

— Excelente! Quero ver o código!

O auditor começou a suar.

Na tela apareceu:

C:\SISTEMA> DIR

CLIENTES.DBF
FATURA.DBF
CALCULA.EXE
README.TXT

Lloyd abriu o README.

Havia apenas uma frase:

“NÃO APAGAR. É IMPORTANTE.”

Nenhuma assinatura.

Nenhuma documentação.

Nenhum responsável.

Nenhuma explicação.

Lloyd ficou maravilhado.

O auditor pediu café.

E em algum lugar do castelo, provavelmente às 03:17, um velho batch COBOL terminou com:

CC 0000

sem jamais imaginar que, décadas depois, continuávamos tentando resolver exatamente o mesmo problema.

Porque computadores mudam.

Linguagens mudam.

Storage muda.

Redes mudam.

Cloud muda.

IA muda.

Mas existe uma constante assustadoramente retrocompatível:

Toda tecnologia que começa como experiência pode acabar virando infraestrutura crítica antes que alguém perceba.

E talvez essa seja a verdadeira magia que Lloyd de Saloum precisava aprender.

Não a magia de criar sistemas.

Mas a magia muito mais difícil de saber quais sistemas existem, por que existem, quem responde por eles e o que acontecerá quando alguma coisa der errado.

☕ Bem-vindo ao Bellacosa Mainframe.

Onde até um PC esquecido debaixo de uma mesa pode esconder uma dungeon inteira de governança corporativa.

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.

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