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

Translate

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

quinta-feira, 14 de dezembro de 2023

🧪 SENKU E A DUNGEON DOS FUNDAMENTOS — QUANDO O PROGRAMADOR COBOL DESCOBRIU QUE O IF TINHA BILHÕES DE TRANSISTORES ESCONDIDOS

 

Bellacosa Mainframe e fundamentos da informatica

☕ Um Café no Bellacosa Mainframe

🧪 SENKU E A DUNGEON DOS FUNDAMENTOS — QUANDO O PROGRAMADOR COBOL DESCOBRIU QUE O IF TINHA BILHÕES DE TRANSISTORES ESCONDIDOS

CPU, ALU, registradores, memória, cache, binário, hexadecimal, EBCDIC, sistemas operacionais, redes, bancos de dados, SQL, virtualização, cloud, containers — e o dia em que Senku Ishigami decidiu reconstruir a Ciência da Computação, uma abstração de cada vez.



🎬 PRÓLOGO — DEZ BILHÕES POR CENTO CERTEZA DE QUE NÃO É MAGIA

Imagine a situação.

Você acabou de entrar no mundo do mainframe.

Aprendeu seus primeiros comandos COBOL:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. PEDRA001.

       DATA DIVISION.
       WORKING-STORAGE SECTION.

       01 WS-SALDO       PIC 9(7)V99 VALUE 1000.00.
       01 WS-COMPRA      PIC 9(7)V99 VALUE 150.00.

       PROCEDURE DIVISION.

           IF WS-SALDO >= WS-COMPRA
               DISPLAY 'COMPRA AUTORIZADA'
           ELSE
               DISPLAY 'SALDO INSUFICIENTE'
           END-IF.

           STOP RUN.

Compilou.

Executou.

Funcionou.

Você olha para a tela e pensa:

“Entendi. O computador comparou dois números.”

Nesse momento, Senku Ishigami, de Dr. Stone, provavelmente apareceria carregando alguma engenhoca feita com pedras, fios, ácido sulfúrico e uma quantidade suspeita de confiança científica.

— Errado!

Não porque o programa esteja errado.

Mas porque entre:

IF WS-SALDO >= WS-COMPRA

e:

COMPRA AUTORIZADA

existe uma civilização inteira.

CPU.

Registradores.

Cache.

RAM.

Sistema operacional.

Memória virtual.

Encoding.

Storage.

Compilador.

Instruções de máquina.

Talvez Db2.

Talvez CICS.

Talvez MQ.

Talvez TCP/IP.

Talvez uma API.

Talvez outro computador do outro lado do planeta.

A melhor maneira de entender fundamentos de computação, portanto, não é decorar vinte definições para uma prova.

É fazer algo muito mais próximo da filosofia de Dr. Stone:

reconstruir o computador conceitualmente, camada por camada.

Pegue uma pedra.

Depois outra.

Depois eletricidade.

Depois lógica.

Depois memória.

Depois software.

Quando terminarmos nossa dungeon, aquela pequena instrução COBOL nunca mais parecerá tão pequena.



🪨 CAPÍTULO 1 — ANTES DO COBOL EXISTIA A PEDRA

Vamos começar do absoluto zero.

O que é um computador?

Uma definição introdutória bastante útil seria:

Um computador é uma máquina eletrônica programável capaz de receber dados, processá-los, armazená-los e produzir resultados.

Temos então:

INPUT
  ↓
PROCESSING
  ↓
OUTPUT
  ↓
STORAGE

Um teclado fornece entrada.

A CPU processa.

Um monitor apresenta saída.

Um dispositivo de armazenamento preserva dados.

Essa explicação funciona.

Mas Senku provavelmente perguntaria:

— O que significa processar?

E aí começa nossa aventura.

Processar significa transformar um estado em outro seguindo regras.

Considere:

SALDO = 1000
COMPRA = 150

O computador recebe esses valores e executa determinada transformação.

Depois:

SALDO = 850

Nada disso possui significado financeiro para a CPU.

Para ela não existem:

clientes, salários, boletos, cartões, parcelas ou financiamento.

Existem representações.

Nós, humanos, construímos significado em cima delas.

Essa diferença entre dado e informação é importante.

Considere:

80
90
70

São dados.

Quando aplicamos uma regra:

(80 + 90 + 70) / 3 = 80

produzimos algo interpretável:

MÉDIA = 80

O processamento transformou dados em informação útil dentro de determinado contexto.

É exatamente isso que sistemas empresariais fazem bilhões de vezes.



⚡ CAPÍTULO 2 — SENKU DESCOBRE O BIT

Precisamos agora construir nosso computador.

Infelizmente ainda não temos COBOL.

Nem Windows.

Nem z/OS.

Nem sequer uma CPU.

Temos eletricidade.

Precisamos representar informação fisicamente.

Uma solução extraordinariamente poderosa é trabalhar com dois estados.

Conceitualmente:

0
1

Nasce o bit, abreviação de binary digit.

Um bit pode representar duas possibilidades.

Com dois bits:

00
01
10
11

temos quatro combinações.

Com três:

000
001
010
011
100
101
110
111

oito combinações.

A fórmula geral é:

2ⁿ

Com 8 bits:

2⁸ = 256

combinações possíveis.

Oito bits formam convencionalmente um byte.

Agora já podemos representar números.



🔢 CAPÍTULO 3 — O PROGRAMADOR COBOL ENTRA NA DUNGEON DO BINÁRIO

Nós utilizamos normalmente base decimal:

347

Na verdade isso significa:

3 × 10² +
4 × 10¹ +
7 × 10⁰

ou:

300 + 40 + 7

Binário funciona exatamente da mesma maneira, apenas utilizando base 2.

Considere:

1011₂

Temos:

1 × 2³ = 8
0 × 2² = 0
1 × 2¹ = 2
1 × 2⁰ = 1

Portanto:

1011₂ = 11₁₀

Não há magia.

É apenas um sistema posicional com outra base.



🧙 CAPÍTULO 4 — SURGE O HEXADECIMAL

Imagine analisar:

110101101101101111101111

Depois de algumas horas, até Senku pediria café.

Por isso hexadecimal é tão conveniente.

Ele utiliza base 16:

0 1 2 3 4 5 6 7 8 9 A B C D E F

A grande vantagem é:

um dígito hexadecimal representa exatamente quatro bits.

Assim:

1111₂ = F₁₆

E:

11111111₂ = FF₁₆

Para um programador mainframe, hexadecimal não é apenas matéria escolar.

Quando começamos a analisar dumps, campos, bytes e problemas de dados, ele pode se transformar numa ferramenta cotidiana.

Dica de Padawan COBOL:

aprenda hexadecimal antes de precisar dele em produção às 03:17.

Sim, 03:17.

Guarde esse horário.

Toda dungeon precisa de um easter egg.


🧪 CAPÍTULO 5 — CPU: O LABORATÓRIO DE SENKU

Agora precisamos de algo capaz de executar operações.

Chegamos à CPU — Central Processing Unit.

Materiais introdutórios normalmente apresentam três componentes conceituais:

CPU
├── ALU
├── Control Unit
└── Registers

A ALU — Arithmetic and Logic Unit executa operações aritméticas e lógicas.

Exemplos:

+
-
*
/
AND
OR
NOT
>
<
=

A Control Unit coordena a execução das instruções.

Os registradores são pequenas áreas de armazenamento extremamente rápidas dentro do processador.

Podemos imaginar o ciclo clássico:

FETCH
 ↓
DECODE
 ↓
EXECUTE
 ↓
FETCH...

Primeiro a CPU busca uma instrução.

Depois descobre o que aquela instrução significa.

Finalmente executa a operação correspondente.

É uma simplificação, naturalmente.

Processadores modernos possuem pipelines, múltiplas unidades de execução, predição de desvios, execução especulativa e inúmeros outros mecanismos.

Mas nosso modelo é excelente para começar.


🧮 CAPÍTULO 6 — A ALU NÃO SABE O QUE É DINHEIRO

Aqui aparece algo fascinante para quem vem do COBOL.

Considere:

01 WS-PRECO PIC S9(7)V99 COMP-3.

COMP-3 indica uma representação decimal compactada (packed decimal).

Por que isso interessa?

Porque computadores são naturalmente excelentes em binário, enquanto aplicações comerciais frequentemente precisam lidar cuidadosamente com decimal.

Dinheiro é o exemplo clássico.

Em algumas representações de ponto flutuante binário, valores decimais aparentemente simples não possuem representação exata.

Para aplicações científicas isso pode ser perfeitamente administrável.

Mas:

R$ 1.000.000,00

não é o tipo de número no qual o banco gostaria de descobrir um centavo filosófico surgido por aproximação.

A computação empresarial desenvolveu durante décadas mecanismos especializados para aritmética decimal.

COBOL está profundamente ligado a essa história.


🏎️ CAPÍTULO 7 — REGISTRADORES, CACHE, RAM E A CORRIDA PELA MEMÓRIA

A CPU é extremamente rápida.

Mas existe um problema:

buscar dados custa tempo.

Por isso computadores possuem uma hierarquia de memória.

Simplificando:

        REGISTRADORES
             ↓
            L1
             ↓
            L2
             ↓
            L3
             ↓
            RAM
             ↓
         SSD / DASD
             ↓
      armazenamento remoto

Quanto mais próximo da CPU, normalmente temos:

mais velocidade
menos capacidade
maior custo por byte

Quanto mais distante:

mais capacidade
maior latência
menor custo relativo

A cache explora principalmente duas propriedades muito interessantes dos programas.

Localidade temporal

Se você acabou de utilizar determinado dado, talvez precise dele novamente.

Localidade espacial

Se acessou determinado endereço, provavelmente poderá acessar dados próximos.

Considere:

PERFORM VARYING WS-I FROM 1 BY 1
    UNTIL WS-I > 100000
       ADD WS-VALOR(WS-I) TO WS-TOTAL
END-PERFORM.

O acesso sequencial pode apresentar comportamento bastante favorável à hierarquia de memória.

Isso nos ensina algo importante:

performance não depende somente do número de linhas do programa.

O modo como acessamos memória e dados importa.


💾 CAPÍTULO 8 — RAM NÃO É DISCO

Outra confusão comum entre iniciantes:

“Meu computador tem 16 GB de memória e 1 TB de memória.”

Não exatamente.

Os 16 GB provavelmente são RAM.

O 1 TB provavelmente corresponde ao armazenamento persistente.

RAM é memória de trabalho, normalmente volátil.

SSD, HDD ou armazenamento empresarial preservam dados de maneira persistente.

No mundo mainframe podemos pensar em:

DASD
  ↓
DATASET
  ↓
BUFFER
  ↓
MEMÓRIA
  ↓
CACHE
  ↓
CPU

Quando seu COBOL escreve:

READ ARQ-CLIENTES

parece que o programa simplesmente “leu o arquivo”.

Mas entre a instrução e o dado podem existir várias camadas de software, memória, buffers, cache, canais e armazenamento.

A simplicidade do COBOL é construída sobre uma enorme complexidade escondida.


🏰 CAPÍTULO 9 — SISTEMA OPERACIONAL: O SENKU DOS RECURSOS

Chegamos ao sistema operacional.

Ele administra recursos como:

CPU
memória
processos
arquivos
dispositivos
segurança
usuários
I/O

Mas sua função intelectualmente mais interessante talvez seja outra:

criar abstrações.

Você diz:

ARQUIVO

O sistema operacional esconde inúmeros detalhes físicos.

Você diz:

PROCESSO

Ele administra execução, memória e recursos.

Você pensa:

MEMÓRIA

Por baixo podem existir mecanismos sofisticados de memória virtual e tradução de endereços.

É como se o sistema operacional dissesse:

“Programador, cuide do seu problema. Eu cuido desta dungeon.”

No universo IBM Z encontramos um caso extraordinariamente rico:

IBM Z
 │
PR/SM
 │
LPAR
 │
z/OS

E podemos ter múltiplas partições executando diferentes workloads e sistemas.

A virtualização não nasceu com a cloud.

