☕ 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 diagnóstico. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta diagnóstico. Mostrar todas as mensagens

quarta-feira, 11 de fevereiro de 2026

🔥 SEU PROGRAMA NÃO MORRE… ELE DEIXA PISTAS 💀

 

Bellacosa Mainframe analisando o RTM

🔥 SEU PROGRAMA NÃO MORRE… ELE DEIXA PISTAS 💀

O guia proibido do RTM que revela como o z/OS investiga, sobrevive e aprende com cada falha

Você vê um ABEND e pensa:

👉 “deu erro…”

O z/OS pensa diferente:

💥 “vamos registrar, analisar, aprender e continuar rodando.”

Esse é o papel do Recovery Termination Manager (RTM) — o sistema que transforma falhas em evidência técnica.

Se você quer sair do nível “rodou ou não rodou” e entrar no nível engenharia de diagnóstico, esse é o mapa definitivo 👊🔥


🧠 1. A FILOSOFIA DO z/OS SOBRE ERROS

No mundo distribuído:

👉 erro = problema

No mainframe:

👉 erro = evento analisável


💡 Tradução Bellacosa

“falhar é permitido… repetir o erro não.”


⚙️ 2. RTM — O “INVESTIGADOR OFICIAL”

O RTM entra em ação quando:

  • ocorre erro (ABEND)
  • há falha de hardware
  • há erro de sistema
  • ou até quando tudo termina normalmente

🔥 Funções principais

  • capturar erro
  • chamar rotinas de recuperação
  • gerar dumps
  • registrar LOGREC
  • limpar recursos

💡 Insight

RTM atua até quando o programa termina certo


🧩 3. RTM1 vs RTM2 — DOIS NÍVEIS DE SOBREVIVÊNCIA

🔹 RTM1 (System)

  • protege o sistema
  • chama FRR

🔹 RTM2 (Task)

  • trata a task
  • chama ESTAE

🔥 Fluxo real

Erro → RTM1 → RTM2 → Recovery → Dump → Cleanup

💡 Tradução

“primeiro o sistema sobrevive… depois a task”


🛡️ 4. ESTAE — A AUTODEFESA DO PROGRAMA

Programas podem registrar:

👉 rotinas de recuperação


🔥 Como funciona

  • programa define ESTAE
  • erro ocorre
  • RTM chama essa rotina

💡 Tradução Bellacosa

“seu programa pode tentar se salvar antes do fim”


🧠 Exemplo real

COBOL acessa memória inválida
↓
ESTAE intercepta
↓
log + tratamento

💀 5. DUMPS — A CENA DO CRIME

Um dump é:

👉 uma foto completa do sistema no erro


🔥 Tipos

  • SYSABEND → completo
  • SYSMDUMP → técnico
  • SYSUDUMP → básico
  • SVC Dump → sistema
  • Stand-alone → sistema morto

💡 Tradução

“dump é o momento congelado da falha”


🧠 Exemplo

S0C4
↓
dump gerado
↓
IPCS analisa

🧠 6. LOGREC — O HISTÓRICO DOS ERROS

LOGREC registra:

  • falhas de hardware
  • erros de software
  • condições do sistema

💡 Insight

é o primeiro lugar que um sysprog olha


🔥 Tradução Bellacosa

“LOGREC = diário dos problemas”


📜 7. LOGS — A LINHA DO TEMPO

🔹 Principais:

  • SYSLOG → sistema
  • OPERLOG → sysplex
  • JESMSGLG → job

💡 Uso

👉 entender o “antes” do erro


🎥 8. TRACES — O FILME COMPLETO

Enquanto dump = foto
👉 trace = vídeo


🔹 Tipos:

  • System Trace
  • GTF
  • Component Trace

💡 Uso

👉 analisar fluxo ao longo do tempo


🧠 9. DAE — INTELIGÊNCIA DE DUMP

Evita:

👉 dumps repetidos


🔥 Usa:

  • SYS1.DAE

💡 Tradução

“não repetir análise inútil”


🔎 10. IPCS — O CSI DO MAINFRAME

Ferramenta para:

  • ler dumps
  • interpretar dados
  • analisar erro

💡 Tradução Bellacosa

“IPCS = laboratório forense”


🧨 11. SLIP TRAPS — PEGANDO ERRO NO FLAGRA

Você pode definir:

👉 “quando isso acontecer… capture tudo”


💡 Exemplo

Se S0C4 ocorrer → gerar dump completo

🔥 Tradução

“armadilha inteligente”


⚙️ 12. CLEANUP — O FINAL OBRIGATÓRIO

Após erro ou término:

  • memória liberada
  • datasets fechados
  • locks removidos
  • timers cancelados

💡 Tradução

“ninguém sai sem arrumar o ambiente”


🔄 13. PASSO A PASSO COMPLETO

Programa executa
↓
Erro ocorre
↓
RTM acionado
↓
ESTAE / FRR chamados
↓
Dump gerado
↓
LOGREC atualizado
↓
Recursos liberados
↓
Sistema continua

🧨 CURIOSIDADES (NÍVEL ROOT)

🤯 1. RTM roda até em término normal


🔥 2. Dump pode salvar dias de análise


💀 3. LOGREC é ignorado por iniciantes


🧠 4. SLIP é arma de elite


⚡ 5. z/OS foi feito para falhar… e continuar


🎯 RESUMO FINAL

✔ RTM controla término e erro

✔ RTM1 protege sistema

✔ RTM2 trata task

✔ ESTAE = recuperação

✔ Dumps = evidência

✔ LOGREC = histórico

✔ IPCS = análise


💥 FRASE FINAL

“No mainframe, o erro não encerra o sistema… ele inicia a investigação.”

 

terça-feira, 6 de agosto de 2024

SQLCODE sem Mistérios : O Guia de Sobrevivência do Programador COBOL Padawan diante dos Principais Erros do Db2

 

Bellacosa Mainframe e o sqlcode sem misterios

☕ Um Café no Bellacosa Mainframe

SQLCODE sem Mistérios

O Guia de Sobrevivência do Programador COBOL Padawan diante dos Principais Erros do Db2

Imagine a seguinte cena.

Você acabou de escrever seu primeiro programa COBOL acessando uma tabela Db2. O código compilou. O pré-compilador não reclamou. O BIND terminou aparentemente bem. O JCL foi submetido. O job entrou no JES2, executou alguns segundos e terminou com uma mensagem misteriosa:

SQLCODE = -805

O jovem Padawan olha para o número e pensa:

“Meu programa abendou?”

Talvez sim. Talvez não.

Um SQLCODE negativo não é necessariamente um ABEND do sistema operacional. Ele é uma resposta do Db2 informando que não conseguiu executar determinada instrução SQL. É como se o banco de dados dissesse:

“Recebi sua solicitação, mas existe alguma coisa errada. Aqui está o código que explica o motivo.”

O segredo não é decorar centenas de números. O verdadeiro conhecimento está em aprender a interpretar o contexto, capturar as informações do SQLCA, identificar a instrução que falhou e seguir uma sequência organizada de diagnóstico.

É exatamente isso que faremos neste artigo.

Prepare a caneca, abra o SDSF e venha conhecer o lado Jedi do tratamento de erros SQL em COBOL.


1. Antes do SQLCODE: como COBOL e Db2 conversam?

Um programa COBOL não entende SQL nativamente da mesma maneira que entende comandos como:

MOVE
ADD
PERFORM
READ
WRITE

As instruções SQL aparecem dentro do programa como SQL embutido:

EXEC SQL
    SELECT NOME_CLIENTE
      INTO :WS-NOME-CLIENTE
      FROM CLIENTE
     WHERE COD_CLIENTE = :WS-COD-CLIENTE
END-EXEC.

Durante a preparação do programa, um pré-compilador ou coprocessador Db2 identifica os blocos delimitados por EXEC SQL e END-EXEC, separa o SQL do código COBOL e prepara as estruturas necessárias para a execução. A documentação da IBM estabelece justamente esse formato para aplicações COBOL que emitem comandos SQL. (IBM)

Quando o programa executa uma instrução SQL, o Db2 precisa devolver uma resposta.

Essa resposta inclui, entre outras informações:

  • se a instrução funcionou;

  • se ocorreu um aviso;

  • se nenhum registro foi localizado;

  • se houve erro;

  • qual objeto estava envolvido;

  • quais tokens complementam a mensagem;

  • qual estado SQL representa a situação.

É nesse momento que entra o SQLCA.


2. O que é SQLCA?

SQLCA significa:

SQL Communication Area

Em português:

Área de Comunicação SQL

Ela é uma estrutura de dados usada para transportar informações entre o mecanismo SQL e o programa hospedeiro, como COBOL, PL/I, C ou Assembler.

No COBOL, normalmente incluímos essa estrutura assim:

EXEC SQL
    INCLUDE SQLCA
END-EXEC.

Durante o processo de pré-compilação, essa instrução é substituída pela definição correspondente da estrutura SQLCA. A IBM documenta a composição gerada pelo INCLUDE SQLCA para as diferentes linguagens hospedeiras. (IBM)

Conceitualmente, a origem do SQLCA está ligada à necessidade criada pelo SQL embutido: o banco precisava de uma área padronizada para devolver o resultado de cada operação ao programa que o chamou.

Pense nela como uma pequena central de mensagens.

O COBOL envia:

SELECT este cliente.

O Db2 responde através da SQLCA:

Encontrei.
Não encontrei.
Encontrei, mas houve aviso.
Não consegui porque a tabela não existe.
Não consegui porque o package não foi localizado.
Não consegui porque outro processo está segurando o recurso.

O SQLCODE é apenas o campo mais famoso dessa estrutura.


3. Anatomia básica do SQLCA

Uma representação simplificada da SQLCA em COBOL seria semelhante a esta:

01 SQLCA.
   05 SQLCAID          PIC X(8).
   05 SQLCABC          PIC S9(9) COMP-5.
   05 SQLCODE          PIC S9(9) COMP-5.
   05 SQLERRM.
      49 SQLERRML      PIC S9(4) COMP-5.
      49 SQLERRMC      PIC X(70).
   05 SQLERRP          PIC X(8).
   05 SQLERRD OCCURS 6 TIMES
                       PIC S9(9) COMP-5.
   05 SQLWARN.
      10 SQLWARN0      PIC X.
      10 SQLWARN1      PIC X.
      10 SQLWARN2      PIC X.
      10 SQLWARN3      PIC X.
      10 SQLWARN4      PIC X.
      10 SQLWARN5      PIC X.
      10 SQLWARN6      PIC X.
      10 SQLWARN7      PIC X.
      10 SQLWARN8      PIC X.
      10 SQLWARN9      PIC X.
      10 SQLWARNA      PIC X.
   05 SQLSTATE         PIC X(5).

A definição exata pode variar conforme plataforma, compilador e versão, mas os conceitos permanecem.

SQLCODE

É o código numérico principal retornado pelo Db2.

0       Operação bem-sucedida
+100    Nenhum dado encontrado
positivo diferente de +100
        Operação concluída com aviso
negativo
        Erro

A IBM define que SQLCODE 0 representa sucesso, +100 indica ausência de dados e valores negativos indicam que a execução não foi bem-sucedida. (IBM)

SQLSTATE

É um código de cinco caracteres que classifica a condição de maneira mais padronizada.

Exemplo:

02000

Representa a condição “nenhum dado encontrado”, equivalente ao SQLCODE +100.

SQLCODE é muito usado historicamente em ambientes Db2 e mainframe. SQLSTATE é útil por apresentar uma categorização mais padronizada entre diferentes sistemas gerenciadores de bancos de dados.

SQLERRMC

Contém tokens associados à mensagem.

Se o erro envolver o nome de uma tabela, coluna, package, plano ou autorização, essa área pode trazer justamente a informação que faltava para entender o problema.

SQLERRML

Informa o comprimento válido do conteúdo de SQLERRMC.

Portanto, não é uma boa prática exibir os 70 bytes de SQLERRMC indiscriminadamente. O ideal é considerar a quantidade indicada por SQLERRML.

SQLERRP

Pode identificar o módulo ou componente que detectou a condição. No Db2 for z/OS, os primeiros caracteres normalmente trazem a assinatura DSN. (IBM)

SQLERRD

É um conjunto de campos numéricos com informações complementares.

Dependendo da instrução e do SQLCODE, eles podem indicar:

  • quantidade de linhas afetadas;

  • códigos internos;

  • informações relacionadas ao processamento;

  • razão complementar de determinadas condições.

A interpretação dos campos SQLERRD depende do contexto. Portanto, nunca conclua que um determinado índice possui sempre o mesmo significado em qualquer SQLCODE.

SQLWARN

É um conjunto de indicadores de aviso.

Quando SQLWARN0 contém W, pelo menos uma condição de warning foi identificada. Outros campos mostram categorias específicas de aviso, como truncamento ou situações relacionadas aos dados retornados. A SQLCA utiliza esse conjunto de indicadores para comunicar warnings ao programa. (IBM)


4. A primeira regra Jedi: sempre teste o SQLCODE

Um dos erros mais perigosos não é receber um SQLCODE negativo.

É ignorá-lo.

Observe este código:

EXEC SQL
    SELECT SALDO
      INTO :WS-SALDO
      FROM CONTA
     WHERE NUM_CONTA = :WS-NUM-CONTA
END-EXEC.

DISPLAY 'SALDO: ' WS-SALDO.

O que acontecerá se a conta não existir?

O Db2 retornará +100. Entretanto, se o programa não verificar o resultado, WS-SALDO poderá continuar contendo um valor anterior, zeros, espaços ou dados residuais.

O programa poderá apresentar um saldo incorreto como se fosse válido.

O padrão correto é:

EXEC SQL
    SELECT SALDO
      INTO :WS-SALDO
      FROM CONTA
     WHERE NUM_CONTA = :WS-NUM-CONTA
END-EXEC.

EVALUATE TRUE
    WHEN SQLCODE = 0
         PERFORM 3000-PROCESSAR-SALDO

    WHEN SQLCODE = +100
         PERFORM 3100-CONTA-NAO-ENCONTRADA

    WHEN OTHER
         PERFORM 9000-TRATAR-ERRO-SQL
END-EVALUATE.

Esse modelo deixa explícitos três caminhos:

sucesso;
ausência de dados;
erro inesperado.

5. SQLCODE 0 — sucesso, mas continue atento

SQLCODE = 0 significa que a instrução foi executada com sucesso.

Exemplo:

EXEC SQL
    UPDATE CONTA
       SET SALDO = SALDO - :WS-VALOR
     WHERE NUM_CONTA = :WS-NUM-CONTA
END-EXEC.

Entretanto, existe uma armadilha.

Um UPDATE pode retornar SQLCODE zero e ainda assim não ter atualizado a quantidade de linhas que sua regra de negócio esperava.

Imagine uma rotina que deveria alterar exatamente uma linha.

Mesmo após SQLCODE zero, pode ser importante verificar a quantidade de linhas afetadas usando as informações apropriadas da SQLCA, de acordo com a instrução e o ambiente.

A pergunta profissional não é apenas:

“Funcionou?”

É também:

“Funcionou exatamente como a regra de negócio esperava?”


6. SQLCODE +100 — nenhum dado encontrado

O +100 é provavelmente o SQLCODE positivo mais conhecido.

Ele significa:

No data found.

Nenhum dado foi encontrado.

Isso pode ocorrer em situações como:

  • SELECT INTO sem linha correspondente;

  • FETCH após o final do cursor;

  • determinadas operações que esperavam encontrar um registro;

  • exclusão ou atualização sem correspondência, conforme a instrução e o contexto.

A IBM associa o SQLCODE +100 e o SQLSTATE 02000 à condição NOT FOUND. (IBM)

Exemplo com SELECT

EXEC SQL
    SELECT NOME
      INTO :WS-NOME
      FROM CLIENTE
     WHERE COD_CLIENTE = :WS-COD-CLIENTE
END-EXEC.

IF SQLCODE = +100
    DISPLAY 'CLIENTE NAO ENCONTRADO'
END-IF.

Exemplo com cursor

PERFORM UNTIL WS-FIM-CURSOR = 'S'

    EXEC SQL
        FETCH C1
         INTO :WS-CODIGO,
              :WS-NOME
    END-EXEC

    EVALUATE TRUE
        WHEN SQLCODE = 0
             PERFORM 4000-PROCESSAR-CLIENTE

        WHEN SQLCODE = +100
             MOVE 'S' TO WS-FIM-CURSOR

        WHEN OTHER
             PERFORM 9000-TRATAR-ERRO-SQL
    END-EVALUATE

END-PERFORM.

Possíveis soluções

  1. Verifique se os valores das host variables estão corretos.

  2. Confirme se a linha realmente existe na tabela.

  3. Verifique espaços, zeros à esquerda e formatos de data.

  4. Confirme se o predicado WHERE não está restritivo demais.

  5. Em cursores, trate +100 como fim normal da leitura.

  6. Inicialize as variáveis de saída antes do SELECT.

Dica Bellacosa

Não trate todo +100 como erro técnico.

Em muitos programas, “cliente não encontrado” é uma condição normal de negócio. Em um cursor, +100 é praticamente o equivalente SQL ao fim de arquivo.


7. SQLCODE -204 — objeto não definido

O -204 informa que o objeto referenciado não está definido no subsistema ou contexto em que a instrução está sendo executada. A documentação da IBM cita essa condição para diferentes tipos de objetos Db2. (IBM)

Exemplo:

SELECT *
  FROM CLIENTES

Mas a tabela correta é:

SISTEMA1.CLIENTE

Causas comuns

  • nome da tabela digitado incorretamente;

  • creator ou schema ausente;

  • tabela existente em outro ambiente;

  • synonym, alias ou view inexistente;

  • programa executando em outro subsistema Db2;

  • objeto ainda não criado;

  • qualificador definido incorretamente no BIND;

  • diferença entre desenvolvimento, homologação e produção.

Passo a passo

  1. Capture o conteúdo de SQLERRMC.

  2. Identifique o nome exato do objeto mencionado.

  3. Confirme o subsistema Db2 em que o programa executou.

  4. Pesquise o catálogo Db2.

  5. Verifique o schema ou creator.

  6. Compare o DDL entre os ambientes.

  7. Verifique os parâmetros de qualificação usados no BIND.

  8. Corrija o nome ou solicite a criação do objeto.

Exemplo de correção

Antes:

EXEC SQL
    SELECT NOME
      INTO :WS-NOME
      FROM CLIENTE
     WHERE CODIGO = :WS-CODIGO
END-EXEC.

Depois:

EXEC SQL
    SELECT NOME
      INTO :WS-NOME
      FROM CADASTRO.CLIENTE
     WHERE CODIGO = :WS-CODIGO
END-EXEC.

8. SQLCODE -206 — coluna não encontrada ou inválida

O -206 geralmente indica que o nome de uma coluna não é válido no contexto da instrução.

Exemplo:

SELECT NOME_COMPLETO
  FROM CLIENTE

Mas a coluna real se chama:

NOME_CLIENTE

Causas comuns

  • erro de digitação;

  • coluna removida ou renomeada;

  • referência incorreta a alias de tabela;

  • SQL dinâmico montado de maneira errada;

  • DCLGEN desatualizada;

  • programa compilado com uma versão antiga do layout;

  • promoção incompleta entre ambientes.

Diagnóstico

  1. Identifique a coluna em SQLERRMC.

  2. Consulte a definição atual da tabela.

  3. Compare o SQL com a DCLGEN.

  4. Confirme se o alias da tabela foi usado corretamente.

  5. Verifique se a coluna pertence à tabela esperada.

  6. Atualize e regenere as estruturas, se necessário.

Armadilha clássica

SELECT C.NOME
  FROM CLIENTE X

A tabela recebeu o alias X, mas a coluna foi qualificada com C.

A correção seria:

SELECT X.NOME
  FROM CLIENTE X

