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

quinta-feira, 1 de outubro de 2026

🧪 O USUÁRIO QUE FAZ A EQUIPE MEXER NO MOTOR — QUANDO 35 ANOS DE PRODUÇÃO TRANSFORMAM UM COBOLZEIRO EM ANOMALY DETECTOR HUMANO

 
Bellacosa Mainframe e o limite de criação de imagem plus veruss free

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🧪 O USUÁRIO QUE FAZ A EQUIPE MEXER NO MOTOR — QUANDO 35 ANOS DE PRODUÇÃO TRANSFORMAM UM COBOLZEIRO EM ANOMALY DETECTOR HUMANO

Mainframe, COBOL, produção, baseline, observabilidade, weak signals, anomaly detection, stress testing, suporte, telemetria, experiência operacional — e o dia em que descobrimos que talvez o usuário mais inconveniente seja justamente aquele que encontra o problema antes do dashboard.



🎬 PRÓLOGO — “TEM ALGUMA COISA ERRADA AQUI”

São duas horas da manhã.

Nenhum alarme disparou.

Nenhum programa terminou com S0C7.

Nenhum operador telefonou.

Nenhuma aplicação caiu.

Nenhuma mensagem vermelha apareceu na tela.

O programador olha o SDSF.

Três segundos.

Talvez cinco.

E diz:

— Tem alguma coisa errada aqui.

O programador COBOL iniciante olha para a mesma tela.

Jobs executando.

RC=0000.

Filas aparentemente normais.

CPU sem nenhuma explosão evidente.

Nenhum desastre.

— Onde?

O veterano responde:

— Ainda não sei.

Parece magia.

Não é.

É algo muito mais interessante:

BASELINE HUMANO.

Depois de anos observando um sistema, nosso cérebro começa a construir uma representação daquilo que significa normal.

Não necessariamente através de fórmulas.

Nem sempre através de dashboards.

Muito menos através de inteligência artificial.

Às vezes é quase uma sensação:

“Essa tela não deveria estar assim.”

E talvez uma das coisas mais curiosas sobre trabalhar décadas com produção seja justamente essa transformação.

Você começa como:

USER

Depois vira:

POWER USER

Mais tarde:

TROUBLEMAKER

Até alguém perceber que talvez o nome correto seja:

ANOMALY DETECTOR

Coloque café na caneca.

Porque hoje não vamos falar apenas de COBOL.

Vamos falar sobre o momento em que usar demais um sistema deixa de ser abuso e começa a virar observabilidade.



🦖 CAPÍTULO 1 — PRIMEIRO: O QUE DIABOS É UM BASELINE?

Imagine um batch que roda todos os dias.

Durante meses:

JOBPAY01
START  02:00
END    02:12
RC=0000

Algumas vezes:

02:11
02:13
02:12
02:14

Nada extraordinário.

Seu cérebro aprende:

NORMAL ≈ 12 minutos

Um belo dia:

JOBPAY01
START  02:00
END    02:26
RC=0000

Tecnicamente:

SUCCESS

Operacionalmente:

🤨

Por quê?

Porque sucesso funcional e comportamento normal não são a mesma coisa.

O programa terminou.

Mas levou aproximadamente o dobro do tempo habitual.

Isso é um desvio do baseline.

Baseline é, simplificando, uma referência do comportamento esperado.

Pode envolver:

tempo
volume
frequência
CPU
I/O
memória
quantidade de registros
horário
sequência
latência
throughput
erros
usuários
transações

Um sistema moderno pode calcular isso matematicamente.

Mas operadores humanos também constroem baselines.

Depois de milhares de execuções você sabe que:

JOB A normalmente termina antes do JOB B
JOB C raramente fica esperando
JOB D costuma gerar determinado volume
TRANSACTION X não aparece de madrugada

Até que um dia:

JOB B terminou primeiro.

Nada quebrou.

Mas...

por quê?

Essa pergunta é o nascimento da investigação.



🧠 CAPÍTULO 2 — O CÉREBRO DO OPERADOR É UMA ENGINE DE DETECÇÃO

Existe algo fascinante em profissionais que trabalham muito tempo com determinado ambiente.

Eles começam a reconhecer padrões sem conscientemente enumerar todas as variáveis utilizadas.

Um mecânico experiente escuta um motor e diz:

— Esse ruído não está certo.

Um piloto percebe uma vibração.

Um médico experiente observa pequenas combinações de sinais.

Um DBA olha determinado comportamento de queries.

Um operador mainframe olha o SDSF.

Não significa que sejam infalíveis.

Muito pelo contrário.

Intuição precisa ser testada.

Mas existe um mecanismo poderoso funcionando:

MILHARES DE OBSERVAÇÕES
          ↓
RECONHECIMENTO DE PADRÕES
          ↓
BASELINE IMPLÍCITO
          ↓
DESVIO
          ↓
"ISSO ESTÁ ESTRANHO"

A experiência não fornece automaticamente a resposta.

Ela fornece algo talvez igualmente importante:

a pergunta.



⚠️ CAPÍTULO 3 — O GRANDE ERRO: ESPERAR O ABEND

Para o COBOLzeiro iniciante, problema frequentemente significa:

S0C7
S0C4
S806
RC=12

Natural.

São problemas explícitos.

O computador praticamente colocou uma placa:

DEU MERDA.

Obrigado, computador.

O problema mais interessante é aquele que termina:

RC=0000

e mesmo assim alguma coisa mudou.

Imagine um processamento:

ONTEM:
10.000.000 registros
12 minutos

HOJE:
10.100.000 registros
31 minutos

O volume cresceu 1%.

O tempo cresceu 158%.

Não houve falha.

Mas existe uma história esperando para ser investigada.

Talvez:

  • mudou o access path;
  • aumentou contenção;
  • houve alteração de índice;
  • outro workload competiu por recursos;
  • ocorreu mudança de WLM;
  • aumentou I/O;
  • algum componente intermediário passou a responder lentamente.

O importante é:

Ausência de erro não significa ausência de problema.



🔬 CAPÍTULO 4 — DO POWER USER AO DETECTOR DE ANOMALIAS

Agora saímos do CPD e entramos em qualquer plataforma digital.