O universo mainframe possui uma história de virtualização que antecede em décadas boa parte da terminologia moderna de infraestrutura.


👻 CAPÍTULO 10 — SENKU ENCONTRA O FANTASMA DO EBCDIC

Agora precisamos representar letras.

Um computador não armazena conceitualmente a letra:

A

Ele armazena uma representação numérica interpretada segundo determinada codificação.

Em ASCII:

A = 0x41

Em páginas EBCDIC comuns:

A = 0xC1

E aqui encontramos uma criatura muito conhecida da dungeon mainframe:

EBCDIC

Extended Binary Coded Decimal Interchange Code.

Quem trabalha apenas com sistemas distribuídos modernos pode passar anos praticamente sem pensar nele.

Quem integra mainframe com outros ambientes eventualmente descobre sua existência.

Imagine:

COBOL / EBCDIC
       ↓
      MQ
       ↓
 integração
       ↓
 JSON / UTF-8
       ↓
 aplicação web

Se as conversões forem incorretas, aparecem caracteres aparentemente misteriosos.

Não foi um espírito.

Não foi RACF.

Não foi CICS possuído.

Pode simplesmente ser encoding.

Dica prática:

quando dados textuais atravessarem plataformas diferentes, pergunte sempre qual é a codificação na origem e qual é a codificação no destino.


🌐 CAPÍTULO 11 — SENKU INVENTA A REDE

Temos computadores.

Agora queremos conectá-los.

Podemos encontrar classificações tradicionais:

PAN
LAN
MAN
WAN

Mas compreender redes exige ir além da distância geográfica.

Imagine camadas:

APLICAÇÃO
HTTP / DNS
────────────
TRANSPORTE
TCP / UDP
────────────
REDE
IP
────────────
ENLACE
Ethernet
────────────
FÍSICA
sinais

Quando alguém escreve:

https://exemplo.com

pode ocorrer uma cadeia aproximadamente assim:

nome
 ↓
DNS
 ↓
endereço IP
 ↓
roteamento
 ↓
TCP
 ↓
TLS
 ↓
HTTP
 ↓
aplicação

Agora imagine um programa COBOL CICS expondo funcionalidade por uma API.

De repente:

COBOL

está conversando conceitualmente com:

HTTP
JSON
TLS
TCP/IP

O programa de 30 anos não precisou necessariamente virar JavaScript para participar da Internet.

Essa é uma lição importantíssima sobre modernização:

integrar não significa obrigatoriamente reescrever.


🗄️ CAPÍTULO 12 — O REINO DOS BANCOS DE DADOS

Precisamos armazenar dados organizadamente.

Chegamos aos bancos de dados.

Primeira distinção:

DATABASE ≠ DBMS

O banco contém dados organizados.

O DBMS — Database Management System é o software responsável por gerenciá-los.

Em um banco relacional encontramos conceitos como:

TABLE
ROW
COLUMN
PRIMARY KEY
FOREIGN KEY

Mas um DBMS moderno faz muito mais:

transações
locking
logging
recovery
índices
buffers
segurança
concorrência
otimização
integridade

No mundo mainframe, Db2 é um personagem importantíssimo dessa história.


💰 CAPÍTULO 13 — SENKU TENTA FAZER UMA TRANSFERÊNCIA BANCÁRIA

Suponha:

CONTA A = 1000
CONTA B = 500

Queremos transferir 100.

Precisamos:

A = A - 100
B = B + 100

Mas imagine:

A = A - 100

*** SISTEMA CAI ***

E a segunda operação nunca acontece.

Parabéns.

Inventamos uma máquina de desaparecer dinheiro.

Por isso sistemas transacionais precisam de propriedades robustas.

Surge a famosa ideia de ACID:

Atomicity
Consistency
Isolation
Durability

Atomicidade significa, de forma simplificada:

a transação deve ser tratada como uma unidade — não queremos metade lógica da operação confirmada e metade perdida.

Isso é central para compreender sistemas empresariais.

CICS, Db2 e outros componentes do ecossistema transacional não existem apenas para tornar a arquitetura mais bonita em PowerPoint.

Eles existem porque dinheiro, estoque, reservas e pagamentos não toleram facilmente:

“quase funcionou”.

📜 CAPÍTULO 14 — SQL DESCOBRE UMA MAGIA DIFERENTE DO COBOL

COBOL é predominantemente procedural.

Você escreve uma sequência de ações.

SQL possui natureza declarativa.

Considere:

SELECT NOME, SALDO
FROM CLIENTES
WHERE CIDADE = 'ITATIBA';

Você informou o resultado desejado.

Não necessariamente determinou fisicamente:

abra o arquivo
leia registro
compare cidade
avance
leia novamente
...

O DBMS possui um otimizador.

Ele pode escolher diferentes estratégias.

Por exemplo:

table scan
index access
join
sort

Essa é uma mudança profunda de pensamento.

COBOL frequentemente pergunta:

COMO devo fazer?

SQL frequentemente permite dizer:

O QUE quero obter?

O DBMS procura uma estratégia.

Essa diferença entre programação procedural e declarativa reaparece em muitos outros lugares da computação moderna.


☁️ CAPÍTULO 15 — SENKU OLHA PARA O CÉU E NÃO ENCONTRA A CLOUD

Cloud computing é frequentemente explicada como:

recursos computacionais disponíveis pela Internet.

É um começo.

Mas se fosse somente isso, qualquer servidor remoto dos anos 1990 poderia receber retroativamente um adesivo escrito CLOUD.

O conceito moderno envolve características operacionais importantes:

provisionamento sob demanda
automação
elasticidade
resource pooling
medição de consumo
self-service

Portanto:

CLOUD ≠ COMPUTADOR DE OUTRA PESSOA

Essa piada possui alguma utilidade, mas é insuficiente tecnicamente.

Cloud é também um modelo operacional.

Isso nos leva a uma conexão interessante com mainframe.

Mainframes já praticavam há décadas ideias relacionadas a:

compartilhamento de recursos
virtualização
isolamento
gestão de workload
alta utilização
automação

Cloud não transformou o mainframe numa relíquia.

Na realidade, estudar mainframe ajuda a perceber que várias ideias consideradas modernas possuem ancestrais bastante antigos.


📦 CAPÍTULO 16 — CONTAINER NÃO É UMA VM EMAGRECIDA

Outra confusão clássica.

Máquinas virtuais e containers trabalham com isolamento, mas em níveis diferentes.

Simplificando uma VM:

APLICAÇÃO
   ↓
GUEST OS
   ↓
HYPERVISOR
   ↓
HARDWARE

Agora um container:

APLICAÇÃO
DEPENDÊNCIAS
   ↓
CONTAINER RUNTIME
   ↓
HOST OS
   ↓
HARDWARE

Containers normalmente compartilham recursos do kernel do host em vez de carregar necessariamente um sistema operacional convidado completo para cada instância.

Por isso podem ser leves e rápidos de iniciar.

Mas existe um detalhe importante:

containers e VMs podem coexistir.

Podemos ter:

HARDWARE
   ↓
VIRTUAL MACHINE
   ↓
LINUX
   ↓
CONTAINER RUNTIME
   ↓
CONTAINER

Tecnologia raramente é simplesmente:

VELHO ❌
NOVO ✅

Muito mais frequentemente encontramos:

camada
sobre
camada
sobre
camada.

🧠 CAPÍTULO 17 — SENKU DESCOBRE O VERDADEIRO SEGREDO: ABSTRAÇÃO

Finalmente chegamos ao conceito que une praticamente tudo.

Abstração.

Observe:

APLICAÇÃO
     ↓
COBOL
     ↓
COMPILADOR / RUNTIME
     ↓
MIDDLEWARE
     ↓
SISTEMA OPERACIONAL
     ↓
MEMÓRIA
     ↓
CPU
     ↓
MICROARQUITETURA
     ↓
CIRCUITOS
     ↓
TRANSISTORES
     ↓
FÍSICA

Cada camada permite esquecer temporariamente detalhes da camada inferior.

Sem isso seria praticamente impossível desenvolver sistemas modernos.

Imagine escrever:

DISPLAY 'BOM DIA'.

e precisar manualmente definir:

pixels
buffers
endereços físicos
sinais elétricos
registradores
temporização
I/O

Nunca terminaríamos o sistema.

Abstração é o mecanismo pelo qual transformamos complexidade inadministrável em conceitos utilizáveis.

Mas existe uma regra que todo profissional experiente aprende:

quando a abstração quebra, desça uma camada.


⚔️ CAPÍTULO 18 — O JOB LEVAVA 4 MINUTOS. AGORA LEVA 38.

Chegamos à War Room.

Produção informa:

ONTEM: 4 minutos
HOJE: 38 minutos

O programador iniciante abre imediatamente o COBOL.

Isso não é absurdo.

Pode realmente existir algum problema no programa.

Mas o profissional mais experiente constrói hipóteses.

O volume aumentou?

Mudou o access path do Db2?

Existe mais I/O?

Algum índice mudou?

Há contenção?

Existe locking?

O SORT cresceu?

Mudou o workload concorrente?

Há pressão de CPU?

A memória está pressionada?

Storage está respondendo diferente?

Alguma alteração foi implantada?

O programa está esperando alguma coisa?

Observe a mudança.

O iniciante pensa:

PROGRAMA → PROBLEMA

O engenheiro pensa:

SISTEMA
├── aplicação
├── dados
├── banco
├── middleware
├── sistema operacional
├── rede
├── CPU
├── memória
└── storage

Isso não significa investigar tudo indiscriminadamente.

Significa formular hipóteses e procurar evidências.

Senku aprovaria.

Ciência antes de superstição.


🏛️ CAPÍTULO 19 — O IBM Z COMO LABORATÓRIO DE FUNDAMENTOS

Agora podemos reunir nossa dungeon.

Imagine:

                    IBM Z
                      │
                    PR/SM
                      │
                    LPAR
                      │
                    z/OS
                      │
          ┌───────────┼───────────┐
          │           │           │
         JES         WLM         RACF
          │           │           │
          └───────────┼───────────┘
                      │
          ┌───────────┼───────────┐
          │           │           │
        CICS         Db2          MQ
          │           │           │
          └───────────┼───────────┘
                      │
                    COBOL

Essa representação é propositalmente simplificada, mas revela algo fundamental.

COBOL não é uma ilha.

Quando você aprende apenas sintaxe COBOL, aprende uma camada.

Quando entende:

JCL
datasets
VSAM
Db2
CICS
MQ
JES
RACF
WLM
TCP/IP
z/OS
storage
CPU

começa a enxergar o sistema.

E existe uma enorme diferença entre:

saber escrever um programa

e:

entender o sistema no qual o programa vive.


🧭 CAPÍTULO 20 — ROTEIRO DO PADAWAN: COMO ESTUDAR TUDO ISSO SEM ENLOUQUECER

Não tente aprender tudo simultaneamente.

Construa a civilização como Senku.

Etapa 1 — representação

Aprenda:

bit
byte
binário
hexadecimal
caracteres
ASCII
EBCDIC
Unicode
UTF-8

Faça conversões simples à mão.

Entenda por que:

41

pode significar coisas completamente diferentes dependendo de como interpretamos os bits.

Etapa 2 — hardware

Estude:

CPU
ALU
registradores
cache
RAM
storage
I/O

Não precisa projetar um processador.

Precisa entender onde os dados estão e por que movimentá-los custa tempo.

Etapa 3 — sistema operacional

Entenda:

processo
memória
arquivo
I/O
segurança
virtualização

Depois traduza isso para z/OS.

Etapa 4 — COBOL

Agora:

PIC
MOVE
COMPUTE
IF
EVALUATE
PERFORM
READ
WRITE
CALL

começam a ganhar contexto.

Etapa 5 — dados

Estude:

QSAM
VSAM
Db2
SQL
transações
índices
commit
rollback

Etapa 6 — processamento empresarial

Entre em:

batch
JCL
JES
CICS
Db2
MQ

Etapa 7 — integração

Finalmente:

TCP/IP
HTTP
REST
JSON
APIs
mensageria
cloud
containers

Agora o mainframe deixa de parecer uma máquina isolada e passa a aparecer como aquilo que realmente é:

uma plataforma participante de arquiteturas empresariais muito maiores.


🔬 CAPÍTULO 21 — TRÊS EXPERIMENTOS DE SENKU PARA O PROGRAMADOR COBOL

Faça estes pequenos laboratórios.

Experimento 1 — Hexadecimal. Pegue caracteres como A, 0, espaço e compare suas representações em ASCII e EBCDIC. Depois imagine o que aconteceria se um sistema interpretasse bytes EBCDIC como ASCII.

Você compreenderá encoding melhor do que decorando definições.

Experimento 2 — SQL. Compare mentalmente:

PERFORM UNTIL EOF
    READ CLIENTES
    IF CIDADE = 'ITATIBA'
       DISPLAY NOME
    END-IF
END-PERFORM

com:

SELECT NOME
FROM CLIENTES
WHERE CIDADE = 'ITATIBA';

Pergunte:

quem decidiu como encontrar os registros?

A resposta revela a diferença entre procedural e declarativo.

Experimento 3 — performance. Quando um programa estiver lento, não pergunte imediatamente:

“Qual linha está lenta?”

Pergunte primeiro:

“Onde o tempo está sendo gasto?”

Essas duas perguntas parecem semelhantes.

Não são.


🗿 CAPÍTULO 22 — A CURIOSIDADE ESCONDIDA NA PEDRA

Existe uma ironia histórica deliciosa.

Cada geração acredita ter inventado completamente o futuro.

Virtualização parece moderna.

Computação distribuída parece moderna.

Cloud parece moderna.

Containers parecem modernos.

Inteligência Artificial parece ter surgido ontem.

Mas a computação é uma enorme árvore genealógica.

Ideias reaparecem modificadas.

Problemas antigos recebem novas abstrações.

Tecnologias desaparecem e seus conceitos sobrevivem.

É exatamente por isso que estudar fundamentos continua valendo a pena.

Uma ferramenta pode desaparecer.

Um framework pode desaparecer.

Uma linguagem pode perder popularidade.

Mas conceitos como:

estado
memória
I/O
transação
concorrência
representação
abstração
algoritmo
protocolo
persistência

continuam retornando com roupas diferentes.


☕ EPÍLOGO — O IF DE DUAS LINHAS QUE CARREGA UM SÉCULO DE CIÊNCIA

Voltamos finalmente ao nosso pequeno programa:

IF WS-SALDO >= WS-COMPRA
    DISPLAY 'COMPRA AUTORIZADA'
END-IF.

Agora você sabe que essas duas linhas escondem uma cadeia extraordinária.

O fonte COBOL precisa ser representado por caracteres.

Os caracteres precisam possuir encoding.

O compilador precisa compreender a linguagem.

O programa precisa transformar-se em algo executável pela arquitetura.

O sistema operacional precisa fornecer recursos.

Dados precisam ocupar memória.

A CPU precisa executar instruções.

Registradores e caches participam do processamento.

Talvez o saldo venha do Db2.

Talvez a transação esteja sob CICS.

Talvez uma mensagem atravesse MQ.

Talvez outra plataforma participe pela rede.

Talvez o resultado seja entregue por uma API para um smartphone a milhares de quilômetros do datacenter.

O usuário toca:

COMPRAR

e espera talvez dois segundos.

Ele não quer saber de:

CPU
cache
RAM
EBCDIC
SQL
Db2
CICS
TCP/IP
TLS
MQ
storage

E está certo.

Essa complexidade é problema nosso.

Essa é a beleza da engenharia.

Construímos uma camada para que a próxima possa esquecer a anterior.

Até que um dia algo quebra.

Às 03:17.

O telefone toca.

A aplicação não responde.

O programador olha para o COBOL e diz:

“Mas meu IF está correto!”

Então Senku aparece imaginariamente na War Room, pega o café abandonado ao lado do terminal 3270 e responde:

Então formule outra hipótese.

Esse talvez seja o ensinamento mais importante de todos os fundamentos de computação.

Não decore simplesmente que CPU significa Central Processing Unit.

Não decore que RAM é volátil.

Não decore que DNS converte nomes em endereços.

Não decore que SQL consulta bancos.

Não decore que cloud fornece recursos.

Pergunte por quê.

Pergunte o que existe abaixo.

Pergunte qual abstração está escondendo qual complexidade.

Pergunte onde o dado nasceu, como foi representado, onde foi armazenado, como chegou até a CPU, quem o modificou, como foi persistido e como atravessou a rede.

Porque o dia em que um programador COBOL começa a enxergar:

COBOL
   ↓
CICS / Db2 / MQ
   ↓
z/OS
   ↓
virtualização
   ↓
CPU / memória / I/O
   ↓
hardware

é o dia em que deixa de enxergar somente programas.

Começa a enxergar sistemas.

E esse é um upgrade que nenhum MOVE, PERFORM ou certificado consegue fornecer sozinho.

Senku começou sua reconstrução com pedras, ciência e perguntas.

Nosso Padawan começa com:

IDENTIFICATION DIVISION.

O destino, porém, é muito parecido:

entender como as coisas realmente funcionam.

E quando alguém perguntar se precisamos mesmo conhecer binário, hexadecimal, CPU, memória, sistema operacional, banco de dados, redes, virtualização e cloud para programar COBOL, já temos a resposta.

Para escrever:

DISPLAY 'HELLO'.

provavelmente não.

Para descobrir por que o HELLO não apareceu às 03:17 da madrugada?

Aí começa a verdadeira Ciência da Computação.

Dez bilhões por cento.

quarta-feira, 2 de agosto de 2023

🗄️ ALAN TURING E O Db2 DOS AGENTES — QUANDO DUAS IAs ESTÃO CERTAS EM REALIDADES DIFERENTES

 

Bellacosa Mainframe concorrencia e questoes de dados quem é relevante

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🗄️ ALAN TURING E O Db2 DOS AGENTES — QUANDO DUAS IAs ESTÃO CERTAS EM REALIDADES DIFERENTES

Db2, agentes de IA, COBOL, SQL, ACID, transações, isolamento, locks, MVCC, dirty read, non-repeatable read, phantom read, lost update, optimistic concurrency, timestamps, versionamento, commit, rollback, contexto, temporalidade, proveniência, RAG — e o dia em que Alan Turing descobriu que uma inteligência artificial pode estar absolutamente certa sobre uma realidade que deixou de existir três segundos atrás.



🎬 PRÓLOGO — AS DUAS INTELIGÊNCIAS ESTAVAM CERTAS

Alan Turing entrou no CPD.

Dois pequenos agentes estavam discutindo.

O primeiro gritava:

— O cliente possui R$ 10.000!

O segundo respondia:

— Não! Ele possui R$ 2.000!

Turing olhou para o programador COBOL.

— Qual deles está errado?

— Um dos dois, obviamente.

Turing tomou um gole de café.

— Tem certeza?

Na tela havia:

AGENT-A
READ TIME..... 10:00:01
BALANCE....... 10000.00

Na outra:

AGENT-B
READ TIME..... 10:00:04
BALANCE....... 2000.00

Entre as duas leituras:

10:00:03
WITHDRAWAL.... 8000.00
COMMIT........ OK

Silêncio.

O jovem programador coçou a barba imaginária que todo programador mainframe adquire depois de alguns anos.

Turing perguntou novamente:

— Qual inteligência artificial estava errada?

O pequeno robô respondeu:

— Nenhuma.

— Exatamente.

E escreveu no quadro:

DADOS NÃO EXISTEM FORA DO TEMPO.

A primeira lição daquele dia seria desagradavelmente simples:

Ler um dado não significa possuir a verdade. Significa possuir uma observação feita em determinado momento e sob determinadas condições.

Bem-vindo ao Db2 dos Agentes.



🗄️ CAPÍTULO 1 — O BANCO DE DADOS NÃO É UM ARMÁRIO

Para quem está começando em COBOL, é tentador imaginar banco de dados como um enorme armário.

Existe uma gaveta:

CUSTOMER

Dentro dela:

CUSTOMER_ID
NAME
BALANCE
STATUS
CREDIT_LIMIT

O programa pergunta:

SELECT BALANCE
FROM CUSTOMER
WHERE CUSTOMER_ID = 12345;

Db2 responde:

10000.00

Pronto.

Verdade encontrada.

Só que não.

Em um sistema corporativo real, enquanto você lê 10000.00, outras coisas podem estar acontecendo.

Um caixa eletrônico pode sacar dinheiro.

Uma API pode registrar pagamento.

Um programa COBOL pode alterar o limite.

Outro agente pode atualizar o cadastro.

Um batch pode consolidar movimentos.

Uma transação CICS pode estar executando naquele exato instante.

O banco de dados não é uma fotografia imóvel.

É uma cidade viva.



🧠 CAPÍTULO 2 — LER NÃO É COMPREENDER

Imagine que nosso agente recebe:

CUSTOMER_ID = 12345
BALANCE     = 10000

E conclui:

Cliente possui recursos suficientes para uma compra de R$ 8.000.

Matematicamente:

10000 >= 8000

Correto.

Mas talvez exista:

PENDING_PAYMENT = 5000

ou:

AVAILABLE_BALANCE = 3000

ou uma regra dizendo:

ACCOUNT_STATUS = BLOCKED

O dado isolado estava correto.

A interpretação estava incompleta.

Esse problema é enorme para agentes.

LLMs são extraordinariamente bons em transformar informações em linguagem e relações.

Mas não devemos confundir:

DADO

com:

SIGNIFICADO DO DADO.

Um agente corporativo precisa conhecer:

  • semântica;

  • origem;

  • unidade;

  • validade;

  • relacionamento;

  • regras de negócio;

  • temporalidade.

BALANCE = 10000 sem contexto pode ser praticamente inútil.



📚 CAPÍTULO 3 — O COPYBOOK JÁ TENTAVA NOS AVISAR

Programadores COBOL convivem com isso há décadas.

Veja:

01  WS-CUSTOMER.
    05 WS-CUSTOMER-ID       PIC 9(09).
    05 WS-BALANCE           PIC S9(11)V99 COMP-3.
    05 WS-STATUS            PIC X.

O layout explica a representação.

Mas ainda não explica completamente o significado.

O que significa:

WS-STATUS = 'B'

?

Blocked?

Bankrupt?

Business?

Batman?

😂

Sem documentação, regra de negócio ou conhecimento do sistema, temos apenas um byte.

É por isso que sistemas antigos frequentemente possuem algo valiosíssimo:

CONHECIMENTO SEMÂNTICO.

Está espalhado por:

copybooks
programas COBOL
DDL
stored procedures
documentação
regras
manuais
pessoas

Para um agente entender dados corporativos, não basta entregar tabelas.

Precisamos entregar contexto.



⏰ CAPÍTULO 4 — O DADO TEM IDADE

Turing escreve:

VALUE = 10000

Depois pergunta:

— Quando?

O programador responde:

— Como assim?

Turing acrescenta:

VALUE = 10000
READ_AT = 10:00:01

Agora temos algo muito mais interessante.

Porque:

10:00:01 → 10000
10:00:03 → withdrawal 8000
10:00:04 → 2000

O dado envelheceu em três segundos.

Chamaremos informalmente isso de:

DATA FRESHNESS.

Ou frescor do dado.

Para algumas informações:

3 segundos

é praticamente tempo real.

Para outras:

3 segundos

é perigosamente velho.

Temperatura média anual?

Sem problema.

Saldo bancário antes de autorizar pagamento?

Problema.


🕰️ CAPÍTULO 5 — TODA DECISÃO POSSUI UMA JANELA TEMPORAL

Nosso agente faz:

10:00:01 READ CUSTOMER
10:00:02 CALL LLM
10:00:04 SEARCH DOCUMENT
10:00:07 ANALYZE
10:00:09 DECIDE

Ele tomou uma decisão às:

10:00:09

baseado em informação obtida às:

10:00:01.

Temos oito segundos de diferença.

Em alguns processos isso é irrelevante.

Em outros é enorme.

Podemos imaginar:

DECISION AGE = DECISION_TIME - DATA_READ_TIME