9. SQLCODE -305 — valor NULL sem indicador

O -305 é um dos primeiros grandes encontros do programador COBOL com a diferença entre o mundo COBOL e o mundo relacional.

No Db2, uma coluna pode possuir valor NULL.

No COBOL tradicional, uma variável hospedeira comum não possui, sozinha, um terceiro estado que signifique “valor desconhecido ou ausente”.

Por isso usamos uma variável indicadora.

Exemplo incorreto:

EXEC SQL
    SELECT COMPLEMENTO
      INTO :WS-COMPLEMENTO
      FROM ENDERECO
     WHERE COD_CLIENTE = :WS-COD-CLIENTE
END-EXEC.

Se COMPLEMENTO for NULL, o programa poderá receber -305.

Correção

01 WS-COMPLEMENTO       PIC X(30).
01 IND-COMPLEMENTO      PIC S9(4) COMP-5.

EXEC SQL
    SELECT COMPLEMENTO
      INTO :WS-COMPLEMENTO
          :IND-COMPLEMENTO
      FROM ENDERECO
     WHERE COD_CLIENTE = :WS-COD-CLIENTE
END-EXEC.

Depois:

IF IND-COMPLEMENTO < 0
    MOVE 'NAO INFORMADO' TO WS-COMPLEMENTO
END-IF.

Regra prática

Indicador negativo:

o valor recebido é NULL.

Indicador zero:

o valor não é NULL.

Certas condições positivas podem representar informações adicionais, como truncamento, dependendo da operação.

Passo a passo

  1. Descubra qual coluna permite NULL.

  2. Adicione uma variável indicadora compatível.

  3. Associe o indicador à host variable.

  4. Verifique o indicador após a instrução.

  5. Defina a regra de negócio para valores nulos.

  6. Não confunda NULL com espaços ou zeros.


10. SQLCODE -302 — valor incompatível ou grande demais

O -302 costuma indicar que uma variável de entrada possui um valor incompatível com o tipo ou tamanho esperado.

Exemplo:

01 WS-CODIGO PIC X(20).

A coluna Db2 espera um número pequeno, mas o programa envia:

ABC123

Também pode haver problemas de comprimento, precisão, escala ou representação.

Causas comuns

  • conteúdo alfanumérico enviado para coluna numérica;

  • número maior do que a coluna suporta;

  • escala decimal incompatível;

  • data em formato inválido;

  • host variable com definição incorreta;

  • estrutura COBOL divergente do DCLGEN;

  • indicador ou comprimento incorreto.

Passo a passo

  1. Exiba o valor da host variable antes do SQL.

  2. Verifique o tipo da coluna no catálogo.

  3. Compare PIC, USAGE, comprimento, precisão e escala.

  4. Valide dados recebidos de arquivo, tela ou API.

  5. Verifique sinais e casas decimais.

  6. Utilize DCLGEN atualizada.

  7. Não corrija apenas aumentando o campo sem entender a origem do valor.

Exemplo

Coluna:

VALOR DECIMAL(9,2)

Host variable recomendada:

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

Um erro de definição poderia fazer o programa enviar uma representação incompatível.


11. SQLCODE -303 — tipos incompatíveis na atribuição

O -303 aparece quando o Db2 não consegue atribuir um valor à variável hospedeira devido à incompatibilidade de tipos.

Exemplo conceitual:

SELECT DATA_NASCIMENTO
  INTO :WS-VALOR-NUMERICO

Se WS-VALOR-NUMERICO não possuir definição compatível com uma data, haverá problema.

Solução

  • compare o tipo da coluna com a PIC da host variable;

  • use DCLGEN;

  • faça conversões explícitas quando justificadas;

  • evite depender de conversões implícitas;

  • verifique CCSID e codificação quando o erro envolver caracteres;

  • confira precisão e escala em campos decimais.


12. SQLCODE -407 — tentativa de gravar NULL em coluna NOT NULL

O -407 representa a tentativa de atribuir NULL a uma coluna que não aceita valores nulos.

Isso pode ocorrer em:

  • INSERT;

  • UPDATE;

  • processamento de indicadores;

  • triggers;

  • valores omitidos sem default apropriado.

Exemplo

INSERT INTO CLIENTE
       (CODIGO, NOME)
VALUES (:HV-CODIGO, :HV-NOME)

Se o indicador associado a HV-NOME estiver negativo, o programa estará tentando inserir NULL.

Caso NOME seja NOT NULL, a operação falhará.

Passo a passo

  1. Identifique a coluna envolvida.

  2. Verifique os indicadores.

  3. Consulte a definição NULL/NOT NULL.

  4. Confirme se existe valor default.

  5. Valide os campos obrigatórios antes do SQL.

  6. Não substitua NULL por espaços sem autorização da regra de negócio.


13. SQLCODE -803 — chave duplicada

O -803 é o guardião da unicidade.

Ele geralmente ocorre quando um INSERT ou UPDATE tenta gerar um valor que viola um índice único ou uma restrição de unicidade.

Exemplo:

INSERT INTO CLIENTE
       (COD_CLIENTE, NOME)
VALUES (100, 'ANA')

Mas já existe um cliente com código 100.

Causas comuns

  • chave primária já existente;

  • índice único violado;

  • contador ou sequência mal controlada;

  • reprocessamento do mesmo arquivo;

  • mensagem MQ processada duas vezes;

  • reinício de job sem checkpoint;

  • concorrência entre processos;

  • lógica “consultar e depois inserir” sujeita a corrida.

Passo a passo

  1. Identifique a constraint ou índice envolvido.

  2. Verifique quais colunas formam a chave única.

  3. Consulte o registro existente.

  4. Descubra se é duplicidade real ou reprocessamento.

  5. Verifique a origem da chave.

  6. Avalie o uso de sequence ou identity.

  7. Torne o processamento idempotente quando necessário.

  8. Não resolva apagando o registro anterior sem análise.

Dica de produção

Em sistemas distribuídos, o -803 pode ser sintoma de uma mensagem repetida, não de um erro humano.

A pergunta correta pode ser:

“Por que esta transação chegou duas vezes?”


14. SQLCODE -805 — package não encontrado

O -805 é um clássico do Db2 for z/OS.

Ele normalmente informa que o Db2 não encontrou o package necessário para executar a instrução SQL.

Seu programa foi compilado, linkeditado e executado, mas o componente Db2 correspondente não foi localizado na collection esperada.

Causas comuns

  • DBRM não foi bindado;

  • BIND PACKAGE não foi executado;

  • collection incorreta;

  • versão incorreta;

  • package removido;

  • plano não possui PKLIST adequado;

  • programa executando em subsistema diferente;

  • promoção incompleta;

  • load module novo com package antigo;

  • package novo com load module antigo.

Passo a passo de diagnóstico

  1. Capture todo o conteúdo de SQLERRMC.

  2. Identifique location, collection, package e consistência.

  3. Confirme qual load module foi executado.

  4. Verifique a STEPLIB ou JOBLIB.

  5. Confirme o subsistema Db2.

  6. Consulte o catálogo para verificar se o package existe.

  7. Confira collection e versão.

  8. Verifique o PKLIST do plano.

  9. Execute ou solicite o BIND correto.

  10. Confirme se programa e package pertencem à mesma construção.

Analogia Bellacosa

O load module é o guerreiro.

O package é o pergaminho com a estratégia SQL.

O plano ou contexto de execução é a autorização para usar determinados pergaminhos.

No -805, o guerreiro chegou ao campo de batalha, mas o pergaminho correto não estava na biblioteca.


15. SQLCODE -818 — incompatibilidade de timestamp

O -818 normalmente indica que o módulo executável e o DBRM/package associado não pertencem à mesma preparação.

Em termos simples:

o código COBOL e o código SQL ficaram fora de sincronia.

Cenário clássico

  1. Programa é pré-compilado.

  2. Um novo DBRM é produzido.

  3. O programa é compilado e linkeditado.

  4. O BIND usa um DBRM antigo.

Ou:

  1. O package foi atualizado.

  2. O load module antigo continua na load library.

Solução passo a passo

  1. Identifique o load module carregado.

  2. Confirme a data e versão do módulo.

  3. Identifique o DBRM usado no último BIND.

  4. Refaça toda a cadeia de construção.

  5. Pré-compile novamente.

  6. Compile novamente.

  7. Faça o link-edit novamente.

  8. Execute o BIND novamente.

  9. Promova load module e package como uma unidade.

  10. Verifique se a execução está lendo a biblioteca correta.

Dica DevOps

Nunca trate o package e o executável como artefatos independentes.

Eles são partes da mesma entrega.


16. SQLCODE -811 — SELECT retornou mais de uma linha

Um SELECT INTO espera, normalmente, uma única linha.

Exemplo:

EXEC SQL
    SELECT NOME
      INTO :WS-NOME
      FROM CLIENTE
     WHERE CIDADE = :WS-CIDADE
END-EXEC.

Se existirem cem clientes na cidade, o Db2 não poderá decidir qual nome devolver.

Resultado:

SQLCODE -811

Causas

  • predicado incompleto;

  • premissa errada de unicidade;

  • dados duplicados;

  • constraint ausente;

  • chave incorreta;

  • regra de negócio mudou;

  • SELECT deveria utilizar cursor.

Soluções

Quando deveria existir apenas uma linha

  • corrija o WHERE;

  • consulte pela chave correta;

  • elimine duplicidades de forma controlada;

  • implemente constraint única quando fizer sentido.

Quando várias linhas são válidas

Use cursor:

EXEC SQL
    DECLARE C1 CURSOR FOR
        SELECT NOME
          FROM CLIENTE
         WHERE CIDADE = :WS-CIDADE
END-EXEC.

Cuidado com a falsa solução

Adicionar algo equivalente a “pegue apenas a primeira linha” pode esconder um problema de dados.

Antes de limitar o resultado, pergunte:

“Qual linha é realmente a correta?”


17. SQLCODE -904 — recurso indisponível

O -904 indica que a instrução não foi executada porque um recurso necessário estava indisponível. A mensagem traz informações como reason code, tipo do recurso e nome do recurso. (IBM)