Existe uma diferença enorme entre um usuário comum e alguém que utiliza intensivamente determinada funcionalidade.

Imagine:

Usuário A:
3 operações por semana

Usuário B:
300 operações por semana

Quem provavelmente encontrará primeiro:

  • inconsistências?
  • estados raros?
  • problemas de sessão?
  • limites inesperados?
  • degradações?
  • diferenças entre versões?

Provavelmente o usuário B.

Não necessariamente porque seja tecnicamente melhor.

Ele simplesmente possui uma amostra muito maior.

Em estatística existe uma ideia básica:

eventos raros precisam de oportunidades para aparecer.

Se um bug acontece uma vez a cada 1.000 operações, alguém que executa dez operações talvez nunca o encontre.

Quem executa milhares eventualmente encontrará.

Assim nasce uma criatura curiosa:

o power user como sensor de produção.


🧪 CAPÍTULO 5 — DIGITAL INNOVATION ONE: QUANDO O USUÁRIO COMEÇA A FAZER O MOTOR SE MEXER

Essa história não começou hoje.

Durante minha experiência na Digital Innovation One, comecei simplesmente utilizando intensamente a plataforma.

Curso.

Laboratório.

Comunidade.

Funcionalidade.

Outra funcionalidade.

Mais uma.

E naturalmente comecei a encontrar coisas.

Algumas pequenas.

Outras curiosas.

Outras mereciam investigação.

O processo começou a se repetir:

USO
 ↓
OBSERVAÇÃO
 ↓
ANOMALIA
 ↓
FEEDBACK
 ↓
INVESTIGAÇÃO
 ↓
AJUSTE

Depois de algum tempo, diferentes áreas começaram a reconhecer aquele padrão.

Vieram contatos.

Reconhecimento.

Brindes.

Camisetas — várias delas.

E até um simpático selo de amigo.

Mas a parte mais interessante não era a camiseta.

Era a reputação.

Algo próximo de:

“Esse é o sujeito que faz a gente mexer no motor.”

E, para alguém vindo de produção, isso é praticamente uma medalha.

Porque mexer na pintura é fácil.

Mexer no motor significa:

alguma coisa aconteceu
        ↓
não parece cosmética
        ↓
precisamos investigar internamente

🤖 CAPÍTULO 6 — E ENTÃO O CHATGPT ENTROU NO LABORATÓRIO

Anos depois aparece outra plataforma.

ChatGPT.

Uso normal?

Claro que não.

Começam artigos.

Depois imagens.

Depois capas.

Depois infográficos.

Depois sequências inteiras de produção.

Em determinado momento o uso deixa de representar:

"Faça uma imagem de um gato."

e vira:

CAPA
INFOGRÁFICO 1
INFOGRÁFICO 2
INFOGRÁFICO 3
INFOGRÁFICO 4
...

Estamos novamente nas bordas do sistema.

E bordas são lugares interessantes.

Porque sistemas normalmente são testados para caminhos esperados.

Power users exploram combinações que talvez poucos usuários executem repetidamente.

Até que um dia:

IMAGE GENERATION LIMIT

Tudo bem.

Serviços possuem limites.

Só que surge aquela sensação antiga do SDSF:

“Espera... isso está diferente.”

A investigação começa.


🕵️ CAPÍTULO 7 — RECLAMAR É DIFERENTE DE INVESTIGAR

Existem duas mensagens possíveis.

A primeira:

QUE PORCARIA!
NÃO FUNCIONA!

Compreensível.

Mas tecnicamente pouco útil.

A segunda:

EXPECTED:
comportamento histórico X

OBSERVED:
comportamento Y

ENVIRONMENT:
Plus / Web / Windows

APPROXIMATE VOLUME:
38 gerações

TIMESTAMP:
registrado

RESULT:
bloqueio

RESET:
aproximadamente 20 horas

Agora temos algo diferente.

Temos um incident report rudimentar.

Depois adicionamos uma segunda observação.

Outra conta.

Outro plano.

Outro comportamento.

Ainda não podemos concluir causalidade.

Mas podemos formular hipóteses.

Isso é importantíssimo:

OBSERVAÇÃO
≠
CONCLUSÃO

O investigador responsável diz:

“Observei isto.”

Não:

“Portanto certamente aquilo aconteceu.”


📊 CAPÍTULO 8 — OBSERVABILIDADE NÃO É APENAS DASHBOARD BONITO

Hoje todo mundo gosta da palavra:

OBSERVABILITY.

Logs.

Metrics.

Traces.

OpenTelemetry.

Dashboards maravilhosos.

Gráficos piscando.

Mas observabilidade possui uma ideia muito mais profunda:

conseguir inferir o estado interno de um sistema através daquilo que ele expõe externamente.

Quando não temos acesso ao código de uma plataforma, fazemos algo parecido com ciência experimental.

Enviamos entrada.

Observamos saída.

INPUT
  ↓
BLACK BOX
  ↓
OUTPUT

Mudamos alguma variável.

INPUT'
   ↓
BLACK BOX
   ↓
OUTPUT'

Comparamos.

Foi exatamente o que aconteceu com a geração de imagens.

Não sabemos internamente:

quota?
token bucket?
rolling window?
dynamic capacity?
per-model limit?
per-tool limit?

Então observamos comportamento.

É uma espécie de:

observabilidade de caixa-preta.


🧮 CAPÍTULO 9 — O COBOLZEIRO DESCOBRE O ANOMALY DETECTION

Imagine um programa COBOL extremamente simplificado:

IF CURRENT-VALUE NOT = EXPECTED-VALUE
    DISPLAY 'ANOMALIA'
END-IF.

Funciona?

Às vezes.

Mas sistemas reais possuem variação.

Então precisamos pensar em tolerâncias.

NORMAL:
48
51
49
53
47
52

Se aparecer:

50

normal.

Se aparecer:

500

hmmm.

Só que existem anomalias mais sutis.

Talvez:

VOLUME NORMAL
+
HORÁRIO ESTRANHO
+
USUÁRIO INCOMUM
+
SEQUÊNCIA RARA

Nenhuma variável isolada é absurda.

A combinação é.

É exatamente o que sistemas modernos de anomaly detection tentam fazer.