Nesse caso:

8 segundos.

Uma arquitetura de agentes deveria perguntar:

Quanto tempo uma observação continua válida para esta decisão?

Isso é tão importante quanto o timeout discutido no CICS dos Agentes.


⚛️ CAPÍTULO 6 — ACID ENTRA NA SALA

Quando falamos de bancos transacionais, encontramos a famosa sigla:

ACID

Ela representa quatro propriedades conceituais:

A — Atomicity
C — Consistency
I — Isolation
D — Durability

Vamos traduzi-las para nosso pequeno robô.


⚛️ CAPÍTULO 7 — ATOMICIDADE: TUDO OU NADA

Imagine transferência:

Conta A: -100
Conta B: +100

Não queremos:

Conta A: -100
Conta B: ERROR

A unidade lógica precisa ser tratada de forma coerente.

Ou todas as alterações da unidade de trabalho são confirmadas, ou as alterações não confirmadas precisam ser revertidas conforme a transação e os recursos envolvidos.

Conceitualmente:

BEGIN

DEBIT A
CREDIT B

COMMIT

Se ocorrer problema:

ROLLBACK

Nosso agente precisa entender que ações relacionadas não podem ser tratadas como frases independentes de uma conversa.


🧭 CAPÍTULO 8 — CONSISTÊNCIA: NÃO QUEBRE AS REGRAS DO UNIVERSO

Consistência significa que as operações devem respeitar as regras e invariantes estabelecidas pelo sistema.

Por exemplo:

STOCK >= 0

ou:

ORDER must reference valid CUSTOMER

ou regras implementadas em aplicações, constraints, triggers e outros mecanismos.

O agente pode dizer:

Parece razoável.

Db2 responde:

Não perguntei se parece razoável.

😂

O sistema possui regras.

Inteligência probabilística não substitui integridade transacional.


🧱 CAPÍTULO 9 — ISOLAMENTO: AQUI COMEÇA A DIVERSÃO

Agora chegamos ao ponto central.

Imagine duas transações:

TX-A
TX-B

executando simultaneamente.

Queremos controlar o quanto uma transação pode perceber dos efeitos da outra enquanto ambas estão em andamento.

Isso é parte do problema de:

ISOLATION.

Sem isolamento adequado, concorrência pode produzir resultados surpreendentes.

E agentes multiplicam esse problema porque podemos ter:

10 agentes
100 agentes
1.000 agentes

tomando decisões simultaneamente.


💾 CAPÍTULO 10 — DURABILIDADE: COMMIT NÃO É PROMESSA DE BAR

Quando uma transação é confirmada com sucesso, esperamos que seu resultado persistente sobreviva conforme as garantias oferecidas pelo sistema.

Ou seja:

COMMIT

não deveria significar:

Acho que gravei.

Significa que a alteração alcançou o ponto de confirmação definido pelo sistema transacional.

Para agentes corporativos isso importa muito.

O agente precisa diferenciar:

PLANNED

de:

EXECUTED

e:

COMMITTED.

São estados diferentes.


👻 CAPÍTULO 11 — DIRTY READ: O FANTASMA QUE AINDA PODE DESAPARECER

Imagine:

TX-A:
UPDATE ACCOUNT
SET BALANCE = 2000

Mas ainda não houve commit.

Outra transação consegue observar essa alteração sob condições que permitam leitura não confirmada.

Depois A faz:

ROLLBACK.

A informação que B viu desapareceu.

B tomou decisão sobre algo que nunca se tornou estado confirmado.

É a ideia de:

DIRTY READ.

Para um agente, isso pode ser especialmente perigoso.

Ele pode gerar uma explicação brilhante baseada em uma alteração que será desfeita segundos depois.


🔁 CAPÍTULO 12 — NON-REPEATABLE READ: EU JURO QUE ERA 10.000

Agente A lê:

BALANCE = 10000

Agente B altera:

BALANCE = 2000
COMMIT

A lê novamente:

BALANCE = 2000

A mesma consulta lógica produziu valores diferentes durante a execução da atividade.

O pequeno robô olha para Turing:

— Professor, o banco mentiu para mim!

— Não.

— Mas mudou!

— Exatamente.

O mundo mudou.

Essa é uma distinção filosófica e técnica importante:

Mudança não é inconsistência.

Às vezes o sistema está funcionando perfeitamente.

A realidade simplesmente evoluiu.


👥 CAPÍTULO 13 — PHANTOM READ: APARECEU OUTRO CLIENTE

Imagine:

SELECT COUNT(*)
FROM ORDERS
WHERE STATUS = 'PENDING';

Resultado:

10

Outra transação insere novo pedido pendente.

Você executa novamente.

11

Apareceu uma nova linha que satisfaz o predicado da consulta.

O conjunto observado mudou.

É o tipo de fenômeno associado ao famoso:

PHANTOM.

Para agentes que fazem análises sobre conjuntos de dados, isso importa bastante.

O agente pode perguntar:

Quantas solicitações aguardam aprovação?

A resposta pode envelhecer antes de terminar a frase.


💥 CAPÍTULO 14 — LOST UPDATE: DOIS AGENTES ESTAVAM CERTOS

Temos:

STOCK = 10

Agent-A lê:

10

Agent-B lê:

10.

A decide vender 3.

Calcula:

10 - 3 = 7

B decide vender 4.

Calcula:

10 - 4 = 6.

A grava:

7

B grava:

6.

A atualização de A pode ser efetivamente perdida dependendo da forma como a aplicação implementa a concorrência.

O valor correto deveria refletir ambas as operações:

3.

Dois agentes.

Duas contas matematicamente corretas.

Resultado corporativo errado.

Esse é um dos melhores exemplos de por que:

INTELIGÊNCIA NÃO RESOLVE CONCORRÊNCIA.


🔒 CAPÍTULO 15 — LOCKS: RESERVANDO UM PEDAÇO DA REALIDADE

Uma abordagem tradicional para coordenar concorrência utiliza locks.

Simplificando:

AGENT-A
LOCK ROW

Agora B precisa esperar dependendo da operação, isolamento e mecanismos envolvidos.

A altera.

UPDATE
COMMIT

Lock liberado.

B continua.

Isso pode proteger consistência.

Mas lembra do CICS dos Agentes?

Locks possuem custo.

Se o agente fizer:

LOCK CUSTOMER

CALL LLM

SEARCH WEB

READ 50 PDFs

ASK HUMAN

WAIT 20 MINUTES

o DBA provavelmente surgirá atrás dele segurando um manual do Db2 como arma contundente.


☠️ CAPÍTULO 16 — NÃO PENSE SEGURANDO O LOCK

Nossa regra retorna:

NÃO DEIXE O LLM PENSAR SEGURANDO LOCKS DESNECESSÁRIOS.

Uma arquitetura possível:

READ
↓
CAPTURE VERSION
↓
RELEASE TRANSACTIONAL RESOURCES
↓
THINK
↓
REVALIDATE
↓
SHORT UPDATE TRANSACTION
↓
COMMIT

Mas agora aparece uma pergunta:

Como sabemos se o dado mudou enquanto o agente pensava?

Excelente.

Entramos no próximo monstro.


🔢 CAPÍTULO 17 — VERSIONAMENTO

Imagine tabela conceitual:

CUSTOMER
────────────────────────
ID          12345
BALANCE     10000
VERSION     17

O agente lê:

VERSION = 17.

Vai pensar.

Enquanto isso outra transação altera o registro.

Agora:

VERSION = 18.

Nosso agente retorna e tenta atualizar.

Em vez de simplesmente:

UPDATE CUSTOMER
SET CREDIT_LIMIT = 5000
WHERE CUSTOMER_ID = 12345;

podemos usar uma estratégia de concorrência otimista:

UPDATE CUSTOMER
SET CREDIT_LIMIT = 5000,
    VERSION = VERSION + 1
WHERE CUSTOMER_ID = 12345
  AND VERSION = 17;

Se:

ROWS UPDATED = 1

ótimo.

Se:

ROWS UPDATED = 0

alguma coisa mudou.

Pare.

Releia.

Reavalie.


optimistic CAPÍTULO 18 — OPTIMISTIC CONCURRENCY

O nome vem da ideia:

Provavelmente ninguém vai alterar isto enquanto estou trabalhando.

Em vez de manter um lock durante todo o raciocínio, registramos a versão observada.

Depois verificamos se ainda é a mesma.

Fluxo:

READ VERSION 17
      ↓
THINK
      ↓
CHECK VERSION
      ↓
   ┌───────┐
   │       │
  17      18
   │       │
   ▼       ▼
UPDATE   STALE
        RELOAD

Isso combina muito bem com agentes.

Por quê?

Porque raciocínio de IA pode levar tempo e envolver recursos externos.

Não queremos manter uma transação aberta durante todo esse período.


🥖 CAPÍTULO 19 — O PÃO DE QUEIJO DA CONCORRÊNCIA

Turing coloca um pão de queijo sobre a mesa.

Diz ao Agent-A:

— Quantos existem?

— Um.

Agent-A vira para consultar o LLM sobre a composição nutricional do pão de queijo.

Agent-B chega.

Come o pão de queijo.

Agent-A volta.

— Decidi com 98,7% de confiança que devo comer o pão de queijo.

Turing aponta para o prato vazio.

Agent-A:

ERROR:
RESOURCE NOT FOUND

😂

Essa é concorrência otimista explicada no café.

Você não precisa segurar o pão durante quinze minutos.

Mas antes de mordê-lo:

VERIFIQUE SE ELE AINDA EXISTE.


📸 CAPÍTULO 20 — SNAPSHOT: UMA FOTOGRAFIA DA REALIDADE

Às vezes queremos que uma operação trabalhe sobre uma visão consistente dos dados.

Conceitualmente, podemos imaginar:

SNAPSHOT @ 10:00:00

O agente analisa aquela visão.

Mesmo que o mundo continue mudando, sabemos:

Esta análise corresponde à realidade observada naquele ponto ou contexto transacional.

Isso é extremamente útil.

Mas exige honestidade.

O resultado deveria dizer algo como:

ANALYSIS-AS-OF:
2026-09-27T10:00:00

e não:

CURRENT STATE.

Se os dados eram de dez minutos atrás, não chame de “agora”.


🕰️ CAPÍTULO 21 — “AS OF” PODE SER TÃO IMPORTANTE QUANTO O VALOR

Imagine um relatório:

RISK SCORE = 72

Pergunta:

— Baseado em quê?

Resposta:

CUSTOMER DATA..... 10:00
PAYMENTS........... 09:58
CREDIT BUREAU...... 08:00
CRM................ yesterday

Agora entendemos muito melhor o resultado.

Para agentes, deveríamos considerar metadados como:

SOURCE
READ_AT
VALID_AT
VERSION
TRANSACTION_ID
RUN_ID

Isso cria:

PROVENIÊNCIA TEMPORAL.

Não basta saber de onde veio.

Precisamos saber de quando veio.


🤖 CAPÍTULO 22 — O RAG TAMBÉM POSSUI RELÓGIO

Agora chegamos a algo delicioso.

RAG:

Retrieval-Augmented Generation

Em termos simples:

PERGUNTA
↓
BUSCA INFORMAÇÃO
↓
ENTREGA CONTEXTO AO MODELO
↓
MODELO RESPONDE

Fantástico.

Mas imagine recuperar:

POLITICA-CREDITO-2024.PDF

quando existe:

POLITICA-CREDITO-2026.PDF.

O modelo pode interpretar perfeitamente o documento errado.

A resposta pode ser:

linguisticamente excelente
logicamente coerente
tecnicamente obsoleta.

Isso é assustador.


📚 CAPÍTULO 23 — EMBEDDING NÃO SABE QUE A NORMA FOI REVOGADA

Busca semântica responde:

Este documento é parecido com sua pergunta.

Ela não necessariamente responde:

Este documento continua válido hoje.

Essas são perguntas diferentes.

Um sistema RAG corporativo pode precisar considerar:

EFFECTIVE_FROM
EFFECTIVE_TO
VERSION
STATUS
SUPERSEDED_BY
SOURCE
AUTHORITY