Possíveis causas

  • tablespace parado;

  • objeto em estado restritivo;

  • partição indisponível;

  • utilitário em execução;

  • recurso não iniciado;

  • problema de comunicação;

  • recurso auxiliar indisponível;

  • condição de recuperação pendente.

Passo a passo

  1. Capture o reason code.

  2. Capture o resource type.

  3. Capture o resource name.

  4. Consulte a documentação do reason code.

  5. Verifique mensagens Db2 no log.

  6. Consulte o estado do objeto.

  7. Verifique utilitários ativos.

  8. Acione o DBA ou suporte de produção com os dados completos.

  9. Não tente repetir indefinidamente sem entender a indisponibilidade.

Dica importante

-904 sem reason code é apenas metade do diagnóstico.

Dizer ao DBA:

“Deu menos novecentos e quatro”

é pouco útil.

Dizer:

“SQLCODE -904, reason 00C9..., resource type ..., resource name ...”

transforma um pedido genérico em uma investigação objetiva.


18. SQLCODE -911 e -913 — deadlock ou timeout

Esses códigos aparecem em situações de contenção, timeout ou deadlock.

Deadlock

Dois processos ficam esperando recursos mantidos um pelo outro.

Exemplo:

Programa A atualiza CLIENTE e espera CONTA.
Programa B atualiza CONTA e espera CLIENTE.

Nenhum consegue continuar.

O Db2 escolhe uma das unidades de trabalho como vítima para liberar o impasse.

Timeout

Um processo aguarda um recurso por mais tempo do que o limite permitido.

Diferença prática

A interpretação exata deve considerar:

  • SQLCODE;

  • reason code;

  • mensagens;

  • rollback executado;

  • ambiente e parâmetros;

  • informações de trace.

Em muitos cenários, -911 aparece quando a unidade de trabalho sofre rollback, enquanto -913 pode indicar uma condição semelhante sem o mesmo comportamento automático de rollback. A confirmação deve ser feita pelos dados complementares, especialmente reason code e SQLERRD. (Comunidade IBM)

Possíveis soluções

  1. Reduza o tempo entre commits.

  2. Não mantenha cursor ou unidade de trabalho aberta desnecessariamente.

  3. Acesse tabelas na mesma ordem em todos os programas.

  4. Atualize somente as linhas necessárias.

  5. Garanta bons índices.

  6. Evite varreduras extensas durante updates.

  7. Analise isolamento e concorrência.

  8. Implemente retry controlado quando permitido.

  9. Não faça retry infinito.

  10. Registre tentativa, horário e chave processada.

Exemplo de retry controlado

MOVE 0 TO WS-TENTATIVAS.

PERFORM UNTIL WS-SUCESSO = 'S'
           OR WS-TENTATIVAS >= 3

    ADD 1 TO WS-TENTATIVAS

    PERFORM 5000-EXECUTAR-TRANSACAO

    EVALUATE SQLCODE
        WHEN 0
             MOVE 'S' TO WS-SUCESSO

        WHEN -911
             PERFORM 5100-PREPARAR-NOVA-TENTATIVA

        WHEN -913
             PERFORM 5100-PREPARAR-NOVA-TENTATIVA

        WHEN OTHER
             PERFORM 9000-TRATAR-ERRO-SQL
             MOVE 'S' TO WS-ENCERRAR
    END-EVALUATE

END-PERFORM.

O retry precisa respeitar a arquitetura da aplicação. Em alguns casos, repetir a operação automaticamente pode duplicar efeitos externos.


19. SQLCODE -922 — falha de autorização

O -922 normalmente está relacionado à autorização, conexão ou acesso a recursos do Db2.

Possíveis causas

  • usuário sem privilégio;

  • plano sem autorização;

  • package sem autorização de execução;

  • falha na conexão;

  • contexto de segurança incorreto;

  • autorização RACF ou Db2 ausente;

  • ambiente executando com outro ID;

  • mudança de owner ou qualifier.

Passo a passo

  1. Identifique o authorization ID em uso.

  2. Capture os tokens da SQLCA.

  3. Verifique o privilégio exigido.

  4. Confirme quem é o owner do package.

  5. Verifique autorização de EXECUTE.

  6. Confira plano, collection e contexto de execução.

  7. Analise mensagens SAF/RACF quando aplicável.

  8. Solicite o GRANT correto.

  9. Nunca peça privilégios excessivos apenas para “fazer funcionar”.


20. SQLCODE -501, -502 e -514 — problemas com cursor

-501

Tentativa de executar FETCH ou CLOSE em cursor que não está aberto.

-502

Tentativa de abrir um cursor que já está aberto.

-514

O cursor não está em estado adequado para a operação, frequentemente por não estar preparado corretamente em cenários de SQL dinâmico.

Checklist de cursor

A sequência esperada é:

DECLARE
OPEN
FETCH
FETCH
FETCH
...
+100
CLOSE

No COBOL:

EXEC SQL
    OPEN C1
END-EXEC.

IF SQLCODE NOT = 0
    PERFORM 9000-TRATAR-ERRO-SQL
END-IF.

PERFORM UNTIL WS-FIM = 'S'

    EXEC SQL
        FETCH C1
         INTO :WS-CODIGO,
              :WS-NOME
    END-EXEC

    EVALUATE SQLCODE
        WHEN 0
             PERFORM 4000-PROCESSAR
        WHEN +100
             MOVE 'S' TO WS-FIM
        WHEN OTHER
             PERFORM 9000-TRATAR-ERRO-SQL
             MOVE 'S' TO WS-FIM
    END-EVALUATE

END-PERFORM.

EXEC SQL
    CLOSE C1
END-EXEC.

Dica

Use flags explícitas:

01 WS-CURSOR-ABERTO PIC X VALUE 'N'.
01 WS-FIM-CURSOR    PIC X VALUE 'N'.

Elas ajudam a impedir OPEN duplicado ou FETCH após fechamento.


21. WHENEVER: útil, mas não mágico

O Db2 permite instruções como:

EXEC SQL
    WHENEVER SQLERROR
    GO TO 9000-ERRO-SQL
END-EXEC.

Também existem:

EXEC SQL
    WHENEVER NOT FOUND
    GO TO 8000-NAO-ENCONTRADO
END-EXEC.

EXEC SQL
    WHENEVER SQLWARNING
    GO TO 8500-WARNING-SQL
END-EXEC.

A IBM documenta que:

  • NOT FOUND corresponde ao +100;

  • SQLERROR corresponde a SQLCODE negativo;

  • SQLWARNING cobre warnings e códigos positivos diferentes de +100. (IBM)

Entretanto, existe uma característica importante:

WHENEVER é uma diretiva tratada durante a preparação do SQL embutido. Seu efeito depende da posição em que aparece no fonte.

Ela não funciona exatamente como uma configuração dinâmica COBOL tradicional.

Risco

Um programador pode colocar:

EXEC SQL
    WHENEVER SQLERROR GO TO 9000-ERRO
END-EXEC.

e depois esquecer que todas as instruções SQL seguintes estarão sujeitas a esse desvio, até que outra diretiva altere o comportamento.

Alternativa explícita

Muitas equipes preferem:

EXEC SQL
    WHENEVER SQLERROR CONTINUE
END-EXEC.

E verificam o SQLCODE após cada comando:

EXEC SQL
    DELETE FROM TEMPORARIA
     WHERE CHAVE = :WS-CHAVE
END-EXEC.

PERFORM 9100-VERIFICAR-SQL.

Isso pode tornar o fluxo mais previsível.


22. Uma rotina COBOL centralizada de tratamento

Uma boa aplicação não deveria espalhar dezenas de DISPLAY SQLCODE improvisados.

Crie uma rotina padronizada:

9000-TRATAR-ERRO-SQL.

    DISPLAY '**************************************'
    DISPLAY '* ERRO DB2                           *'
    DISPLAY '**************************************'
    DISPLAY 'PROGRAMA : ' WS-NOME-PROGRAMA
    DISPLAY 'PARAGRAFO: ' WS-PARAGRAFO-ATUAL
    DISPLAY 'OPERACAO : ' WS-OPERACAO-SQL
    DISPLAY 'SQLCODE  : ' SQLCODE
    DISPLAY 'SQLSTATE : ' SQLSTATE
    DISPLAY 'SQLERRP  : ' SQLERRP
    DISPLAY 'SQLERRML : ' SQLERRML
    DISPLAY 'SQLERRMC : ' SQLERRMC
    DISPLAY 'SQLERRD1 : ' SQLERRD (1)
    DISPLAY 'SQLERRD2 : ' SQLERRD (2)
    DISPLAY 'SQLERRD3 : ' SQLERRD (3)
    DISPLAY 'SQLERRD4 : ' SQLERRD (4)
    DISPLAY 'SQLERRD5 : ' SQLERRD (5)
    DISPLAY 'SQLERRD6 : ' SQLERRD (6)
    DISPLAY '**************************************'

    MOVE 12 TO RETURN-CODE.

Em produção, avalie cuidados com dados sensíveis. Não exiba:

  • senhas;

  • tokens;

  • informações pessoais desnecessárias;

  • números completos de documentos;

  • dados financeiros sigilosos;

  • comandos SQL contendo informações protegidas.

A observabilidade deve ajudar o diagnóstico sem criar uma nova vulnerabilidade.


23. O passo a passo universal de diagnóstico

Quando aparecer um SQLCODE inesperado, siga esta sequência.

Passo 1 — identifique a instrução

Não procure apenas pelo número.

Descubra:

qual programa;
qual parágrafo;
qual instrução SQL;
qual tabela;
qual chave;
qual operação.

Passo 2 — registre a SQLCA

Capture:

SQLCODE;
SQLSTATE;
SQLERRMC;
SQLERRML;
SQLERRP;
SQLERRD;
SQLWARN.

Passo 3 — descubra a categoria

Pergunte:

É sucesso?
É +100?
É warning?
É erro de dados?
É erro de objeto?
É erro de package?
É erro de autorização?
É indisponibilidade?
É concorrência?