O veterano de produção frequentemente faz isso intuitivamente.


🧬 CAPÍTULO 10 — WEAK SIGNALS: OS SUSSURROS ANTES DO DESASTRE

Grandes incidentes raramente começam com uma placa dizendo:

ATENÇÃO:
GRANDE INCIDENTE COMEÇARÁ EM 5 MINUTOS.

Frequentemente aparecem pequenos sinais.

Chamamos esses sinais fracos de:

weak signals.

Exemplo:

latência +4%
fila ligeiramente maior
retry ocasional
job terminando 2 minutos mais tarde
timeout raro

Separadamente:

meh.

Juntos:

🤨

Depois:

💥

O profissional experiente frequentemente percebe justamente a mudança de textura do sistema.

Ele não necessariamente sabe ainda a causa.

Mas percebe:

o sistema deixou de respirar como respirava ontem.


🧯 CAPÍTULO 11 — “EU SABIA!” NÃO VALE COMO ROOT CAUSE ANALYSIS

Aqui existe uma armadilha.

Experiência pode gerar excesso de confiança.

Você percebe uma anomalia e imediatamente conclui:

“É o banco.”

Talvez seja.

Talvez não.

Então precisamos separar:

INTUIÇÃO

de:

EVIDÊNCIA

A sequência saudável é:

INTUIÇÃO
   ↓
HIPÓTESE
   ↓
COLETA
   ↓
TESTE
   ↓
EVIDÊNCIA
   ↓
CONCLUSÃO

Nunca:

INTUIÇÃO
   ↓
CONCLUSÃO

Essa talvez seja a diferença entre veterano e palpiteiro.


🔁 CAPÍTULO 12 — REPRODUZIBILIDADE: FAÇA A ANOMALIA APARECER DE NOVO

Encontrou algo estranho?

Primeira pergunta:

Consigo reproduzir?

Imagine:

AÇÃO A → ERRO

Repita.

AÇÃO A → ERRO

Novamente.

AÇÃO A → ERRO

Interessante.

Agora altere uma variável:

AÇÃO A + CONDIÇÃO B → NORMAL

Estamos aprendendo.

É quase método científico.

OBSERVAÇÃO
 ↓
HIPÓTESE
 ↓
EXPERIMENTO
 ↓
RESULTADO
 ↓
NOVA HIPÓTESE

Um bom bug report praticamente é um pequeno paper científico.


🔧 CAPÍTULO 13 — “VOCÊ FAZ A GENTE MEXER NO MOTOR”

Essa expressão merece atenção.

Produto possui várias camadas.

Podemos imaginar:

INTERFACE
   ↓
APLICAÇÃO
   ↓
SERVIÇOS
   ↓
PLATAFORMA
   ↓
INFRAESTRUTURA
   ↓
MOTOR

Muitos problemas são superficiais.

Um botão desalinhado.

Um texto incorreto.

Uma cor.

Mas power users frequentemente encontram situações relacionadas a:

estado
concorrência
limites
sessão
cache
consistência
integração
capacidade

A equipe precisa descer.

Camada por camada.

Até alguém dizer:

“Precisamos olhar internamente.”

É aí que o usuário conseguiu fazer a equipe mexer no motor.


🦖 CAPÍTULO 14 — POR QUE MAINFRAME TREINA TÃO BEM ESSE INSTINTO?

Porque mainframe ensina uma coisa brutalmente útil:

produção não perdoa distração.

Um ambiente corporativo pode envolver:

milhões de transações
milhares de jobs
dependências
SLAs
bancos
mensageria
CICS
Db2
IMS
MQ
JES2
WLM
RACF

Você aprende rapidamente que:

"está funcionando"

não significa:

"está saudável"

Um CICS pode estar disponível e degradado.

Um Db2 pode responder e estar sofrendo.

Um job pode terminar e estar atrasando toda a cadeia.

Uma queue pode funcionar e crescer lentamente.

Produção ensina a observar tendências.


🧠 CAPÍTULO 15 — 35 ANOS NÃO DÃO SUPERPODERES; DÃO AMOSTRAS

Aqui está talvez a explicação mais simples.

Depois de 35 anos você viu:

normal
normal
normal
problema
normal
problema
normal
problema
...

Milhares de vezes.

Cada ocorrência alimenta uma biblioteca mental.

Quando aparece algo novo, seu cérebro compara:

CURRENT STATE
      ↓
HISTORICAL PATTERNS

É quase um nearest-neighbor biológico.

Não significa que o veterano esteja sempre certo.

Significa que possui muito material comparativo.

É experiência convertida em reconhecimento de padrões.


🤖 CAPÍTULO 16 — O HUMANO E A IA ESTÃO FAZENDO COISAS PARECIDAS?

Em certo nível abstrato, sim.

Um sistema de anomaly detection pode aprender uma representação do comportamento normal.

Depois observa algo novo.

Calcula distância.

NORMAL MODEL
     ↓
CURRENT EVENT
     ↓
DIFFERENCE
     ↓
ANOMALY SCORE

O operador faz algo conceitualmente parecido:

MEMÓRIA OPERACIONAL
       ↓
TELA ATUAL
       ↓
"ISSO ESTÁ ESTRANHO"

Mas existe uma diferença enorme.

O humano possui contexto.

Sabe que ontem houve fechamento mensal.

Sabe que determinado job foi alterado.

Sabe que aquela aplicação é esquisita desde 1998.

Sabe que o sujeito responsável está de férias.

Contexto muda interpretação.

É por isso que combinação humano + máquina pode ser tão poderosa.


📝 CAPÍTULO 17 — COMO ESCREVER UM BUG REPORT QUE NÃO VAI PARA O LIMBO

Quer fazer alguém mexer no motor?

Ajude a pessoa.

Não escreva apenas:

NÃO FUNCIONA.

Escreva:

ENVIRONMENT
Windows / Web / versão

EXPECTED
O que deveria acontecer

OBSERVED
O que aconteceu

TIMESTAMP
Quando

STEPS
Como reproduzir

FREQUENCY
Sempre? Às vezes?

IMPACT
O que impede

EVIDENCE
Print, log, mensagem