Imagine:

DOC A
Similarity = 0.97
Status = EXPIRED

e:

DOC B
Similarity = 0.91
Status = ACTIVE.

Qual deveria ganhar?

Não necessariamente A.

A relevância semântica é apenas uma dimensão.


🧭 CAPÍTULO 24 — VERDADE TAMBÉM PRECISA DE PROVENIÊNCIA

Nosso agente afirma:

O limite do cliente é R$ 20.000.

Pergunte:

SOURCE?

Depois:

WHEN?

Depois:

VERSION?

Depois:

COMMITTED?

Depois:

AUTHORIZED SOURCE?

Uma resposta corporativa forte deveria conseguir produzir evidências.

Por exemplo:

VALUE......... 20000
SOURCE........ DB2.CUSTOMER_LIMIT
KEY........... 12345
READ_AT....... 10:42:03
VERSION....... 882
RUN-ID........ A004821

Agora temos algo auditável.


🪪 CAPÍTULO 25 — O RUN-ID ENCONTRA O DATA VERSION

No JES2 dos Agentes criamos:

RUN-ID.

Agora podemos relacionar:

RUN-ID A004821

com:

CUSTOMER VERSION 882
DOCUMENT VERSION 17
RULESET VERSION 42
MODEL VERSION X

Isso responde uma pergunta extremamente importante:

Qual realidade o agente viu quando tomou esta decisão?

Sem isso, uma auditoria futura pode encontrar dados diferentes e perguntar:

— Como a IA chegou nessa conclusão absurda?

Talvez não fosse absurda.

Talvez os dados fossem outros naquele momento.


🧪 CAPÍTULO 26 — REPRODUZIR UMA DECISÃO DE IA É MAIS DIFÍCIL

Com programa COBOL determinístico:

INPUT X
+
PROGRAM VERSION Y
=
OUTPUT Z

frequentemente temos comportamento bastante reproduzível.

Com agente:

PROMPT
MODEL
TOOLS
DATA
DOCUMENTS
TIMING
CONVERSATION
POLICY

todos podem influenciar.

Portanto registrar apenas:

PROMPT

não basta.

Podemos precisar registrar referências para:

RUN-ID
MODEL VERSION
PROMPT VERSION
TOOL VERSION
DATA VERSION
DOCUMENT VERSION
POLICY VERSION
TIMESTAMPS
RESULT

Isso é observabilidade encontrando governança de dados.

SDSF encontra Db2.


🔄 CAPÍTULO 27 — REVALIDATE BEFORE COMMIT

Aqui está uma regra poderosa.

Nosso agente:

READ
↓
THINK
↓
DECIDE

Antes de alterar algo importante:

REVALIDATE

Depois:

COMMIT.

Fluxo completo:

READ STATE V17
      ↓
ANALYZE
      ↓
PROPOSE ACTION
      ↓
CHECK CURRENT STATE
      ↓
V17?
 │
 ├─ YES → EXECUTE → COMMIT
 │
 └─ NO  → RELOAD → REASON AGAIN

Essa talvez seja uma das regras mais importantes de todo o artigo.

NÃO CONFIE CEGAMENTE NO SNAPSHOT QUE INICIOU O RACIOCÍNIO.


👤 CAPÍTULO 28 — HUMAN-IN-THE-LOOP PIORA O PROBLEMA TEMPORAL

Imagine:

10:00
Agent recommends payment

Humano recebe:

Approve?

Vai almoçar.

Volta:

13:30

Clica:

APPROVE.

O agente não deveria simplesmente continuar a operação planejada três horas e meia atrás.

Precisa:

RELOAD
REVALIDATE
REAUTHORIZE
EXECUTE

Talvez o saldo mudou.

Talvez o cliente foi bloqueado.

Talvez a regra mudou.

Talvez outro operador já resolveu.

A aprovação humana confirma intenção.

Não necessariamente confirma que o estado antigo continua válido.


🚨 CAPÍTULO 29 — STALE CONTEXT

Vamos dar nome ao monstro:

STALE CONTEXT.

O contexto ficou velho.

Exemplo:

AGENT CONTEXT
CUSTOMER_STATUS = ACTIVE
READ_AT = 10:00

Agora:

CURRENT DATABASE
CUSTOMER_STATUS = BLOCKED
UPDATED_AT = 10:03.

Às 10:05 o agente ainda carrega:

ACTIVE.

Isso não é hallucination.

Não é necessariamente erro do LLM.

É contexto obsoleto.

Essa distinção é importantíssima.


🧯 CAPÍTULO 30 — NEM TODO ERRO DE IA É ERRO DA IA

Quando um agente produz resposta incorreta, investigue:

MODEL?
PROMPT?
RETRIEVAL?
DATA?
TIMING?
TOOL?
CACHE?
VERSION?

Talvez o modelo tenha raciocinado corretamente sobre dados ruins.

Talvez os dados fossem bons, mas velhos.

Talvez a ferramenta tenha retornado cache.

Talvez a consulta tenha usado uma réplica com defasagem.

Talvez o documento recuperado estivesse revogado.

“IA errou” pode ser diagnóstico preguiçoso.

Precisamos descobrir:

EM QUAL CAMADA A REALIDADE SE DESVIOU?


🗃️ CAPÍTULO 31 — CACHE É UMA MÁQUINA DO TEMPO

Cache melhora desempenho.

No CICS dos Agentes adoramos isso.

Em vez de consultar Db2:

20 ms

podemos obter:

2 ms.

Fantástico.

Mas existe preço.

O dado pode estar:

STALE.

Imagine:

CACHE TTL = 5 minutes

Para:

COUNTRY CODE

talvez ótimo.

Para:

AVAILABLE BALANCE

talvez terrível.

Portanto:

Cache não é simplesmente performance. É uma decisão sobre quanto passado aceitamos apresentar como presente.


🎯 CAPÍTULO 32 — FRESHNESS BUDGET

No CICS tínhamos:

LATENCY BUDGET.

Agora podemos imaginar:

FRESHNESS BUDGET.

Por exemplo:

PRODUCT DESCRIPTION..... 24h
CUSTOMER ADDRESS........ 5m
ACCOUNT BALANCE......... 1s
FRAUD STATUS............ 0s / revalidate

Não são números universais.

São decisões de negócio e arquitetura.

Mas o conceito é poderoso:

Quão velho este dado pode estar antes de deixar de ser aceitável?


📊 CAPÍTULO 33 — O PAINEL DO Db2 DOS AGENTES

Imagine nosso painel operacional:

RUN-ID......... A004821
AGENT.......... CREDIT-ANALYSIS

DATA SOURCES
────────────────────────────────────────
CUSTOMER        VERSION 882    AGE 0.4s
BALANCE         VERSION 991    AGE 0.1s
CRM             VERSION 441    AGE 2m
CREDIT-RULES    VERSION 42     AGE 3d
RAG-DOC         VERSION 17     AGE 4h

DECISION AGE.................. 2.8s
STALE SOURCES................. 0
OPEN TRANSACTION.............. NO
LOCKS HELD.................... 0
REVALIDATION REQUIRED......... YES

Agora estamos falando.

O operador consegue enxergar não apenas:

O QUE O AGENTE ESTÁ FAZENDO?

mas:

QUAL REALIDADE ELE ESTÁ VENDO?

🧰 CAPÍTULO 34 — CHECKLIST PARA AGENTES QUE TOMAM DECISÕES SOBRE DADOS

Antes de colocar um agente corporativo em produção, pergunte:

1. Qual é a fonte oficial?

Db2?
API?
RAG?
cache?

2. O dado possui timestamp?

Saiba quando foi observado.

3. Existe versão?

Use versionamento quando necessário.

4. Qual é o freshness budget?

Defina tolerância.

5. O agente mantém transação aberta enquanto pensa?

Evite.

6. Existem locks?

Minimize duração.

7. Pode haver concorrência?

Presuma que sim.

8. Existe optimistic concurrency?

Considere version checking.

9. A ação precisa ser revalidada?

Para ações críticas, quase certamente.

10. O RAG conhece validade documental?

Não use apenas similaridade.

11. Existe proveniência?

Registre origem.

12. Podemos reconstruir a decisão?

Associe dados, versões e RUN-ID.

13. O humano pode demorar para aprovar?

Revalide depois da aprovação.

14. O cache é permitido?

Defina TTL de acordo com semântica.

15. O resultado informa “as of”?

Quando relevante, deveria.


🥚 EASTER EGG — O AGENTE QUE ESTAVA 100% CERTO

02:14 da madrugada.

Telefone toca.

— Produção.

O operador atende.

— Temos problema.

— Qual?

— A IA aprovou uma operação que deveria ter recusado.

Abrem o trace.

RUN-ID A008817

Modelo respondeu corretamente.

Prompt correto.

Regra correta.

RACF correto.

Nenhuma hallucination.

Turing chega carregando café.

— Mostre os dados.

CUSTOMER_STATUS = ACTIVE

— Quando foram lidos?

Silêncio.

Procuram.

CACHE READ:
01:43:02

Turing olha o relógio.

02:14.

Consulta Db2:

CUSTOMER_STATUS = BLOCKED
UPDATE TIME     = 01:44:11

O agente estava usando uma informação de 31 minutos atrás.

O jovem programador diz:

— Então a IA errou.

Turing responde:

— Não.

Aponta para o cache.

— Nós entregamos o passado e perguntamos sobre o presente.

Silêncio.

No fundo do CPD, o DBA sorri.

Finalmente não era culpa do banco.


🧬 CAPÍTULO 35 — NOSSO MAINFRAME DOS AGENTES ESTÁ FICANDO INTERESSANTE

Agora nossa arquitetura conceitual possui:

RACF
↓
QUEM PODE?
PF3
↓
POSSO PARAR?
SDSF
↓
O QUE ESTÁ FAZENDO?
MAXCC
↓
FUNCIONOU?
WLM
↓
QUEM RECEBE RECURSOS?
JES2
↓
QUEM COMEÇA E QUANDO?
CICS
↓
QUANTO TEMPO O HUMANO PODE ESPERAR?

E agora:

Db2
↓
QUAL REALIDADE O AGENTE ESTÁ VENDO?

Isso muda tudo.


🏰 CAPÍTULO 36 — O SISTEMA OPERACIONAL CONCEITUAL DOS AGENTES

Turing desenha novamente:

                     HUMANO
                        │
                        ▼
                 ┌─────────────┐
                 │   REQUEST   │
                 └──────┬──────┘
                        │
               ┌────────┴────────┐
               │                 │
               ▼                 ▼
             CICS               JES2
         responda agora      trabalhe depois
               │                 │
               └────────┬────────┘
                        ▼
                       WLM
                        │
                       RACF
                        │
                        ▼
                      AGENT
                        │
           ┌────────────┼────────────┐
           ▼            ▼            ▼
          LLM          Db2          TOOLS
                        │
                        ▼
               CURRENT REALITY?

Ao redor:

SDSF
OBSERVE

CHECKPOINT
RESUME

PF3
STOP

MAXCC
VERIFY

RUN-ID
IDENTIFY

VERSION
VALIDATE

TIMESTAMP
WHEN?

O mainframe não está apenas nos ensinando como executar agentes.

Está nos ensinando a fazê-los sobreviver à realidade corporativa.


👴 CAPÍTULO 37 — O PROGRAMADOR COBOL JÁ VIU ESSE FILME

O mundo de IA está descobrindo:

agents
tool calls
state
concurrency
context
workflow

O programador COBOL olha e pensa:

Vocês descobriram processamento corporativo.

😂

Porque ele já viveu:

CICS
Db2
JES2
MQ
RACF
WLM
COMMIT
ROLLBACK
LOCK
RESTART

Claro que agentes introduzem problemas novos.

Modelos probabilísticos.

Context windows.

Embeddings.

RAG.

Tool selection.

Autonomia.

Mas muitos monstros operacionais são antigos.

E nós já temos cicatrizes deles.


☕ EPÍLOGO — QUAL REALIDADE VOCÊ ESTÁ VENDO?

Fim da tarde.

O pequeno agente recebe:

CUSTOMER_ID = 12345

Consulta:

BALANCE = 10000
VERSION = 882
READ_AT = 17:42:01

Começa análise.

Enquanto pensa:

17:42:02
WITHDRAWAL = 8000
COMMIT
VERSION = 883

O agente termina:

17:42:04

Antigamente responderia:

Operação aprovada. O cliente possui R$ 10.000.

Mas agora aprendeu.

Antes de agir:

CHECK VERSION 882

Db2 responde:

CURRENT VERSION = 883.

O robô para.

Relê.

BALANCE = 2000.

Reavalia.

Resultado:

DECISION = DENIED
REASON   = INSUFFICIENT FUNDS

Turing sorri.

— Muito bem.

O agente pergunta:

— Minha primeira análise estava errada?

Turing responde:

— Não.

— Então por que não usei?

— Porque ela estava correta para uma realidade que não existia mais.

O programador COBOL olha para o terminal.

Na tela:

RUN-ID........ A004821

READ VERSION.. 882
CURRENT....... 883

CONTEXT....... STALE
REVALIDATION.. REQUIRED

ACTION........ REEVALUATED
STATUS........ COMMITTED

Turing termina o café.

Antes de sair, escreve no quadro:

UMA IA NÃO PRECISA APENAS SABER A RESPOSTA.

Abaixo:

PRECISA SABER DE QUANDO É A RESPOSTA.

E finalmente:

SELECT
    VALUE,
    VERSION,
    TIMESTAMP
FROM
    REALITY
WHERE
    NOW = NOW;

O programador observa.

— Professor...

— Sim?

— Essa tabela não existe.

Turing sorri.

— Ainda.

No fundo do CPD, o DBA grita:

— E NEM INVENTA DE CRIAR EM PRODUÇÃO!

O pequeno robô fecha o terminal.

COMMIT;

E todos foram tomar café.

Porque no mainframe, no Db2 e no mundo dos agentes, existe uma verdade que sobrevive a qualquer geração tecnológica:

Uma decisão só é tão confiável quanto os dados, o contexto e o instante da realidade sobre os quais ela foi construída.

READY

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🤖 Alan Turing entra no CPD

O mapa dos agentes de IA explicado por um mainframer

Esta série acompanha a evolução de uma ideia: compreender os problemas modernos dos agentes de inteligência artificial usando conceitos conhecidos por quem trabalha com mainframe, IBM Z e sistemas corporativos.

A viagem começa pelas pessoas e pela experiência de uso, passa por observabilidade, priorização e execução, chega às transações, estado e mensageria e termina na organização hierárquica do contexto.

01
FEV / 2023

🧠 O currículo invisível da inteligência artificial

Antes de construir agentes inteligentes precisamos preparar as pessoas que trabalharão com eles. Técnica, pensamento crítico, conhecimento de negócio, segurança, ética e responsabilidade formam o currículo que nem sempre aparece no certificado.

02
MAR / 2023

🤖 A UX dos agentes

Quando uma IA deixa de apenas responder e começa a executar ações, sua interface precisa mostrar objetivos, progresso, permissões e resultados. PF3, MAXCC e RACF tornam-se excelentes analogias para controle, retorno e privilégio mínimo.

04
MAI / 2023

⚖️ O WLM dos agentes

CPU, GPU, tokens, APIs e bancos de dados são recursos finitos. O Workload Manager inspira uma discussão sobre prioridades, objetivos de serviço, importância do trabalho e distribuição dinâmica de recursos entre agentes.

06
JUL / 2023

⚡ O CICS dos agentes

Uma coisa é uma IA produzir texto. Outra é permitir que ela execute operações reais de negócio. CICS introduz a conversa sobre processamento transacional, concorrência, segurança e integridade.

07
AGO / 2023

🗄️ O Db2 dos agentes

Agentes precisam manter estado, checkpoints, decisões e resultados. O Db2 fornece o ponto de partida para discutir unidade de trabalho, consistência, COMMIT, ROLLBACK e recuperação.

10
SET / 2026

☕ Alan Turing entra no CPD — O mapa completo

O artigo-âncora reúne toda a evolução da ideia: pessoas, UX, observabilidade, prioridade, orquestração, transações, estado, mensageria e contexto transformam artigos independentes em uma arquitetura conceitual para agentes de IA.

🖥️ Leitor da série

Selecione qualquer capítulo acima para abri-lo normalmente. O painel abaixo é apenas um recurso adicional de navegação.

terça-feira, 8 de fevereiro de 2022

🧪 PROFESSOR FARNSWORTH E AS QUATRO LEIS QUE IMPEDIAM O Db2 DE DESTRUIR O UNIVERSO

 

Bellacosa Mainframe apresenta o ACID

☕ Um Café no Bellacosa Mainframe

🧪 PROFESSOR FARNSWORTH E AS QUATRO LEIS QUE IMPEDIAM O Db2 DE DESTRUIR O UNIVERSO

ACID, COBOL, Db2 for z/OS, COMMIT, ROLLBACK, Unit of Work, locks, IRLM, isolation levels, buffer pools, logging, recovery, CICS, deadlocks, restart — e o dia em que o Professor Farnsworth descobriu que “Good news, everyone!” não era uma estratégia válida de recuperação de banco de dados.

Sob a tutela do Professor Hubert J. Farnsworth, da Planet Express.



🎬 PRÓLOGO — BOAS NOTÍCIAS, PESSOAL!

Eram exatamente 03:17 da manhã quando o telefone tocou.

Nenhum programador COBOL experiente gosta de um telefone tocando às 03:17.

Às 08:00, telefone significa reunião.

Às 14:00, provavelmente alguém esqueceu uma vírgula no JCL.

Às 17:30, significa mudança emergencial que alguém garante ter sido "exaustivamente testada".

Mas às 03:17?

Às 03:17 significa produção.

O jovem programador levantou da cama, abriu o notebook e encontrou uma mensagem assustadora:

URGENTE

TRANSFERÊNCIA FINANCEIRA INCONSISTENTE

CONTA A = DEBITADA
CONTA B = NÃO CREDITADA

— Professor! Temos um problema!

Do fundo do laboratório surgiu uma figura de jaleco, chinelos e óculos grossos.

Professor Hubert J. Farnsworth levantou um dedo.

— Good news, everyone!

— Professor, desapareceram mil reais.

— Então talvez as notícias não sejam tão boas.

Na tela havia algo parecido com isto:

EXEC SQL
   UPDATE CONTA
      SET SALDO = SALDO - 1000
    WHERE CONTA_ID = 100
END-EXEC.

EXEC SQL
   UPDATE CONTA
      SET SALDO = SALDO + 1000
    WHERE CONTA_ID = 200
END-EXEC.

EXEC SQL
   COMMIT
END-EXEC.

O jovem programador olhou para o código.

— Parece simples.

Farnsworth sorriu.

Esse era precisamente o problema.

Porque atrás daquele pequeno COMMIT existia um universo inteiro chamado:

ACID.



🧪 CAPÍTULO 1 — AS QUATRO LEIS DO UNIVERSO TRANSACIONAL

Quem começa a estudar banco de dados encontra rapidamente a famosa sigla:

A — Atomicity
C — Consistency
I — Isolation
D — Durability

Em português:

Atomicidade
Consistência
Isolamento
Durabilidade

O resumo de bolso é:

Atomicidade  → tudo ou nada
Consistência → dados continuam válidos
Isolamento   → controlar concorrência
Durabilidade → confirmou, deve permanecer

Está correto.

Mas para quem trabalha com Db2 for z/OS, isso é apenas a porta do laboratório.

Atrás dela encontramos:

COBOL
   │
   ▼
CICS / Batch
   │
   ▼
Db2
   │
   ├── Unit of Work
   ├── COMMIT / ROLLBACK
   ├── Locks
   ├── IRLM
   ├── Isolation Levels
   ├── Buffer Pools
   ├── Logging
   ├── Checkpoints
   ├── Recovery
   └── Restart

ACID não é simplesmente uma propriedade acadêmica do banco.

É uma resposta para uma pergunta muito mais séria:

Como manter os dados confiáveis quando programas falham, máquinas param, transações concorrem e seres humanos fazem coisas que o Professor Farnsworth jamais colocaria em uma especificação?

Vamos entrar no laboratório.



⚛️ CAPÍTULO 2 — A DE ATOMICITY: NÃO EXISTE MEIA TRANSFERÊNCIA

Imagine duas contas:

CONTA A = R$ 5.000
CONTA B = R$ 3.000

Precisamos transferir:

R$ 1.000

O resultado correto é:

CONTA A = R$ 4.000
CONTA B = R$ 4.000

O programa executa:

1. debita A
2. credita B
3. registra movimento
4. COMMIT

Mas o universo não é obrigado a colaborar.

Pode acontecer:

1. debita A ............ OK
2. credita B ........... OK
3. registra movimento .. ABEND

Sem atomicidade, poderíamos terminar com um estado parcialmente processado.

E isso é exatamente o que não queremos.

Farnsworth desenharia no quadro:

          UNIT OF WORK
┌───────────────────────────────┐
│ UPDATE CONTA A               │
│ UPDATE CONTA B               │
│ INSERT MOVIMENTO             │
│                              │
│ COMMIT                       │
└───────────────────────────────┘

Essa caixa representa uma Unit of Work, ou UOW.

Ela é muito mais importante do que pensar individualmente em cada SQL.

O iniciante olha para:

UPDATE CONTA ...

O engenheiro começa a perguntar:

A qual unidade lógica de negócio esse UPDATE pertence?

Essa mudança mental é enorme.



💥 CAPÍTULO 3 — O ABEND NO MEIO DA EXPERIÊNCIA

Agora Farnsworth puxa uma enorme alavanca vermelha.

O jovem programador grita:

— Professor, o que essa alavanca faz?

CLICK.

As luzes apagam.

— Descobriremos!

Imagine que o Db2 estivesse processando:

BEGIN UOW

UPDATE A
     │
     ▼
A = 4000

UPDATE B
     │
     ▼

💥 FALHA

A transação ainda não chegou ao seu ponto de confirmação.

O banco precisa conseguir impedir que o trabalho incompleto se transforme permanentemente no novo estado lógico.

É aí que entram mecanismos como:

ROLLBACK
BACKOUT
LOGGING
RECOVERY

A ideia de atomicidade pode ser resumida assim:

             TRANSAÇÃO

                  │
          ┌───────┴───────┐
          ▼               ▼
       SUCESSO           FALHA
          │               │
          ▼               ▼
       COMMIT        ROLLBACK/BACKOUT
          │               │
          ▼               ▼
     CONFIRMADA       DESFEITA

O importante é que o banco não termine no meio do caminho lógico.



🛑 CAPÍTULO 4 — COMMIT NÃO SIGNIFICA APENAS "SALVAR"

Essa é uma das primeiras armadilhas para o programador COBOL iniciante.

Muitos aprendem:

COMMIT   = salvar
ROLLBACK = desfazer

Não está totalmente errado.

Mas é uma simplificação perigosa.

Pense no COMMIT como:

a declaração de que uma Unit of Work alcançou seu ponto de confirmação.

Portanto:

EXEC SQL
   COMMIT
END-EXEC.

não deveria ser colocado aleatoriamente no programa.

O lugar do COMMIT define fronteiras transacionais.

Imagine um batch processando dez milhões de registros.

Você poderia fazer:

registro 1
registro 2
registro 3
...
registro 10.000.000

COMMIT

Farnsworth olharia para isso e provavelmente diria:

— Excelente! Agora só precisamos esperar alguma coisa falhar no registro 9.999.999.

Uma UOW gigantesca pode trazer consequências para logging, recursos, locking, rollback, concorrência e restart.

Por isso aplicações batch frequentemente utilizam commits periódicos:

processa 1.000
COMMIT

processa 1.000
COMMIT

processa 1.000
COMMIT

Mas atenção.

Não existe um número mágico:

COMMIT A CADA 1000

que seja correto para todas as aplicações.

O intervalo depende de coisas como volume, duração, concorrência, requisitos do negócio, custo de restart e características do workload.