Passo 4 — leia os tokens

Muitos SQLCODEs só ficam claros quando analisamos SQLERRMC, reason code, nome do recurso ou nome do objeto.

Passo 5 — reproduza com os mesmos dados

Tente identificar:

  • chave;

  • conteúdo das host variables;

  • ambiente;

  • versão do programa;

  • package;

  • plano;

  • horário;

  • unidade de trabalho.

Passo 6 — compare estruturas

Verifique:

  • DCLGEN;

  • catálogo;

  • copybooks;

  • tipos;

  • comprimentos;

  • indicadores;

  • nullabilidade;

  • índices;

  • constraints.

Passo 7 — corrija a causa, não apenas o sintoma

Exemplo:

Sintoma: -803.
Correção ruim: ignorar toda duplicidade.
Correção real: descobrir por que a transação foi processada novamente.

Passo 8 — crie proteção contra recorrência

Depois de corrigir:

  • adicione validação;

  • melhore o log;

  • crie teste;

  • atualize documentação;

  • ajuste pipeline;

  • implemente monitoramento;

  • reveja commit e rollback.


24. COMMIT e ROLLBACK: a responsabilidade do Padawan

Uma transação Db2 não é apenas uma sequência de comandos.

Ela é uma unidade lógica de trabalho.

Exemplo:

Debitar conta A.
Creditar conta B.
Registrar movimentação.

Essas três ações precisam ser tratadas como um conjunto.

Se a primeira funcionar e a segunda falhar, você não pode simplesmente continuar.

EXEC SQL
    COMMIT
END-EXEC.

confirma a unidade de trabalho.

EXEC SQL
    ROLLBACK
END-EXEC.

desfaz alterações ainda não confirmadas, dentro das regras e do contexto da aplicação.

Cuidado

Não espalhe commits aleatórios apenas para reduzir locks.

Um commit mal posicionado pode quebrar a atomicidade da transação.

O ponto de commit deve refletir a regra de negócio, não apenas uma tentativa de silenciar problemas de concorrência.


25. Dicas de veterano para o COBOL Padawan

Use DCLGEN

A DCLGEN ajuda a alinhar as colunas Db2 com as variáveis COBOL.

Mas lembre-se:

DCLGEN não é um artefato eterno.

Se a tabela mudar, a declaração precisa ser revisada e regenerada.

Inicialize variáveis

Antes de um SELECT INTO, inicialize as variáveis de saída quando isso fizer sentido.

Isso evita o uso acidental de conteúdo anterior após um +100.

Registre o ponto da falha

Antes da instrução:

MOVE 'SELECT-CLIENTE'
  TO WS-OPERACAO-SQL.

Assim a rotina central sabe exatamente qual comando falhou.

Não use apenas DISPLAY

Em aplicações maduras, prefira uma estratégia padronizada de logging, mensagens de aplicação, códigos de retorno e integração com observabilidade.

Diferencie erro técnico de erro de negócio

+100 procurando cliente opcional:
condição de negócio.

-805:
erro técnico de implantação.

-803 ao reprocessar mensagem:
pode representar condição funcional de idempotência.

-911:
condição técnica de concorrência que talvez permita retry.

Conheça o ambiente

Em Db2 for z/OS, o diagnóstico frequentemente envolve muito mais do que o fonte:

  • subsistema Db2;

  • catálogo;

  • package;

  • collection;

  • plan;

  • DBRM;

  • BIND;

  • load library;

  • RACF;

  • JES2;

  • SDSF;

  • logs;

  • utilitários;

  • locks.


26. Curiosidade: SQLCODE não é ABEND

Um SQLCODE negativo indica que uma instrução SQL falhou.

Um ABEND indica encerramento anormal de uma task, job step ou programa.

Os dois podem aparecer juntos, mas não são a mesma coisa.

Um programa bem escrito pode receber -803, tratar a duplicidade e continuar.

Outro programa pode receber +100, ignorar a condição e mais tarde causar um S0C7 porque tentou usar dados inválidos.

Portanto:

SQLCODE negativo não significa automaticamente ABEND.
SQLCODE positivo não significa automaticamente que tudo está correto.

O resultado depende da maneira como o programa reage.


27. Easter egg do Bellacosa Mainframe

Nos filmes, o jovem Jedi pergunta:

“Mestre, como saberei qual caminho seguir?”

O mestre responde:

“Observe a Força.”

No Db2, a resposta seria:

“Observe a SQLCA.”

O SQLCODE mostra a direção geral.

O SQLSTATE mostra a categoria.

O SQLERRMC revela os personagens envolvidos.

O reason code explica a motivação do vilão.

O SQLERRD guarda pistas escondidas.

O log do Db2 conta o que aconteceu fora da câmera.

E o programa COBOL decide se deve:

continuar;
encerrar;
repetir;
fazer rollback;
informar o usuário;
acionar o suporte.

O verdadeiro Sith não é o SQLCODE negativo.

O verdadeiro Sith é o programa que recebe uma mensagem de erro, ignora a SQLCA e continua processando dados como se nada tivesse acontecido.


28. Tabela de bolso do Padawan

SQLCODE   SIGNIFICADO PRINCIPAL
-------   ----------------------------------------------
0         Execução bem-sucedida
+100      Nenhum dado encontrado / fim do cursor
-204      Objeto não definido
-206      Coluna inválida ou não encontrada
-302      Valor de entrada incompatível ou excessivo
-303      Tipos incompatíveis
-305      NULL recebido sem variável indicadora
-407      NULL enviado para coluna NOT NULL
-501      Cursor não aberto
-502      Cursor já aberto
-514      Cursor em estado inadequado
-803      Violação de chave ou índice único
-805      Package não encontrado
-811      SELECT INTO retornou mais de uma linha
-818      Incompatibilidade entre módulo e DBRM/package
-904      Recurso indisponível
-911      Timeout/deadlock com impacto na unidade de trabalho
-913      Timeout/deadlock; analisar rollback e reason code
-922      Falha de autorização ou conexão

Essa tabela é um mapa inicial, não substitui a documentação completa. O catálogo de códigos Db2 fornece explicações, ações do sistema e respostas recomendadas para cada condição. (IBM)


Conclusão: o erro é uma mensagem, não uma sentença

Aprender Db2 com COBOL não significa decorar uma enciclopédia de SQLCODEs.

Significa construir um método.

Quando uma instrução falhar:

  1. pare;

  2. identifique o SQL;

  3. capture a SQLCA;

  4. leia o SQLCODE;

  5. consulte o SQLSTATE;

  6. analise os tokens;

  7. identifique objetos e reason codes;

  8. verifique host variables;

  9. confirme package, plano e ambiente;

  10. corrija a causa;

  11. proteja o sistema contra recorrência.

Com o tempo, os números deixam de parecer mensagens alienígenas.

O +100 passa a significar fim normal de cursor.

O -305 lembra imediatamente uma variável indicadora esquecida.

O -803 aponta para unicidade ou reprocessamento.

O -805 faz você olhar para package, collection e BIND.

O -818 lembra que load module e DBRM precisam caminhar juntos.

O -911 acende o alerta de concorrência, commit e retry.

O -904 exige reason code, resource type e resource name.

Nesse momento, o Padawan deixa de perguntar:

“Por que o Db2 quebrou?”

E começa a perguntar:

“Qual condição o Db2 está comunicando, quais evidências ele forneceu e qual é a resposta correta da aplicação?”

Essa mudança de postura é o nascimento de um verdadeiro programador de sistemas corporativos.

Porque no Bellacosa Mainframe, cada SQLCODE é uma pista, cada SQLCA é um mapa e cada erro corretamente tratado é mais uma transação protegida no coração do IBM Z.

 


domingo, 4 de agosto de 2024

O Sysprog Bayesiano: por que um veterano vê um S0C7 e já começa a atualizar probabilidades na cabeça

 

Bellacosa Mainframe e o sysprog bayesino

☕ Um Café no Bellacosa Mainframe

O Sysprog Bayesiano: por que um veterano vê um S0C7 e já começa a atualizar probabilidades na cabeça

🧙‍♂️ Bayes, troubleshooting, observabilidade, dumps, experiência e o estranho fenômeno pelo qual trinta anos de produção transformam “acho que é isso” numa distribuição de probabilidades ambulante

Existe um fenômeno curioso nos CPDs.

Você coloca um programador iniciante diante de uma mensagem:

ABEND S0C7

Ele olha para a tela.

A tela olha para ele.

Durante alguns segundos acontece uma negociação diplomática silenciosa.

Então vem a primeira conclusão:

— O MAINFRAME QUEBROU.

Nesse instante, vindo de algum ponto escuro da sala, aparece um veterano carregando café.

Ele nem senta.

Olha para o código.

Olha para o dump.

Pergunta:

— Em qual instrução?

— Aqui.

— Qual campo?

— WS-VALOR.

— De onde veio?

— Arquivo.

— Mudaram o layout ontem?

Silêncio.

Alguém responde:

— Talvez.

O veterano toma um gole.

— Então começa por aí.

O jovem fica perplexo.

Como aquele sujeito chegou a uma hipótese em vinte segundos?

Telepatia?

Magia?

Décadas respirando ar reciclado de CPD?

Ele nasceu com um SYS1.LOGREC dentro do cérebro?

Não.

O que aconteceu foi muito mais interessante.

Sem perceber, o veterano acabou de executar uma espécie de inferência bayesiana humana.

Ele recebeu uma evidência.

Atualizou probabilidades.

Recebeu outra.

Atualizou novamente.

Eliminou hipóteses improváveis.

Aumentou o peso das plausíveis.

E começou a procurar onde havia maior chance de encontrar o defeito.

Ele talvez nunca tenha escrito:

P(H|E)

num quadro.

Mas passou quarenta anos fazendo exatamente isso.

Pegue o café.

Hoje vamos descobrir por que todo bom profissional de troubleshooting acaba virando, em algum grau, um Bayesiano de produção.


Capítulo I — Antes de falarmos de Bayes, precisamos quebrar alguma coisa