CONTROL TEST
Em outra conta/dispositivo funciona?

Isso muda completamente a conversa.

O suporte deixa de perguntar:

“Você tentou atualizar a página?”

e começa a ter material para escalonamento.


🧪 CAPÍTULO 18 — QUANDO O USUÁRIO VIRA STRESS TESTER NÃO CONTRATADO

Existe uma parte deliciosamente absurda nessa história.

A empresa possui:

QA
AUTOMATION
LOAD TEST
UNIT TEST
INTEGRATION TEST

E então aparece um usuário.

Café.

Madrugada.

Ideias demais.

E executa um fluxo que ninguém imaginou:

TEST 1
TEST 2
TEST 3
...
TEST 38

Sistema:

STOP.

Usuário:

INTERESSANTE...

Esse “interessante...” deveria assustar qualquer engenheiro. 😂

Porque significa que o usuário não simplesmente desistiu.

Ele pegou o caderninho.


🐒 CAPÍTULO 19 — OS CHIMPANZÉS DO LABORATÓRIO BELLACOSA

Todo laboratório sério precisa de equipe.

O Bellacosa Mainframe possui chimpanzés imaginários.

Quando algo estranho acontece:

🐒 CHIMPANZÉ 1:
reproduz

🐒 CHIMPANZÉ 2:
anota horário

🐒 CHIMPANZÉ 3:
compara ambiente

🐒 CHIMPANZÉ 4:
faz café

🐒 CHIMPANZÉ 5:
abre chamado

O quinto chimpanzé é particularmente perigoso.

Ele sabe inglês.


📈 CAPÍTULO 20 — MATURIDADE: DE “EU USO MUITO” PARA “EU CONHEÇO O COMPORTAMENTO”

Existe uma evolução interessante:

NOVATO
↓
USUÁRIO
↓
POWER USER
↓
ESPECIALISTA
↓
BASELINE HUMANO
↓
ANOMALY DETECTOR
↓
FEEDBACK LOOP

A diferença está na observação.

O power user não é valioso simplesmente porque clica muito.

É valioso quando transforma experiência em informação.


🔐 CAPÍTULO 21 — ISSO TAMBÉM É CYBERSECURITY

Agora conectamos com segurança.

Ataques sofisticados nem sempre provocam:

ACCESS DENIED

Talvez apareçam como:

SUCCESS
SUCCESS
SUCCESS
SUCCESS

Mas alguma coisa está diferente.

Horário.

Sequência.

Identidade.

Volume.

Destino.

É exatamente o mesmo raciocínio.

Segurança moderna pergunta:

Esse comportamento é permitido?

Mas também:

Esse comportamento é esperado?

Essa segunda pergunta é anomaly detection.


🔄 CAPÍTULO 22 — O FEEDBACK LOOP

O cenário ideal é:

USER
 ↓
OBSERVATION
 ↓
SUPPORT
 ↓
ENGINEERING
 ↓
FIX
 ↓
PRODUCT
 ↓
USER

Isso é um feedback loop.

Um usuário experiente pode se tornar parte valiosa desse ciclo.

Não porque possua acesso ao código.

Mas porque possui algo que o desenvolvedor frequentemente não possui:

experiência prolongada do produto em condições reais.


☕ CAPÍTULO 23 — O USUÁRIO INCÔMODO PODE SER UM PRESENTE

Naturalmente existe uma diferença entre feedback útil e simplesmente atormentar suporte.

Feedback útil possui:

contexto
respeito
evidência
reprodutibilidade
impacto

O objetivo não é:

“Peguei vocês!”

É:

“Encontrei algo que talvez vocês queiram entender.”

Quando isso funciona, nasce uma relação interessante.

A empresa passa a reconhecer determinado usuário como alguém que encontra bordas.

Foi assim que camisetas, brindes e reconhecimento na DIO acabaram simbolizando algo maior.

Não era apenas merchandising.

Era quase:

ACHIEVEMENT UNLOCKED

YOU MADE US OPEN THE HOOD.

🥚 EASTER EGG — O TICKET QUE NINGUÉM QUER RECEBER

03:17.

Um sistema interno recebe:

NEW SUPPORT CASE

Analisa remetente.

IF CUSTOMER = 'BELLACOSA'
    DISPLAY 'OH SHIT'
    MOVE 'ENGINEERING' TO NEXT-QUEUE
END-IF.

Na parede existe um retrato.

Abaixo:

ESTOU DE OLHO EM VOCÊS.

Um engenheiro olha.

— Ele encontrou outro bug?

Suporte responde:

— Pior.

— O quê?

— Ele tem timestamps.

Silêncio.


🎓 CAPÍTULO 24 — LIÇÕES PARA O PROGRAMADOR COBOL INICIANTE

Se você está começando agora, talvez pense que sua missão é apenas escrever programas que terminem com:

RC=0000

Não.

Aprenda também a observar sistemas.

Quando executar seu programa, pergunte:

  • quanto tempo levou?
  • quantos registros processou?
  • qual CPU consumiu?
  • quanto I/O realizou?
  • quais recursos acessou?
  • esse comportamento mudou?
  • qual era o baseline?
  • o que aconteceu antes?
  • o que aconteceu depois?

Não espere apenas pelo erro.

Procure a diferença.

Porque muitos dos problemas mais interessantes não gritam.

Eles sussurram.


🧬 CAPÍTULO 25 — O VERDADEIRO ANOMALY DETECTOR HUMANO

Depois de décadas, alguma coisa muda.

Você não olha mais uma tela vendo simplesmente:

JOB1
JOB2
JOB3
JOB4

Você vê relações.

Ritmos.

Sequências.

Ausências.

Desvios.

É como um maestro olhando uma orquestra.

Talvez ninguém tenha tocado uma nota errada.

Mas alguma coisa saiu do tempo.

E ele percebe.

Essa é provavelmente uma das competências menos documentadas de profissionais veteranos de produção:

conhecimento tácito operacional.

É difícil colocar num manual.

Mas possui enorme valor.


🎬 EPÍLOGO — O CARA QUE FAZ ELES MEXEREM NO MOTOR

Começou como usuário.

Depois virou power user.

Depois começou a encontrar coisas.