🔄 CAPÍTULO 5 — DEPOIS DO COMMIT NÃO EXISTE BORRACHA MÁGICA

Suponha:

Registros 1–1000
COMMIT

1001–2000
COMMIT

2001–3000
COMMIT

3001–3782
💥 ABEND

Um ROLLBACK não vai magicamente voltar ao registro 1.

As UOWs anteriores já foram confirmadas.

O programa precisa saber:

último COMMIT válido = registro 3000

E isso nos leva a um conceito importantíssimo em batch:

Restartability.

Uma aplicação bem projetada pode guardar um checkpoint lógico próprio, chave de último registro processado ou outra informação de controle adequada ao desenho.

No restart:

JOB reiniciado
      │
      ▼
consulta controle
      │
      ▼
último ponto = 3000
      │
      ▼
continua de forma segura

E surge uma nova pergunta:

Se eu executar novamente uma operação, ela produzirá o mesmo resultado ou duplicará dinheiro?

Bem-vindo ao mundo da idempotência.

ACID não resolve sozinho todos os problemas de restart da aplicação.


🧱 CAPÍTULO 6 — C DE CONSISTENCY: O Db2 NÃO CONHECE O REGULAMENTO DO PLANETA EXPRESS

Consistência significa que uma transação deve levar o banco de um estado válido para outro estado válido, respeitando as regras relevantes.

O Db2 conhece muitas regras estruturais porque nós as declaramos.

Por exemplo:

CREATE TABLE CONTA
(
    CONTA_ID INTEGER NOT NULL,
    CLIENTE_ID INTEGER NOT NULL,
    SALDO DECIMAL(15,2) NOT NULL,

    PRIMARY KEY (CONTA_ID)
);

Podemos utilizar mecanismos como:

PRIMARY KEY
FOREIGN KEY
UNIQUE
CHECK
NOT NULL

Eles ajudam a preservar integridade.

Por exemplo, uma FOREIGN KEY pode estabelecer uma relação entre conta e cliente.

Mas Farnsworth faz uma pergunta:

— O Db2 sabe que clientes marcianos recebem 15% de desconto às terças-feiras?

Não.

A menos que essa regra esteja adequadamente representada na solução, o banco não a inventará.

Temos então três mundos:

       CONSISTÊNCIA

      /      |       \
     /       |        \
    ▼        ▼         ▼

DATABASE   APLICAÇÃO   NEGÓCIO

Um valor pode ser perfeitamente válido para um DECIMAL(15,2) e completamente absurdo para a empresa.

Por exemplo:

SALDO = -999999999.99

O datatype pode aceitar.

A regra empresarial talvez não.

Portanto:

Consistência ACID não significa que o Db2 entende automaticamente todas as regras da empresa.

Essa é uma diferença pequena na frase e gigantesca na arquitetura.


👥 CAPÍTULO 7 — I DE ISOLATION: FRY E BENDER SACAM O MESMO DINHEIRO

Agora temos:

SALDO = R$ 1.000

Fry tenta sacar:

R$ 800

Bender, exatamente ao mesmo tempo, tenta sacar:

R$ 800

Imagine ingenuamente:

FRY                       BENDER

SELECT SALDO              SELECT SALDO
     │                         │
     ▼                         ▼
   1000                      1000

"Tem dinheiro!"            "Tem dinheiro!"

Agora os dois tentam continuar.

Concorrência é um dos grandes problemas que bancos de dados transacionais precisam controlar.

É aqui que Isolation começa a conversar com:

locks
IRLM
UR
CS
RS
RR
deadlocks
timeouts

🔐 CAPÍTULO 8 — IRLM: O PORTEIRO DO LABORATÓRIO

No ecossistema Db2 for z/OS aparece um personagem importantíssimo:

IRLM — Internal Resource Lock Manager.

Uma representação conceitual:

PROGRAMA A
    │
    ▼
   Db2
    │
    ▼
   IRLM
    ▲
    │
PROGRAMA B

Suponha que A esteja alterando determinado recurso e possua um lock incompatível com aquilo que B deseja fazer.

B pode precisar esperar.

A:

UPDATE CONTA 100
      │
      ▼
    LOCK
      │
      │
      │     B:
      │
      │     UPDATE CONTA 100
      │            │
      │            ▼
      │           WAIT
      │
   COMMIT
      │
      ▼
 liberação conforme
 regras aplicáveis

O usuário pode reclamar:

"O sistema está esperando!"

Mas aquela espera pode ser justamente parte do mecanismo que evita resultados transacionais incorretos.

Performance e consistência frequentemente precisam conversar.


👻 CAPÍTULO 9 — O FANTASMA DO DIRTY READ

Farnsworth altera um saldo:

T1:

1000 → 100

Mas ainda não fez COMMIT.

Outra transação lê aquele valor.

Depois T1 executa:

ROLLBACK

O saldo retorna a 1000.

A segunda transação acabou de enxergar um valor que nunca se tornou um estado confirmado.

Esse fenômeno é associado a:

Dirty Read.

Conceitualmente:

T1                T2

UPDATE 100
   │
   │
   ├──────────► lê 100
   │
ROLLBACK
   │
   ▼
volta 1000

T2 tomou conhecimento de um estado intermediário que foi posteriormente abandonado.

E agora precisamos falar dos níveis de isolamento.


🧬 CAPÍTULO 10 — UR, CS, RS E RR

No Db2 for z/OS, quatro nomes aparecem frequentemente:

UR — Uncommitted Read
CS — Cursor Stability
RS — Read Stability
RR — Repeatable Read

O erro do iniciante é imaginar:

UR = ruim
RR = excelente

Não.

São escolhas com comportamentos e custos diferentes.

Uma maneira didática de pensar é:

            maior proteção
                  ▲
                  │
                 RR
                  │
                 RS
                  │
                 CS
                  │
                 UR
                  │
                  ▼
       maior liberdade de leitura

Mas não transforme isso numa simples régua de qualidade.

A pergunta correta é:

Qual garantia de isolamento esta transação realmente precisa?

Um relatório estatístico pode aceitar comportamento que seria inadmissível em uma autorização financeira.

Mais isolamento também pode significar impactos na concorrência e no locking.

Engenharia é escolher conscientemente.


👻 CAPÍTULO 11 — NON-REPEATABLE READ

Fry executa:

SELECT SALDO
FROM CONTA
WHERE CONTA_ID = 10;

Obtém:

1000

Outra transação altera a mesma linha e confirma:

1000 → 1500

COMMIT

Fry lê novamente e, dependendo das garantias aplicáveis, pode encontrar:

1500

Temos conceitualmente:

primeira leitura = 1000

segunda leitura  = 1500

A mesma linha não repetiu o valor observado anteriormente.

Daí o nome:

non-repeatable read.


👻 CAPÍTULO 12 — PHANTOM READ: AGORA APARECEU OUTRO BENDER

Considere:

SELECT COUNT(*)
FROM PEDIDO
WHERE STATUS = 'PENDENTE';

Resultado:

100

Outra transação executa:

INSERT INTO PEDIDO ...

criando outro pedido PENDENTE, e confirma.

Uma nova execução da consulta pode encontrar:

101

A diferença para o exemplo anterior é fascinante.

Não necessariamente alteraram uma das linhas que você já tinha visto.

O conjunto de linhas que satisfaz o predicado mudou.

Temos então três fenômenos fáceis de diferenciar:

DIRTY READ
→ observei dado não confirmado.

NON-REPEATABLE READ
→ uma linha observada mudou.

PHANTOM
→ o conjunto correspondente ao predicado mudou.

Farnsworth chamaria o último de:

— Fantasmas quânticos relacionais!

Não use esse termo numa prova de certificação.


💀 CAPÍTULO 13 — DEADLOCK: FRY ESPERA BENDER, BENDER ESPERA FRY

Imagine:

TRANSAÇÃO A                TRANSAÇÃO B

LOCK RECURSO X             LOCK RECURSO Y
      │                          │
      ▼                          ▼

quer Y                      quer X
      │                          │
      ▼                          ▼

WAIT                         WAIT

Temos um ciclo:

A espera B
▲         │
│         ▼
└──────── B

Isso é deadlock.

O sistema precisa romper a situação e uma das unidades de trabalho envolvidas acaba sendo tratada como vítima.

Para o programador COBOL surge uma lição essencial:

IF SQLCODE NOT = ZERO
    DISPLAY 'ERRO'
END-IF

não representa tratamento transacional adequado.

É necessário compreender o SQLCODE/SQLSTATE e decidir o comportamento correto da aplicação.


⏱️ CAPÍTULO 14 — TIMEOUT NÃO É DEADLOCK

Farnsworth deixa Bender segurando a chave do laboratório.

Fry espera.

E espera.

E espera.

Não existe necessariamente um ciclo.

Existe um recurso indisponível durante tempo suficiente para que o limite aplicável seja atingido.

Conceitualmente:

DEADLOCK:

A → B
↑   │
└───┘


TIMEOUT:

A possui recurso

B → WAIT → WAIT → WAIT → limite

Para o usuário:

"Travou."

Para quem investiga produção:

Precisamos saber exatamente por quê.

Essa é a diferença entre observar sintoma e diagnosticar sistema.


💾 CAPÍTULO 15 — D DE DURABILITY: O SEGREDO DO COMMIT

Agora Farnsworth aperta novamente o botão vermelho.

— Professor, não!

Tarde demais.

💥

O Db2 caiu logo depois de uma transação ter sido confirmada.

A pergunta é:

Os dados confirmados desapareceram?

A durabilidade existe justamente para estabelecer a expectativa de que uma transação efetivamente comprometida sobreviva a falhas dentro das garantias do sistema.

Mas aqui encontramos uma curiosidade fantástica.

Muitos iniciantes imaginam:

UPDATE
   │
   ▼
grava imediatamente a página no DASD
   │
   ▼
COMMIT

Essa visão é simples demais.

Db2 utiliza buffer pools.


🏊 CAPÍTULO 16 — BUFFER POOL: A PISCINA DO PROFESSOR

Imagine uma página trazida para memória:

       DASD
         │
         ▼
    BUFFER POOL
   ┌────────────┐
   │ DATA PAGE  │
   └────────────┘

Ela é alterada:

    BUFFER POOL
   ┌────────────┐
   │ MODIFIED   │
   │   PAGE     │
   └────────────┘

Essa página modificada precisa, em algum momento apropriado, chegar ao armazenamento persistente.

Mas seria terrivelmente caro exigir ingenuamente uma escrita física completa da página de dados a cada simples UPDATE.

Então surge outro personagem fundamental:

O Db2 Log.


📜 CAPÍTULO 17 — O DIÁRIO SECRETO DO Db2

O Db2 mantém informações de log essenciais para recovery.

Mentalmente:

             SQL UPDATE
                 │
        ┌────────┴────────┐
        ▼                 ▼
   BUFFER POOL          LOG
        │                 │
        ▼                 ▼
   DATA PAGES         RECOVERY

É por isso que uma ideia crucial é:

COMMIT não deve ser entendido como "todas as páginas modificadas foram necessariamente gravadas fisicamente no tablespace naquele mesmo instante".

O sistema possui mecanismos de logging e recuperação justamente para separar adequadamente esses eventos sem abandonar durabilidade.

Esse ponto muda completamente a compreensão do COMMIT.


✍️ CAPÍTULO 18 — WRITE-AHEAD LOGGING

Entra em cena o princípio de Write-Ahead Logging, WAL.

De forma didática, as informações de log necessárias à recuperação precisam obedecer à ordenação apropriada em relação às páginas de dados modificadas.

Farnsworth explicaria:

Antes de mandar Bender alterar o universo, anote no diário o suficiente para descobrir depois o que ele fez.

Suponha o log conceitual:

T001 UPDATE A
T001 UPDATE B
T001 COMMIT

T002 UPDATE C
T002 UPDATE D

💥 CRASH

Temos duas situações.

T001 foi confirmada.

T002 não chegou ao commit.

Durante recovery, o sistema possui informações para preservar/reaplicar o que deve sobreviver e desfazer/backout do que não deveria permanecer, conforme necessário.