Vamos montar nosso pequeno desastre.

Programa COBOL:

WORKING-STORAGE SECTION.

01 WS-VALOR      PIC 9(7)V99.
01 WS-QUANTIDADE PIC 9(5).

PROCEDURE DIVISION.

    COMPUTE WS-TOTAL =
        WS-VALOR * WS-QUANTIDADE.

O programa funcionava havia meses.

Numa bela terça-feira às 10h37:

SYSTEM COMPLETION CODE=0C7

Pronto.

Produção abriu chamado.

O gerente pergunta:

— O que aconteceu?

Resposta tecnicamente perfeita:

— Tivemos um S0C7.

Gerente:

— E o que significa?

— Data exception.

Gerente:

— E o que significa?

— Temos algum dado incompatível com uma operação decimal.

Gerente:

— E o que significa?

— Alguma coisa está errada.

Gerente:

— Excelente. Vou informar à diretoria.

Troubleshooting começou.


Capítulo II — O iniciante vê possibilidades; o veterano vê probabilidades

Quando recebemos apenas:

S0C7

existem várias causas possíveis.

Talvez:

  • um campo numérico tenha caracteres inválidos;

  • um layout esteja incorreto;

  • tenha ocorrido deslocamento de dados;

  • um campo packed decimal esteja corrompido;

  • uma área tenha sido sobrescrita;

  • um programa esteja utilizando definição diferente do arquivo;

  • uma alteração recente tenha introduzido inconsistência;

  • o offset esteja apontando para uma rotina específica;

  • exista problema em dados provenientes de outro sistema.

O programador iniciante pensa:

“Pode ser qualquer coisa.”

O veterano pensa:

“Pode ser muita coisa, mas algumas são muito mais prováveis que outras.”

Essa diferença é gigantesca.

O iniciante possui um conjunto:

H1 H2 H3 H4 H5 H6 H7 H8...

O veterano possui algo parecido com:

H1  45%
H2  25%
H3  12%
H4   8%
H5   5%
outros...

Esses números não estão escritos conscientemente.

Provavelmente nem são números precisos.

Mas existe uma ordenação implícita das hipóteses.

Isso é experiência.


Capítulo III — Entre Thomas Bayes carregando café

Thomas Bayes foi um matemático e ministro presbiteriano britânico do século XVIII.

Séculos depois, sem jamais imaginar CICS, COBOL, Db2 ou alguém chamando às três da manhã porque “o batch parou”, seu nome ficaria associado a uma das ideias mais poderosas da estatística:

quando recebemos nova evidência, devemos atualizar aquilo que acreditávamos anteriormente.

De maneira clássica:

P(A|B) = P(B|A) × P(A) / P(B)

Não fuja.

Vamos traduzir isso para português de CPD.

A é uma hipótese.

Por exemplo:

“O S0C7 foi causado por dado não numérico vindo do arquivo de entrada.”

B é uma evidência.

Por exemplo:

“O erro começou exatamente depois de uma alteração no layout desse arquivo.”

Bayes pergunta:

sabendo dessa nova evidência, quanto devo aumentar ou diminuir minha confiança na hipótese?

Pronto.

Você acabou de fazer estatística.

Pode guardar a calculadora.


Capítulo IV — O prior: aquilo que você acreditava antes de olhar o dump

Antes de receber qualquer evidência específica, você já possui alguma noção sobre quais causas são comuns.

Isso é chamado de prior probability, ou probabilidade a priori.

Imagine mil incidentes históricos de S0C7.

Hipoteticamente:

dados inválidos             45%
layout incompatível         25%
área sobrescrita            15%
erro de lógica               8%
outros                       7%

Esses números são apenas ilustrativos.

Mas representam algo real:

alguns defeitos aparecem mais frequentemente que outros.

O profissional experiente acumulou isso na cabeça.

Talvez nunca tenha registrado estatisticamente.

Mas lembra de vinte incidentes semelhantes.

Quando vê:

S0C7

seu cérebro imediatamente diz:

— Primeiro vou procurar dados.

Isso não é preconceito irracional.

É utilização de frequência histórica.

O nome elegante é:

prior.

No CPD chamamos:

— Já vi essa porcaria antes.


Capítulo V — Agora chega a evidência

Então descobrimos:

O programa funcionava normalmente até ontem.

Interessante.

Isso altera probabilidades.

Se fosse um erro estrutural presente no programa havia meses, por que apareceu justamente hoje?

Talvez algum dado novo tenha provocado o caminho.

Ou alguma alteração tenha ocorrido.

O veterano pergunta:

— Teve mudança?

Resposta:

— Sim. Alteraram o arquivo upstream ontem à noite.

BUM.

A hipótese:

LAYOUT INCOMPATÍVEL

ganha peso.

Outras perdem.

Nosso cérebro fez aproximadamente:

ANTES DA EVIDÊNCIA

dados inválidos       █████████
layout                █████
storage overwrite     ███
outros                 ██

Depois:

DEPOIS DA MUDANÇA CONHECIDA

layout                ██████████████
dados inválidos       ███████
storage overwrite     █
outros                 █

Não sabemos ainda a causa.

Mas reorganizamos nossa fila de investigação.


Capítulo VI — Troubleshooting não é descobrir imediatamente a resposta

Esse ponto merece um café inteiro.

Um bom diagnóstico raramente funciona assim:

ERRO
↓
EUREKA
↓
SOLUÇÃO

Normalmente funciona:

ERRO
↓
HIPÓTESES
↓
EVIDÊNCIA
↓
ATUALIZAÇÃO
↓
NOVO TESTE
↓
NOVA EVIDÊNCIA
↓
ATUALIZAÇÃO
↓
HIPÓTESE MAIS FORTE
↓
CONFIRMAÇÃO

Ou seja:

troubleshooting é um processo iterativo de redução de incerteza.

Cada pergunta deveria servir para eliminar possibilidades.

Perguntar:

— O sistema está ruim?

ajuda pouco.

Perguntar:

— Qual foi o primeiro job que falhou?

ajuda muito mais.

Perguntar:

— Qual alteração entrou imediatamente antes?

melhor ainda.

Perguntar:

— O mesmo input reproduz o problema?

agora estamos cozinhando com gás.


Capítulo VII — O dump é uma máquina de reduzir entropia

No artigo anterior falamos sobre entropia como incerteza.

Receber apenas:

SISTEMA NÃO FUNCIONA

é alta entropia.

Pode ser praticamente qualquer coisa.

Agora recebemos:

JOB ABC123
STEP STEP040
PGM COBPAY01
ABEND S0C7

Já reduzimos bastante.

Depois:

OFFSET X'03A8'

Menos incerteza.

Mapeamos para:

COMPUTE WS-TOTAL =
        WS-VALOR * WS-QTD

Menos ainda.

Inspecionamos WS-VALOR.

Encontramos:

12A45

Praticamente resolvido.

Observe o processo.

Não fomos ficando “mais inteligentes”.

Recebemos informação discriminatória.

Cada pedaço eliminou hipóteses.


Capítulo VIII — Observabilidade é infraestrutura para Bayes

É por isso que observabilidade é tão importante.

Logs.

Métricas.

Traces.

SMF.

RMF.

Mensagens.

Dumps.

SQLCODEs.

File Status.

Registros de auditoria.

Histórico de mudanças.

Todos esses elementos possuem uma finalidade profunda:

fornecer evidências que permitam distinguir hipóteses concorrentes.

Sem observabilidade:

SISTEMA ESTÁ LENTO.

Com observabilidade:

CPU NORMAL
I/O ELEVADO
DB2 GETPAGES +600%
ACCESS PATH ALTERADO
APÓS RUNSTATS

Agora nossa distribuição mental muda completamente.

Talvez CPU não seja o problema.

Talvez rede não seja.

Talvez storage físico não seja.

O access path acabou de se tornar nosso principal suspeito.

Observabilidade não resolve automaticamente o incidente.

Ela melhora brutalmente a qualidade das probabilidades.


Capítulo IX — O detetive ruim coleta dados; o bom coleta dados discriminatórios

Imagine um investigador perguntando:

— Qual foi a temperatura da sala?

Resposta:

— 22 graus.

Talvez útil.

Talvez completamente irrelevante.

Agora:

— O problema começou antes ou depois do deploy?

Isso pode dividir o universo em dois.

Uma boa pergunta de troubleshooting possui alto valor informacional.

Ela separa hipóteses.

Perguntas ruins produzem fatos interessantes.

Perguntas boas destroem possibilidades.

Isso vale para qualquer ambiente:

CICS
DB2
IMS
JES2
VSAM
z/OS
Linux
Cloud
Kubernetes
rede
aplicação

O profissional experiente pergunta pouco.

Mas pergunta aquilo que muda o mapa.


Capítulo X — Exemplo: CICS está lento

Chamado:

“CICS está lento.”

Maravilha.

Talvez sejam:

  • transações;

  • Db2;

  • MQ;

  • CPU;

  • storage;

  • locking;

  • network;

  • runaway task;

  • file control;

  • região chegando ao limite;

  • aplicação;

  • downstream;

  • usuário exagerando;

  • Mercúrio retrógrado.

Bayes entra na sala.

Pergunta número 1:

— Todas as transações?

Resposta:

— Não. Apenas PAY1.

Pronto.

Hipótese de problema generalizado do CICS cai.

Pergunta número 2:

— Quando começou?

— Depois da implantação das 14h.

Outra atualização.

Pergunta número 3:

— O que mudou no PAY1?

— Uma nova consulta Db2.

A distribuição entra em colapso.

Pergunta:

— Temos SQL elapsed?

— Sim. A consulta nova responde em 11 segundos.

Caso quase encerrado.

Não precisamos desmontar o LPAR.

Não precisamos reiniciar CICS.

Não precisamos sacrificar um estagiário ao deus do throughput.

Obtivemos evidência.


Capítulo XI — O problema da ação prematura

Agora conhecemos um personagem muito perigoso:

o técnico que age antes de atualizar probabilidades.

Sistema lento?

— Reinicia.