Depois começaram os reports.

Depois vieram perguntas.

Depois investigações.

Depois mudanças.

Até surgir aquela reputação maravilhosa:

“Esse é o cara que faz a gente mexer no motor.”

Talvez seja uma descrição melhor do que parece.

Porque tecnologia precisa de pessoas que construam.

Precisa de pessoas que operem.

Precisa de pessoas que testem.

Mas também precisa daquele sujeito inconveniente olhando para o painel e dizendo:

“Isso aqui não está igual ontem.”

Às vezes ele estará errado.

Ótimo.

Investigue.

Às vezes será apenas ruído.

Ótimo.

Documente.

Mas algumas vezes alguém abrirá o capô.

E descobrirá:

HOLY SHIT.

HE WAS RIGHT.

Trinta e cinco anos trabalhando com produção não transformam ninguém em vidente.

Transformam milhares de eventos em experiência.

Experiência vira baseline.

Baseline permite reconhecer desvios.

Desvios geram hipóteses.

Hipóteses produzem testes.

Testes produzem evidências.

E evidências fazem equipes mexerem no motor.

Portanto, nossa equação Bellacosa Mainframe fica:

35 ANOS DE PRODUÇÃO
        +
CURIOSIDADE
        +
USO INTENSIVO
        +
BASELINE
        +
WEAK SIGNALS
        +
"QUE PORRA É ESSA?"
        +
EVIDÊNCIA
        =
ANOMALY DETECTOR HUMANO

E existe uma última regra.

Talvez a mais importante.

Quando uma plataforma disser:

LIMIT REACHED.
TRY AGAIN IN 20 HOURS.

existem duas espécies de usuário.

A primeira responde:

OK.

A segunda olha para o relógio, anota o timestamp, conta quantas operações executou, compara com o histórico, testa outra condição e abre um chamado.

Essa segunda criatura é particularmente perigosa.

Porque ela não está apenas usando o sistema.

ELA ESTÁ OBSERVANDO O SISTEMA USÁ-LA DE VOLTA.

☕🦖 Bellacosa Mainframe — onde até uma reclamação pode terminar em observabilidade, anomaly detection e um PERFORM INVESTIGATE UNTIL MORNING.

sexta-feira, 1 de maio de 2026

🚨💥 LAB CICS: “A TASK QUE PAROU A EMPRESA” — DO CAOS À RECUPERAÇÃO 💥🚨

 

Bellacosa Mainframe desafio LAB C|ICS

🚨💥 LAB CICS: “A TASK QUE PAROU A EMPRESA” — DO CAOS À RECUPERAÇÃO 💥🚨

🎬 🎯 CENÁRIO

📍 Ambiente: Produção
📍 Região: CICS01
📍 Horário: 10:17 (pico)
📍 Sintoma:

  • Usuários travados
  • Tempo de resposta absurdo
  • CPU subindo
  • Reclamação geral 😄

👉 Clássico incidente crítico.


🧠🔥 FASE 1 — DETECÇÃO (O ALERTA)

🔎 Primeira ação: ver mensagens

CEMT I SYS

👉 Você percebe:

  • Tasks acumulando
  • Sistema lento

Agora vá direto ao log:

CEBR CSMT

💣 Você encontra:

DFHAC2001 TRANSACTION PAY1 ABENDED WITH CODE ASRA

👉 Tradução:

  • Programa quebrando (provável S0C4)
  • Pode estar em loop/restart

🕵️‍♂️ FASE 2 — IDENTIFICAR O PROBLEMA

🔍 Listar tasks:

CEMT I TASK

🔥 Saída suspeita:

Tas(000345) Tra(PAY1) Use(APPUSR) Sta(RUN)
Tas(000346) Tra(PAY1) Use(APPUSR) Sta(RUN)
Tas(000347) Tra(PAY1) Use(APPUSR) Sta(RUN)

👉 ALERTA:

  • Mesma transação
  • Mesmo user
  • Muitas instâncias
  • Todas rodando

💡 Possível cenário:

  • Loop
  • Deadlock
  • Programa bugado

🎯 Filtro cirúrgico:

CEMT I TASK TRA(PAY1)

👉 Resultado:

  • 30+ tasks abertas 😄

Agora ficou sério.


📊⚡ FASE 3 — ANÁLISE DE CONSUMO

🔎 Ver comportamento:

CEMT I TASK TAS(345)

👉 Observe:

  • CPU TIME alto
  • STATUS RUNNING contínuo
  • Sem I/O

👉 Isso é clássico:

🔥 LOOP CPU (runaway task)


🧬 FASE 4 — INVESTIGAÇÃO PROFUNDA (DUMP)

Agora você quer prova técnica.

💥 Gerar dump:

CEMT SET TRD(PAY1) DUMP

ou automático via abend


🧠 Análise do dump:

Ferramentas:

  • IBM IPCS
  • IBM Fault Analyzer

🔎 Você encontra:

  • Loop em programa COBOL
  • Parágrafo sem EXIT 😄
  • Variável nunca alterada

👉 Bingo.


☠️💣 FASE 5 — CONTENÇÃO (AÇÃO IMEDIATA)

Agora você precisa salvar o ambiente.

💥 Derrubar tasks:

CEMT SET TASK(345) PURGE

Se resistir:

CEMT SET TASK(345) FORCEPURGE

👉 Repita para as demais:

CEMT I TASK TRA(PAY1)

🚫 Bloquear entrada da transação:

CEMT SET TRAN(PAY1) DISABLED

👉 Isso evita novas execuções


🧯 FASE 6 — ESTABILIZAÇÃO

Agora observe:

CEMT I SYS

👉 Esperado:

  • CPU normalizando
  • Tasks reduzindo
  • Sistema respondendo

💡 Se não normalizar:

  • Ver DB2 locks
  • Ver filas MQ
  • Ver storage

🔧 FASE 7 — CORREÇÃO DEFINITIVA

Agora vem o pós-incidente.

📌 Ações:

  • Corrigir programa COBOL
  • Revisar lógica de loop
  • Adicionar timeout/escape
  • Validar com QA

🧠💡 FASE 8 — LIÇÕES DE OURO