Didaticamente:

T001 → REDO se necessário

T002 → UNDO/BACKOUT conforme necessário

E aqui acontece algo maravilhoso.


♻️ CAPÍTULO 19 — ATOMICITY E DURABILITY SE ENCONTRAM NO LOG

Veja:

                    LOG
                  /     \
                 /       \
                ▼         ▼
              UNDO       REDO
                │         │
                ▼         ▼
          ATOMICITY   DURABILITY

Atomicidade diz:

Trabalho incompleto não pode permanecer como se estivesse confirmado.

Durabilidade diz:

Trabalho confirmado não deve desaparecer simplesmente porque houve uma falha.

O log ajuda o Db2 a navegar entre esses dois mundos.

ACID deixa de parecer quatro palavras independentes.

É uma engrenagem.


🗄️ CAPÍTULO 20 — ACTIVE LOG, ARCHIVE LOG E A MÁQUINA DO TEMPO

No Db2 for z/OS encontramos active logs e archive logs dentro da arquitetura de logging.

Uma representação simplificada:

TRANSAÇÕES
     │
     ▼
 ACTIVE LOG
     │
     │ offload
     ▼
ARCHIVE LOG

Ao avançarmos em Db2 recovery aparecem ainda termos importantíssimos:

BSDS
RBA / LRSN
checkpoints
image copies
RECOVER
restart
active logs
archive logs

Perceba como uma simples aula sobre ACID acaba levando diretamente para Backup & Recovery de Db2 for z/OS.

É por isso que conhecimento mainframe funciona como uma catedral.

Você abre uma porta e encontra outras vinte.


🚦 CAPÍTULO 21 — COMMIT, CHECKPOINT E IMAGE COPY NÃO SÃO A MESMA COISA

Guarde isto:

COMMIT ≠ CHECKPOINT ≠ IMAGE COPY

O COMMIT está relacionado à confirmação da Unit of Work.

O checkpoint do Db2 participa de mecanismos internos importantes para restart/recovery e gerenciamento do sistema.

Uma image copy é utilizada dentro da estratégia de backup/recovery dos objetos Db2.

Três ferramentas do universo da confiabilidade.

Três finalidades diferentes.

Misturá-las é como confundir:

SAVE
BACKUP
TRANSACTION

só porque todas parecem envolver a ideia de "não perder alguma coisa".


🚀 CAPÍTULO 22 — PROFESSOR, TEM CICS NESSA EXPERIÊNCIA?

Tem.

E agora Farnsworth realmente fica animado.

Imagine:

ATM / MOBILE / API
        │
        ▼
       CICS
        │
        ▼
      COBOL
        │
   ┌────┼────┐
   ▼    ▼    ▼
  Db2   MQ   VSAM

Uma única operação de negócio pode envolver vários recursos.

Suponha:

1. atualizar Db2
2. atualizar outro recurso transacional
3. produzir uma mensagem

A pergunta já não é apenas:

O Db2 confirmou?

Passa a ser:

A unidade lógica completa foi coordenada corretamente entre os resource managers participantes?

Aqui aparecem conceitos como:

SYNCPOINT
resource managers
transaction coordination
two-phase commit

E percebemos por que o mundo transacional mainframe é muito maior que EXEC SQL.


🤝 CAPÍTULO 23 — TWO-PHASE COMMIT, OU "TODO MUNDO PRONTO?"

Didaticamente, pense num coordenador perguntando:

              COORDENADOR
                   │
          ┌────────┴────────┐
          ▼                 ▼
         Db2                MQ

       pronto?            pronto?
          │                 │
         YES               YES
          │                 │
          └────────┬────────┘
                   ▼
                 COMMIT

Se a operação não puder prosseguir adequadamente, entra o caminho de rollback/recovery previsto pelo protocolo e pelos participantes.

A realidade é mais sofisticada que esse desenho, mas ele mostra uma coisa essencial:

Atomicidade dentro de um banco já é interessante. Atomicidade envolvendo múltiplos resource managers é outro nível de engenharia.


📦 CAPÍTULO 24 — ACID NÃO IMPEDE PAGAMENTO DUPLICADO POR MÁGICA

Farnsworth envia a mensagem:

PAGAMENTO 98472

A rede apresenta problema.

A aplicação tenta novamente:

PAGAMENTO 98472

Temos duas mensagens.

Cada processamento individual pode ser perfeitamente ACID.

Ainda assim, se a aplicação não identificar a duplicidade, poderemos processar o mesmo evento duas vezes.

Talvez o desenho utilize algo equivalente a:

TRANSACTION_ID UNIQUE

ou outra estratégia de idempotência.

Portanto:

ACID
   ≠
IDEMPOTÊNCIA

ACID também não substitui:

tratamento de retries
deduplicação
regras de negócio
recovery da aplicação
restartability

Essa distinção tornou-se ainda mais importante quando o mainframe começou a conversar intensamente com:

APIs
MQ
eventos
cloud
microservices
Kafka

💳 CAPÍTULO 25 — O TESTE FINAL: DUAS COMPRAS, UM LIMITE

Chegamos à experiência final do laboratório.

Limite disponível:

R$ 1.000

Compra de Fry:

R$ 700

Compra de Bender:

R$ 600

As duas chegam praticamente juntas:

                 R$1000
                    │
             ┌──────┴──────┐
             ▼             ▼
          R$700           R$600

Agora ACID inteiro entra em ação.

Atomicity

Se a autorização depende de registrar movimento e atualizar o limite, precisamos da unidade transacional correta.

Não queremos:

limite reduzido
+
autorização inexistente

Consistency

Constraints, relacionamentos e regras implementadas precisam permanecer válidos.

Isolation

As duas compras não podem simplesmente tomar decisões independentes baseadas numa visão concorrente inadequada dos mesmos R$ 1.000.

Aqui entram isolamento, locking e concorrência.

Durability

Depois que a autorização foi efetivamente confirmada, uma falha posterior não deve simplesmente apagá-la da história.

Agora ACID não é mais uma pergunta de entrevista.

É dinheiro.


🧰 CAPÍTULO 26 — CHECKLIST DO PADAWAN COBOL

Sempre que encontrar:

EXEC SQL
   COMMIT
END-EXEC.

não passe correndo.

Pare e investigue:

  1. Qual Unit of Work termina aqui?

  2. Quais alterações pertencem à mesma operação de negócio?

  3. O que acontece se houver ABEND antes deste ponto?

  4. E imediatamente depois?

  5. Como funciona o restart?

  6. Existe risco de reprocessamento?

  7. A operação é idempotente?

  8. Quais outras transações concorrem pelos mesmos dados?

  9. Qual isolamento é necessário?

  10. Há CICS, MQ ou outros resource managers envolvidos?

  11. O programa trata deadlock e timeout adequadamente?

  12. As constraints representam todas as regras importantes ou parte delas vive no COBOL?

Essas doze perguntas valem mais do que decorar ACID para uma prova.


🗺️ CAPÍTULO 27 — O MAPA DO LABORATÓRIO FARNSWORTH

No final da aula, o Professor desenhou tudo no quadro:

                       A C I D
                          │
       ┌──────────────────┼──────────────────┐
       │                  │                  │
       ▼                  ▼                  ▼
  ATOMICITY          CONSISTENCY         ISOLATION
       │                  │                  │
       ▼                  ▼                  ▼
     UOW              Constraints          IRLM
   COMMIT              PK / FK             Locks
  ROLLBACK             UNIQUE            UR/CS/RS/RR
  BACKOUT              CHECK                │
       │               Business        ┌────┴────┐
       │                Rules          ▼         ▼
       │                           Deadlock   Timeout
       │
       └──────────────┐
                      ▼
                    LOG
                 ┌────┴────┐
                 ▼         ▼
               UNDO       REDO
                 │         │
                 ▼         ▼
            Atomicity  Durability
                           │
                ┌──────────┼───────────┐
                ▼          ▼           ▼
           Active Log  Archive Log  Recovery
                                       │
                                       ▼
                                     Restart

E acima disso:

                   USUÁRIO
                      │
                      ▼
                 CICS / BATCH
                      │
                      ▼
                    COBOL
                      │
                      ▼
                     Db2
          ┌───────────┼───────────┐
          ▼           ▼           ▼
     BUFFER POOL     IRLM         LOG
          │           │           │
          ▼           ▼           ▼
        DATA        LOCKING    RECOVERY
          │           │           │
          └───────────┼───────────┘
                      ▼
                     ACID

🧪 EPÍLOGO — GOOD NEWS, EVERYONE!

O jovem programador olhou novamente para o programa.

Naquela manhã, o código parecia simples:

EXEC SQL
   COMMIT
END-EXEC.

Agora ele enxergava outra coisa.

Via uma Unit of Work.

Via alterações ainda não confirmadas.

Via locks sendo administrados.

Via transações concorrentes.

Via IRLM.

Via páginas no buffer pool.

Via logging.

Via trabalho confirmado e não confirmado.

Via possibilidades de REDO e UNDO.

Via restart.

Via CICS coordenando recursos.

Via o batch que precisava saber de onde continuar.

Via o pagamento duplicado que ACID sozinho não impediria.

Via o deadlock escondido entre duas transações perfeitamente corretas quando observadas isoladamente.

Finalmente percebeu uma coisa que todo programador COBOL que trabalha seriamente com Db2 acaba descobrindo:

O SQL que você escreve é apenas a parte visível da transação.

Farnsworth colocou a mão sobre a enorme alavanca vermelha.

— Professor...

— Sim?

— Não toque nisso.

O velho cientista sorriu.

— Good news, everyone! Eu instalei um COMMIT!

— Professor, COMMIT não é backup.

Silêncio.

— Muito bem, jovem.

Farnsworth afastou lentamente a mão da alavanca.

E essa talvez seja a melhor definição do salto entre aprender SQL e começar a compreender Db2 for z/OS.

No começo aprendemos:

SELECT
INSERT
UPDATE
DELETE

Depois aprendemos:

COMMIT
ROLLBACK

Mas o verdadeiro salto acontece quando olhamos para um UPDATE e imediatamente pensamos:

Quem mais está acessando isto?

Qual é minha UOW?

Que lock posso provocar?

Qual isolamento preciso?

O que acontece se eu falhar agora?

O que já está confirmado?

Como faço restart?

Posso executar novamente?

Existe outro resource manager?

Como o Db2 recuperará isso?

Nesse momento você deixa de enxergar Db2 apenas como um lugar onde o COBOL guarda registros.

Você começa a enxergá-lo como uma máquina transacional construída para administrar simultaneamente mudança, concorrência e falha.

E essa é a grande sacada escondida nas quatro letras:

A C I D

ATOMICITY
   │
   └── Não deixe metade da história acontecer.

CONSISTENCY
   │
   └── Não transforme um estado válido em absurdo.

ISOLATION
   │
   └── Não deixe milhares de histórias simultâneas
       destruírem umas às outras.

DURABILITY
   │
   └── Depois de confirmar a história,
       não deixe uma falha apagá-la.

É por isso que bancos, cartões, seguradoras, companhias aéreas, varejistas e tantas outras empresas podem executar volumes enormes de transações sem depender da esperança de que "nada dê errado".

Porque coisas dão errado.

Programas sofrem ABEND.

Jobs são reiniciados.

Transações entram em deadlock.

Recursos ficam indisponíveis.

Sistemas precisam de recovery.

Mensagens podem ser reenviadas.

Aplicações concorrem.

Máquinas podem parar.

E às vezes alguém liga às 03:17 da manhã.

A genialidade não está em construir um universo onde falhas sejam impossíveis.

Está em construir um sistema que saiba o que fazer quando elas inevitavelmente acontecerem.

Farnsworth apagou as luzes do laboratório.

Na tela permaneceu apenas uma mensagem:

DSNE610I NUMBER OF ROWS DISPLAYED IS 1

E, ao lado dela, uma pequena anotação:

*> GOOD NEWS, EVERYONE.
*> SQLCODE = 0.

☕ Bem-vindo ao Db2 no mainframe, Padawan. Aqui até o caos precisa respeitar a Unit of Work.

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