CICS estranho?

— Recicla região.

Db2?

— Rebind.

Servidor?

— Reboot.

Aplicação?

— Redeploy.

Esse comportamento às vezes funciona.

E justamente por funcionar ocasionalmente torna-se perigosíssimo.

Porque cria aprendizado incorreto:

PROBLEMA
+
RESTART
=
RESOLVIDO

Talvez o restart apenas tenha removido temporariamente o sintoma.

O problema real permanece.

É como encontrar uma pessoa caída no chão, trocar o tapete e declarar vitória porque agora ela está deitada numa superfície limpa.


Capítulo XII — O veterano não pergunta apenas “o que aconteceu?”

Ele pergunta:

o que seria esperado se minha hipótese estivesse correta?

Isso é crucial.

Hipótese:

“O problema é exaustão de storage.”

Então deveríamos observar determinados sinais.

Se eles não aparecem, a hipótese perde força.

Hipótese:

“O problema é lock contention no Db2.”

Então deveríamos observar waits, locks e padrões compatíveis.

Não apareceram?

Probabilidade cai.

Essa é uma diferença fundamental entre investigação e superstição.

Superstição:

“Da última vez era storage.”

Investigação:

“Se for storage, quais evidências deveriam existir agora?”


Capítulo XIII — Bayes também sabe dizer “eu estava errado”

Essa é talvez a característica mais valiosa.

O profissional ruim se apaixona pela primeira hipótese.

O profissional bom permite que evidências destruam sua teoria.

Ele começa:

— Acho que é Db2.

Nova evidência:

DB2 NORMAL

Ele responde:

— Então não é.

Fim.

Não existe crise existencial.

Não existe defesa de honra.

Não existe:

— MAS EU TENHO 30 ANOS DE EXPERIÊNCIA!

Experiência deveria melhorar seus priors.

Não tornar suas hipóteses imunes à evidência.


Capítulo XIV — Confirmation bias: o inimigo mora no mesmo cérebro

Existe um perigo.

Quando acreditamos numa hipótese, começamos naturalmente a procurar evidências que a confirmem.

Sysprog:

— É aplicação.

Programador:

— É infraestrutura.

DBA:

— É rede.

Rede:

— É DNS.

DNS:

— Como sempre, ninguém lembra de mim até alguma coisa quebrar.

Cada equipe possui seus priors.

E seus preconceitos.

É por isso que investigação disciplinada pergunta:

O QUE CONFIRMARIA MINHA HIPÓTESE?

mas também:

O QUE A REFUTARIA?

Essa segunda pergunta salva horas.

Às vezes dias.


Capítulo XV — O incidente começa às 02h37

Agora vamos ao verdadeiro laboratório bayesiano:

a madrugada.

Telefone toca.

— Produção caiu.

Você abre o olho esquerdo.

— Tudo?

— Pagamentos.

Seu cérebro já começa.

Pergunta:

— Online ou batch?

— Online.

Atualização.

— Todos os canais?

— Só mobile.

Atualização.

— Web funciona?

— Sim.

Atualização.

— Houve mudança no mobile?

— Versão nova às 23h.

A probabilidade de:

IPL DO MAINFRAME

ser necessária neste momento é aproximadamente equivalente à probabilidade de um macaco escrever Hamlet antes do café esfriar.

Mesmo assim alguém inevitavelmente pergunta:

— Não seria melhor reiniciar tudo?

Não.

Volte para a cama.


Capítulo XVI — Incident response é uma árvore de hipóteses

Podemos imaginar:

                     INCIDENTE
                         |
        --------------------------------
        |              |               |
    APLICAÇÃO       INFRA           DADOS
        |              |               |
     código          CPU            inválido
     deploy          memória        faltando
     config          rede           duplicado
        |
   -------------
   |           |
mudança      bug antigo

Cada nova evidência corta galhos.

Isso é extraordinariamente parecido com algoritmos de busca.

Uma investigação eficiente evita visitar todos os nós.

Ela usa informação para podar a árvore.

O veterano não necessariamente conhece a resposta.

Conhece a ordem inteligente de investigação.


Capítulo XVII — A intuição do veterano não é mágica

Isso merece destaque.

Quando alguém trabalha durante décadas com:

  • milhares de jobs;

  • centenas de incidentes;

  • dezenas de migrações;

  • falhas absurdas;

  • mudanças ruins;

  • dados corrompidos;

  • problemas de performance;

começa a desenvolver reconhecimento de padrões.

Em psicologia cognitiva podemos chamar parte disso de pattern recognition.

No bar do CPD chamamos:

— Esse cheiro é de arquivo.

E frequentemente é.

O cérebro compara a situação atual com milhares de padrões armazenados.

Não realiza conscientemente uma equação.

Mas produz algo semelhante a:

JÁ VI ISSO
+
CONTEXTO ATUAL
=
HIPÓTESE FORTE

Capítulo XVIII — Mas experiência sem observabilidade vira folclore

Existe um perigo enorme.

Veterano:

— Toda vez que acontece isso é rede.

Pergunta:

— Quantas vezes?

— Sempre.

— Temos registro?

— Não.

— Métricas?

— Não.

— Incident database?

— Não.

— Evidência?

— Eu lembro.

Agora entramos numa dimensão perigosa.

Memória humana sofre:

  • viés de disponibilidade;

  • recência;

  • confirmação;

  • seleção;

  • esquecimento.

Precisamos transformar experiência em dados.

Por isso pós-mortem é importante.

Por isso histórico de incidentes importa.

Por isso conhecimento operacional deve ser registrado.

O melhor dos mundos combina:

EXPERIÊNCIA HUMANA
+
TELEMETRIA
+
HISTÓRICO
+
EVIDÊNCIA

Capítulo XIX — O CMDB pode ser uma máquina bayesiana

Imagine possuir histórico:

INCIDENTE 8231
Sintoma: S0C7
Causa: layout incompatível
Mudança anterior: COPYBOOK alterado

INCIDENTE 9102
Sintoma: S0C7
Causa: dado não numérico

INCIDENTE 10221
Sintoma: S0C7
Causa: integração enviando campo inválido

Depois chega incidente novo:

S0C7
+
COPYBOOK ALTERADO HOJE

Seu sistema poderia procurar casos semelhantes.

Agora experiência organizacional começa a virar memória operacional.

Uma espécie de:

P(CAUSA | HISTÓRICO + EVIDÊNCIA ATUAL)

Isso já aponta para aplicações modernas de IA em operações.


Capítulo XX — AIOps: o sysprog bayesiano virou software?

Em certo sentido, muitas ferramentas modernas de observabilidade e AIOps tentam fazer justamente aquilo que um excelente operador humano sempre fez:

  1. observar sinais;

  2. correlacionar eventos;

  3. detectar anomalias;

  4. procurar padrões históricos;

  5. priorizar hipóteses;

  6. sugerir causas.

A diferença está na escala.

Um humano consegue acompanhar determinados sistemas.

Uma grande organização produz milhões de eventos.

Então surgem sistemas tentando responder:

“Dado este conjunto de sinais, qual causa parece mais provável?”

Soa familiar?

Nosso velho Bayes está sorrindo no fundo da sala.


Capítulo XXI — E o LLM entra novamente

Nosso artigo anterior mostrou:

P(próximo token | contexto)

Agora troubleshooting pergunta:

P(causa | sintomas e evidências)

Perceba a semelhança estrutural.

Não estamos dizendo que troubleshooting e LLM são a mesma coisa.

Não são.

Mas ambos demonstram algo profundo:

contexto transforma probabilidades.

Sem contexto:

S0C7

Com contexto:

S0C7
+
COMPUTE
+
CAMPO PACKED
+
ARQUIVO ALTERADO
+
PROBLEMA COMEÇOU HOJE

Outra história.


Capítulo XXII — O prompt perfeito para um incidente

Imagine pedir ajuda a uma IA:

Meu COBOL deu erro. Ajude.

Universo gigantesco.

Agora:

Programa Enterprise COBOL em z/OS.
Batch.
Abend S0C7.
O PSW aponta para um COMPUTE.
Campo de entrada é PIC S9(7)V99 COMP-3.
O arquivo upstream mudou ontem.
O dump mostra bytes incompatíveis com packed decimal.

Você praticamente realizou o trabalho bayesiano antes mesmo da pergunta.

Reduziu a incerteza.

Essa é uma das regras de ouro ao trabalhar com humanos ou IA:

não peça respostas melhores; forneça evidências melhores.


Capítulo XXIII — Easter egg: o Ministério das Causas Prováveis

Em algum prédio governamental britânico existe:

MINISTRY OF PROBABLE ROOT CAUSES

Você entra.

— Estou com S0C7.

Funcionário:

— Formulário?

— Qual?

— Solicitação de hipótese.

— Quero descobrir a causa.

— Antes precisa declarar a causa provável.

— Mas se soubesse a causa não estaria aqui.

— Exatamente.

— Então como preencho?

— Pode solicitar uma hipótese provisória.

— Onde?

— Departamento de Evidências.

— Onde fica?

— Só podemos fornecer essa informação mediante evidência de que você já sabe onde fica.

Thomas Bayes abandona o prédio.

Nunca mais volta.


Capítulo XXIV — Não confunda correlação com causa

Sistema caiu às 14h03.

Deploy ocorreu às 14h00.

Conclusão:

— FOI O DEPLOY!

Calma.

A proximidade temporal aumenta a probabilidade.

Não prova causalidade.

Talvez:

  • uma carga também tenha começado;

  • certificado tenha expirado;

  • algum recurso tenha atingido limite;

  • outro sistema tenha falhado.

Bayes permite:

DEPLOY RECENTE
→ HIPÓTESE SOBE

mas não:

DEPLOY RECENTE
→ CULPADO CONDENADO

Precisamos continuar coletando evidências.


Capítulo XXV — O valor negativo da evidência

Algo que não aconteceu também informa.

Se esperamos que um problema de rede provoque múltiplos serviços afetados, mas apenas uma determinada função falha, isso reduz a força dessa hipótese.