👉 Sempre monitore:

  • Transações com crescimento rápido
  • CPU anormal
  • Tasks duplicadas

👉 Crie alertas para:

  • ASRA recorrente
  • Volume de tasks
  • Tempo de resposta

🧩😄 EASTER EGGS DO LAB

  • “Toda FORCEPURGE tem história”
  • “Loop em COBOL sempre aparece na sexta”
  • “Se tem ASRA em massa… prepara café” ☕

🧪🎯 QUIZ — NÍVEL OPERADOR / SYSPROG

1️⃣ O que indica muitas tasks RUNNING com CPU alto?

A) I/O intenso
B) Loop CPU
C) Problema de rede
D) Storage baixo

👉 Resposta: B


2️⃣ Comando para ver tasks:

A) CEDF
B) CEMT I TASK
C) CICS LIST
D) DISPLAY TASK

👉 Resposta: B


3️⃣ Diferença entre PURGE e FORCEPURGE?

A) Nenhuma
B) FORCEPURGE força finalização imediata
C) PURGE é mais agressivo
D) PURGE mata região

👉 Resposta: B


4️⃣ O que é ASRA?

A) Timeout
B) Falha lógica COBOL
C) Erro de storage/execução
D) Deadlock

👉 Resposta: C


5️⃣ Melhor ação inicial?

A) Reiniciar CICS
B) Derrubar tudo
C) Analisar tasks e logs
D) Ignorar

👉 Resposta: C


🎯💬 FECHAMENTO ESTILO BELLOCAZZA

Ser SysProg de CICS não é saber comando.

É:

  • ler comportamento
  • antecipar desastre
  • agir rápido
  • e salvar produção sem pânico

👉 Porque no mundo real:

“Uma única task errada… pode derrubar milhares de usuários.”

 

quarta-feira, 29 de abril de 2026

🚀💥 CICS: O “CONTROLADOR DE TRÁFEGO” DO MAINFRAME — ONDE TASKS NASCEM, EXECUTAM… E ÀS VEZES PRECISAM SER ELIMINADAS 💥🚀

 

Bellacosa Mainframe CICS para Sysprogs

🚀💥 CICS: O “CONTROLADOR DE TRÁFEGO” DO MAINFRAME — ONDE TASKS NASCEM, EXECUTAM… E ÀS VEZES PRECISAM SER ELIMINADAS 💥🚀

Se você é SysProg raiz, sabe: o IBM CICS não é só um subsistema — é um organismo vivo.
Milhares de transações pulsando por segundo, usuários conectados, filas, locks, DB2, MQ… e no meio disso tudo: você, com a responsabilidade de manter tudo fluindo.

Aqui vai um guia no estilo “mão na massa + café forte” pra dominar o gerenciamento do CICS no dia a dia.


🧠🔥 VISÃO MENTAL DO CICS (ANTES DE OPERAR)

Pense no CICS como:

  • Dispatcher → controla quem executa
  • Tasks (TCA) → unidades de trabalho
  • Terminal/User → origem da transação
  • Programs → lógica (COBOL, PL/I…)
  • Resources → VSAM, DB2, MQ

👉 Cada ENTER do usuário vira uma task
👉 Cada task consome CPU, storage e locks
👉 E sim… algumas tasks travam tudo 😄


🕵️‍♂️🔍 1. VENDO LOGS COMO UM DETETIVE

No CICS, erro nunca vem sozinho. Ele deixa rastro.

📌 Principais logs:

  • CSMT → mensagens gerais
  • CSM1 → log auxiliar
  • Transient Data Queue (TDQ) → logs customizados
  • SMF 110 → performance e auditoria

🔎 Exemplo clássico:

DFHAC2001 TRANSACTION ABCD ABENDED WITH CODE ASRA

👉 Tradução Bellacosa:

“Alguém fez besteira no programa — provavelmente S0C4 disfarçado” 😄


👤🆔 2. IDENTIFICANDO USER E TASK EM TEMPO REAL

Aqui começa o jogo de verdade.

📌 Transação chave:

CEMT I TASK

Isso mostra:

  • Task Number
  • Transaction ID
  • UserID
  • Status (RUNNING, WAITING…)
  • CPU Time

🔥 Exemplo:

Tas(000123) Tra(ABCD) Use(USER01) Sta(RUN)

👉 Você já sabe:

  • Quem → USER01
  • O quê → ABCD
  • Qual → Task 123

💡 Dica de ouro:

CEMT I TASK USE(USER01)

👉 Filtra direto no usuário (perfeito pra incidentes)


☠️💣 3. DERRUBANDO TASK (QUANDO O CAOS CHEGA)

Quando uma task trava:

  • segura recurso
  • explode CPU
  • trava fila inteira

👉 Você entra com autoridade:

💥 Comando:

CEMT SET TASK(123) PURGE

⚠️ Versão nuclear:

CEMT SET TASK(123) FORCEPURGE

👉 Diferença:

  • PURGE → educado
  • FORCEPURGE → “sai ou eu te mato” 😄

💡 Cuidado:

  • Pode deixar dados inconsistentes
  • Use quando não há alternativa

📊⚡ 4. MONITORANDO PERFORMANCE E CONSUMO

Aqui mora o SysProg de elite.

📌 Transações importantes:

  • CEMT I SYS → visão geral
  • CEMT I TASK → consumo por task
  • CEMT I TRAN → estatísticas de transação

🔎 Indicadores críticos:

  • CPU time alto
  • Tasks WAITING (lock?)
  • Storage crescente
  • Response time degradando

🧠 Dica avançada (nível hard):

Use SMF 110 + ferramentas como:

  • IBM OMEGAMON
  • IBM RMF

👉 Isso revela:

  • Top consumidores
  • Gargalos invisíveis
  • Tendência de carga

🛠️📋 5. CHECKLIST DE SOBREVIVÊNCIA DO SYSPROG CICS

Quando der problema, siga isso:

✅ Passo a passo real:

  1. Ver logs (CSMT)
  2. Identificar erro (abend?)
  3. Listar tasks

    CEMT I TASK
  4. Filtrar usuário/transação
  5. Ver consumo
  6. Decidir ação
    • aguardar
    • PURGE
    • FORCEPURGE
  7. Validar impacto
  8. Registrar ocorrência

🧩💡 EASTER EGGS DE QUEM VIVE CICS

👉 😄 “Toda ASRA tem uma história triste por trás”
👉 😄 “Se precisa dar FORCEPURGE… alguém fez deploy na sexta”
👉 😄 “Task WAITING sem motivo = lock escondido no DB2”


🏛️📜 CURIOSIDADES QUE POUCA GENTE SABE

  • O IBM CICS nasceu nos anos 60 (!!)
  • Ainda hoje processa bilhões de transações/dia
  • Grande parte dos caixas eletrônicos do mundo passam por ele
  • Ele é um dos sistemas mais resilientes já criados

🎯💬 COMENTÁRIO FINAL (NA VEIA)

Gerenciar CICS não é rodar comando.

É:

  • entender comportamento
  • prever problema
  • agir rápido
  • e às vezes… tomar decisões duras

👉 Porque no fim do dia:

“CICS parado não é sistema fora — é empresa parada.”

 

segunda-feira, 27 de abril de 2026

🔥💣 RAG NÃO SOBE JOB: O DIA EM QUE A IA QUEBROU O MAINFRAME (E NINGUÉM SABIA POR QUÊ) 💣🔥

 

Bellacosa Mainframe e os perigos da IA

🔥💣 RAG NÃO SOBE JOB: O DIA EM QUE A IA QUEBROU O MAINFRAME (E NINGUÉM SABIA POR QUÊ) 💣🔥

Um guia definitivo — raiz, sem filtro e sem buzzword — para quem quer usar IA no mundo COBOL sem destruir produção


Se você está entrando agora no mundo do mainframe — ou pior, se já está nele e alguém apareceu com um PowerPoint prometendo “modernização com IA em 3 meses” — este artigo é o seu firewall mental.

Porque aqui vai a verdade que ninguém coloca no slide:

💣 Mainframe não é código. É execução.

E execução tem história, dependência, tempo, estado… e consequências.


🧠⚙️ FUNDAMENTO: O QUE OS “PADAWANS COBOL” PRECISAM ENTENDER

Antes de falar de IA, RAG ou qualquer buzzword, você precisa internalizar isso:

🏦 O ecossistema real do z/OS

  • COBOL → lógica de negócio
  • JCL (Job Control Language) → orquestração
  • CICS → mundo transacional online
  • VSAM → armazenamento estruturado crítico
  • Db2 → consistência e persistência
  • Scheduler (Control-M, CA-7) → o “tempo” do sistema

👉 Isso forma um grafo de execução vivo.

Não é um repositório. Não é um projeto.
É um organismo.


💣🔥 O PECADO ORIGINAL: “CÓDIGO É SÓ TEXTO”

Ferramentas modernas tratam código assim:

função → entrada → saída

Mas no mainframe:

JCL → dataset → SORT → VSAM → COBOL → CICS → Db2 → JOB seguinte

💥 Isso é um pipeline físico e temporal.


🤖 O QUE É RAG (E POR QUE ELE TE TRAI)

RAG (Retrieval-Augmented Generation) faz:

  1. Quebra código em pedaços
  2. Vetoriza (transforma em embeddings)
  3. Busca por similaridade
  4. Responde com base nisso

👉 Funciona bem em:

  • APIs modernas
  • microserviços
  • código isolado

👉 Falha brutalmente em:

  • sistemas batch
  • fluxos dependentes
  • ambientes com estado externo

⚠️💣 EXEMPLO REAL — O ERRO QUE TODO MUNDO COMETE

🧾 Código COBOL:

READ CLIENTE-FILE
IF STATUS NOT = 'OK'
PERFORM ERRO
END-IF

🤖 IA (RAG) responde:

“Se falhar, chama rotina ERRO”

😈 Realidade:

  • O arquivo foi gerado por um SORT no JCL
  • O erro dispara um ABEND
  • O CICS intercepta
  • Um handler redireciona
  • O erro vai para Db2
  • Um job batch reconcilia depois

💣 Resultado:
A IA ignorou 80% do sistema.


⏱️💀 O FATOR TEMPO (O ASSASSINO SILENCIOSO)

Mainframe não é só lógica — é quando algo acontece.

Exemplo:

01:00 → JOB-A cria dataset
02:00 → JOB-B transforma
03:00 → COBOL processa

👉 Se o JOB-A falhar:

  • o COBOL continua existindo
  • mas o sistema quebra

💥 RAG não vê isso.


🕳️🔥 CICS: O BURACO NEGRO DA ANÁLISE

No mundo online:

  • Você NÃO chama programa diretamente
  • Existe:
    • definição de transação
    • routing
    • interceptação

👉 O fluxo real passa por camadas invisíveis ao código.

💣 Resultado:
A lógica está fora do COBOL.


🚨💣 RISCOS REAIS (NÃO TEÓRICOS)

1. 🔥 Decisão errada de negócio

IA responde incompleto → time muda código → quebra fluxo batch


2. 💥 Impacto invisível

Mudança em um programa:

  • quebra 3 jobs
  • afeta 2 sistemas downstream
  • só aparece às 3 da manhã

3. ⚠️ Compliance e auditoria

Sistema financeiro exige rastreabilidade
RAG não explica origem do dado


4. 🧨 Debug impossível

Erro não está no código
Está no fluxo


🐞💣 BUG CLÁSSICO DE QUEM USA IA ERRADO

“O programa não mudou, mas o resultado mudou”

👉 Motivo:

  • dataset diferente
  • ordem diferente
  • job anterior falhou

💥 IA não vê histórico → você caça fantasma


🧠💡 BOAS PRÁTICAS (OU COMO NÃO VIRAR INCIDENTE)

✅ 1. Modele o fluxo, não só o código

  • entenda JCL
  • entenda datasets
  • entenda ordem de execução

✅ 2. Pense em GRAFO, não em arquivos

  • quem chama quem
  • quem depende de quem
  • quem produz o quê

✅ 3. Trace o lineage dos dados

Pergunta chave:

“De onde veio esse dataset?”

Se você não sabe → risco crítico


✅ 4. Entenda o runtime

  • batch vs online
  • interceptações CICS
  • handlers