Ausência de sintomas pode ser evidência.

Exemplo:

Hipótese:

CPU SATURADA

Mas RMF mostra:

CPU 32%

Hipótese perde peso.

Hipótese:

DB2 LENTO

Mas todas as queries respondem normalmente exceto uma.

Talvez não seja “Db2 lento”.

Talvez seja:

UMA QUERY RUIM

Toda investigação deveria perguntar:

o que eu deveria estar vendo caso minha teoria fosse verdadeira?


Capítulo XXVI — O poder extraordinário da linha do tempo

Uma das ferramentas mais poderosas de qualquer incidente é extremamente simples:

13:42 deploy iniciado
13:48 deploy finalizado
13:51 primeira mensagem XYZ
13:52 erros começam
13:54 throughput cai
14:01 chamados de usuários

Uma timeline cria relações.

Sem timeline:

UM MONTE DE COISAS ACONTECEU.

Com timeline:

EVENTO A
↓
EVENTO B
↓
SINTOMA C

Não prova automaticamente causalidade.

Mas reorganiza probabilidades brutalmente.

Por isso perguntar:

“quando exatamente começou?”

é uma das armas mais poderosas da engenharia.


Capítulo XXVII — O S0C7 encontra Occam

Outra ideia útil:

quando várias hipóteses explicam os mesmos fatos, normalmente começamos pela mais simples ou pela que requer menos suposições extras.

Não porque o Universo prometa simplicidade.

Ele não promete nada.

Mas porque investigar hipóteses simples e comuns primeiro costuma ser eficiente.

S0C7 depois de alteração de layout.

Possibilidade A:

O arquivo começou a fornecer caracteres não numéricos.

Possibilidade B:

Uma partícula cósmica atravessou o processador, alterou memória exatamente naquele campo e desapareceu deixando nenhuma outra evidência.

Fisicamente talvez B não seja absolutamente impossível.

Mas começaremos por A.

O macaco infinito teria orgulho da B.

Produção não.


Capítulo XXVIII — Base rate: cavalos antes de zebras

Outro princípio importantíssimo.

Quando ouvimos cascos:

pense primeiro em cavalos.

Não zebras.

Em troubleshooting:

comece pelas causas frequentes compatíveis com as evidências.

Isso evita passar quatro horas investigando uma condição extremamente rara enquanto o arquivo possui simplesmente:

00012A45

O veterano parece rápido porque já conhece os base rates.

Sabe o que costuma quebrar.

Isso não significa ignorar coisas raras.

Significa investigar numa ordem economicamente inteligente.


Capítulo XXIX — O novato pergunta “qual é a causa?”

O veterano pergunta:

“qual é a próxima evidência mais barata que pode separar minhas hipóteses?”

Essa pergunta vale ouro.

Temos duas hipóteses:

A = DADO INVÁLIDO
B = STORAGE OVERWRITE

Qual teste é mais simples?

Talvez olhar os bytes do campo no dump.

Se estão inválidos já na entrada:

A sobe muito.

Se estavam corretos e depois aparecem corrompidos:

B sobe.

Investigue primeiro aquilo que possui:

  • baixo custo;

  • alta capacidade discriminatória;

  • baixo risco.

Isso é troubleshooting eficiente.


Capítulo XXX — Reiniciar é uma evidência terrível

Alguém reinicia.

Problema some.

Conclusão:

— Era memória.

Não necessariamente.

O restart alterou dezenas de condições simultaneamente:

  • memória;

  • conexões;

  • filas;

  • locks;

  • caches;

  • processos;

  • sessões;

  • timers.

Portanto ele possui baixo poder discriminatório.

Sabemos:

ESTADO ANTERIOR → PROBLEMA
ESTADO NOVO → SEM PROBLEMA

Mas não sabemos qual diferença foi causal.

Restart é poderoso operacionalmente.

Diagnosticar com ele é frequentemente horrível.


Capítulo XXXI — Nunca desperdice um incidente

Quando corrigimos e simplesmente fechamos:

RESOLVIDO.

perdemos aprendizado.

O fechamento deveria registrar:

SINTOMA
CAUSA
EVIDÊNCIAS
TIMELINE
MUDANÇA RELACIONADA
COMO CONFIRMAMOS
AÇÃO CORRETIVA
COMO DETECTAR MAIS RÁPIDO

Por quê?

Porque estamos construindo os priors da organização.

O incidente de hoje melhora a investigação de amanhã.

Esse é o verdadeiro valor do conhecimento operacional.


Capítulo XXXII — Runbook não deve ser livro de receitas

Runbook ruim:

SE S0C7:
1. REINICIAR
2. TENTAR NOVAMENTE
3. CHAMAR FULANO

Runbook bom:

S0C7

1. Identifique instrução e offset.
2. Determine quais operandos participam.
3. Inspecione representação dos dados.
4. Confirme origem dos campos.
5. Verifique alterações recentes.
6. Compare com layout esperado.
7. Reproduza com input específico.
8. Confirme causa antes da correção.

O segundo ensina investigação.

O primeiro ensina ritual.

Sistemas complexos precisam de raciocínio, não pajelança tecnológica.


Capítulo XXXIII — Quando experiência vira arrogância

Existe uma frase terrível:

“Eu sei o que é.”

Talvez saiba.

Mas a versão profissional é:

“Minha hipótese principal é X porque A, B e C. Vou verificar D para confirmar.”

Veja a diferença.

A primeira encerra investigação.

A segunda cria um teste.

Veteranos realmente bons possuem confiança sem abandonar falsificabilidade.

Eles sabem que experiência melhora probabilidade.

Não concede infalibilidade.


Capítulo XXXIV — O aprendiz pode acelerar décadas de experiência

Aqui existe uma boa notícia.

Você não precisa viver quarenta anos para começar a pensar assim.

Pode criar deliberadamente hábitos bayesianos.

Ao receber um incidente, escreva:

HIPÓTESE 1
HIPÓTESE 2
HIPÓTESE 3

Depois:

EVIDÊNCIA QUE CONFIRMA
EVIDÊNCIA QUE REFUTA

Em seguida pergunte:

QUAL TESTE SEPARA MELHOR ESSAS HIPÓTESES?

Faça isso repetidamente.

Após meses, começa a ficar natural.

Depois de anos:

alguém mostra S0C7.

Você pede café.

E pergunta:

— Mudaram o arquivo ontem?

A metamorfose está completa.


Capítulo XXXV — O Sysprog Bayesiano nasce

Nosso jovem programador finalmente volta ao incidente original.

Temos:

ABEND S0C7

A instrução é:

COMPUTE WS-TOTAL =
        WS-VALOR * WS-QUANTIDADE

Descobrimos:

WS-VALOR = bytes inválidos

A origem:

arquivo upstream

Alteração:

COPYBOOK MODIFICADO ONTEM

Investigação do arquivo mostra:

o produtor passou a gerar determinado campo com nova definição.

O consumidor continuou interpretando o layout antigo.

Pronto.

Causa encontrada.

Não tivemos magia.

Tivemos:

SINTOMA
+
HISTÓRICO
+
HIPÓTESES
+
EVIDÊNCIA
+
ATUALIZAÇÃO
+
CONFIRMAÇÃO

Thomas Bayes acabaria de receber acesso ao RACF.


Epílogo — O velho homem e o dump

Alguns anos depois, aquele programador iniciante está numa sala com outro novato.

O monitor mostra:

S0C7

O jovem pergunta assustado:

— O que pode ser?

Nosso antigo iniciante pega café.

Observa o horário.

Pergunta:

— Quando começou?

— Hoje.

— Mudaram alguma coisa?

— Um arquivo upstream.

Ele sorri.

— Mostra o layout.

O novato pergunta:

— Como você sabia?

Ele pensa por alguns segundos.

Poderia explicar:

prior probabilities.

Likelihood.

Posterior.

Base rate.

Conditional probability.

Entropia.

Information gain.

Pattern recognition.

Observabilidade.

Décadas de incidentes.

Mas responde apenas:

— Experiência.

No fundo da sala, Thomas Bayes derruba a cabeça sobre a mesa.

Porque aquela palavra simples esconde uma máquina extraordinariamente sofisticada.

O cérebro do veterano não possui certeza.

Possui probabilidades bem calibradas.

Ele não conhece todas as causas.

Aprendeu quais causas procurar primeiro.

Ele não lê todas as linhas do dump.

Sabe quais linhas diminuem a incerteza.

Ele não testa todas as hipóteses.

Procura a evidência que elimina mais delas.

E talvez seja essa a verdadeira evolução da nossa trilogia.

O Macaco Infinito dizia:

TENTE TUDO.

O LLM dizia:

USE O CONTEXTO PARA DESCOBRIR
O QUE É MAIS PROVÁVEL.

O Sysprog Bayesiano responde:

USE A EVIDÊNCIA PARA ATUALIZAR
O QUE VOCÊ ACREDITA.

São três formas completamente diferentes de atravessar um universo de possibilidades.

O macaco depende de tempo infinito.

O modelo depende de padrões aprendidos.

O veterano depende de experiência, contexto e observabilidade.

E produção?

Produção não possui tempo infinito.

Produção possui SLA.

Às 03h17, o telefone toca.

— Caiu de novo.

O veterano olha o dashboard.

Depois pergunta:

— Mesmo erro?

— Não.

Ele toma um gole de café.

Apaga todas as hipóteses anteriores.

E começa novamente.

Porque existe uma última regra que todo verdadeiro Sysprog Bayesiano aprende:

a evidência de ontem melhora seu prior — mas nunca substitui a evidência de hoje.

☕🧙‍♂️🖥️

No console:

INCIDENT 004217 CLOSED
ROOT CAUSE CONFIRMED

Trinta segundos depois:

NEW INCIDENT 004218 OPEN

O veterano olha para a tela.

— Interessante.

O novato pergunta:

— Você já sabe o que é?

— Não.

— Então por que está sorrindo?

Ele pega a caneca.

— Porque já sei qual é a primeira pergunta.

E, em troubleshooting, às vezes isso vale mais que saber a resposta.

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