✅ 5. Use IA como apoio — não como verdade

IA ajuda, mas:

💣 não tem visão sistêmica por padrão


🛠️🔥 ARQUITETURA CORRETA (NÍVEL PROFISSIONAL)

Se quiser usar IA de verdade:

🧩 Combine:

  • Graph Database → dependências reais
  • Parser de JCL → fluxo batch
  • Parser CICS → fluxo online
  • Lineage de dados → origem real
  • Observabilidade → runtime

💡 Resultado:

Você responde perguntas como:

  • “Se eu mudar isso, o que quebra?”
  • “Qual job depende disso?”
  • “Qual dataset alimenta isso?”
  • “Qual fluxo gera esse erro?”

🧭💣 PASSO A PASSO (CAMINHO CERTO)

🥇 Passo 1 — Mapear JCL

  • jobs
  • steps
  • datasets

🥈 Passo 2 — Mapear programas COBOL

  • entradas
  • saídas
  • chamadas

🥉 Passo 3 — Mapear CICS

  • transações
  • programas
  • routing

🏅 Passo 4 — Construir grafo

  • dependência real
  • fluxo completo

🎯 Passo 5 — Só então usar IA

  • enriquecimento
  • análise
  • explicação

🧠📚 BASE TEÓRICA (SEM ISSO VOCÊ SOFRE)

Você precisa dominar:

  • Execução batch
  • Dependência temporal
  • Data lineage
  • Sistemas distribuídos (pré-cloud!)
  • Arquitetura orientada a eventos (sim, mainframe já fazia isso)

💣🔥 FRASES QUE VOCÊ NUNCA MAIS ESQUECE

💥 “COBOL não é o sistema. É só a interface da lógica.”

💥 “JCL é o diretor do filme — COBOL é o ator.”

💥 “Se você não entende o fluxo, você não entende o bug.”

💥 “IA sem contexto é só autocomplete caro.”


🚀💣 CONCLUSÃO (A VERDADE NUA)

A promessa de “jogar COBOL em vetor e entender tudo” é sedutora…

…mas perigosa.

Porque:

👉 Mainframe não é texto
👉 Mainframe é execução
👉 Execução tem tempo, estado e dependência

E isso NÃO cabe em embedding.


🧠🔥 MISSÃO PARA OS PADAWANS

Se você quer dominar isso de verdade:

  1. Leia JCL como se fosse código
  2. Siga o caminho do dado
  3. Pense em fluxo, não em linha
  4. Questione qualquer IA
  5. Nunca confie em resposta sem contexto

💣🔥 FINAL ESTILO RAIZ

Se sua IA não entende JCL…
ela não entende seu sistema.

E se ela não entende seu sistema…
ela não deveria chegar perto da produção.


.


🧠💡 O QUE É RAG?

RAG significa:

Retrieval-Augmented Generation
(Geração aumentada por recuperação)

👉 Em português simples:

💬 Uma IA que responde usando informações buscadas em uma base de dados.


🔧 COMO FUNCIONA (VISÃO PRÁTICA)

O RAG segue esse fluxo:

1. 📚 Você fornece conteúdo

  • código
  • documentos
  • PDFs
  • base de conhecimento

2. 🧩 O sistema “quebra” tudo

Exemplo:

Programa COBOL → dividido em pedaços menores

3. 🔢 Vetorização

Cada pedaço vira um vetor (embedding):

👉 uma representação matemática do texto


4. 🔍 Busca por similaridade

Quando você pergunta algo:

“Como funciona validação de conta?”

O sistema:

  • transforma sua pergunta em vetor
  • procura pedaços “parecidos”

5. 🤖 Geração da resposta

O modelo usa:

  • sua pergunta
    • os trechos encontrados

👉 para montar a resposta


💣 RESUMO EM UMA LINHA

RAG = IA + busca inteligente em conteúdo relevante


🔥 EXEMPLO SIMPLES

Você pergunta:

“Onde o cliente é validado?”

O RAG:

  • acha um trecho COBOL com IF CLIENTE-OK
  • retorna explicação baseada nisso

👉 Parece mágico… mas aqui começa o perigo.


⚠️💣 O PROBLEMA (PRINCIPAL)

RAG funciona baseado em:

🔎 similaridade de TEXTO

E NÃO em:

  • fluxo real
  • execução
  • dependência
  • contexto externo

🧠💥 ANALOGIA (FACILITA MUITO)

Imagine:

👉 Você lê páginas soltas de um livro
👉 e tenta entender a história inteira

💣 Isso é RAG.


🏦 NO MUNDO MODERNO

Funciona bem em:

  • documentação
  • APIs
  • microserviços
  • código recente

Porque:
👉 tudo está no próprio código


💀 NO MAINFRAME

Aqui ele sofre:

  • JCL controla execução
  • CICS controla fluxo
  • datasets vêm de outros jobs
  • lógica está espalhada

👉 O código sozinho NÃO conta a história


🔥 EXEMPLO REAL (DOR DE PRODUÇÃO)

Pergunta:

“O que acontece quando falha a validação?”

🤖 RAG responde:

  • lógica IF no COBOL

😈 Realidade:

  • erro interceptado no CICS
  • redirecionado
  • gravado no Db2
  • tratado em batch depois

💣 O RAG erra porque não vê o sistema inteiro


🧠💡 QUANDO USAR RAG

✅ Bom uso:

  • documentação técnica
  • FAQ
  • busca em código isolado
  • suporte a desenvolvedor

❌ Péssimo uso:

  • análise de sistemas complexos
  • dependência batch
  • impacto de mudança
  • fluxo mainframe

⚙️ RESUMO TÉCNICO (NÍVEL MAIS PROFUNDO)

RAG combina:

  • LLM (modelo de linguagem)
  • Vector Database
  • Busca semântica

👉 Ele NÃO entende execução
👉 Ele NÃO entende tempo
👉 Ele NÃO entende dependência real


💣🔥 FRASE PRA GUARDAR

RAG entende o que está escrito
mas não entende o que acontece


🚀 FECHAMENTO

RAG é poderoso — mas:

👉 é ferramenta de leitura
👉 não é ferramenta de entendimento sistêmico



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