Translate

segunda-feira, 23 de fevereiro de 2026

📘 50 Erros que Você Pode Capturar com IF em JCL

 

Bellacosa Mainframe apresenta 50 erros em processo batch e maneira de capturar via if /cond

Controle Condicional de Verdade no z/OS

Por Vagner Bellacosa — El Jefe Midnight Lunch

Salve jovem padawan a vida no mundo batch não é facil. Pensando nisso, seus problemas acabaram, parcialmente, no artigo de hoje, fiz um apanhado, peguei um saco de gatos, misturei com aquele tempero nosso. Coloquei algumas dicas de amarração com return cond, conds e ifs. em resultado apresento a você

Se você ainda usa IF em JCL apenas para testar RC > 8, você está usando uma Ferrari para ir até a padaria da esquina.

O IF/THEN/ELSE/ENDIF no z/OS é uma das ferramentas mais poderosas do processamento batch moderno. Ele permite capturar desde simples return codes até falhas estruturais complexas dentro de procedures.

Neste artigo, vou listar 50 situações reais de produção que podem ser tratadas com IF em JCL — com explicação prática, mentalidade de produção e visão arquitetural.

Prepare o café ☕ — vamos para o campo de batalha.

Seus problemas acabaram



🧠 Primeiro: O que o IF consegue testar?

O IF pode avaliar:

  • Return codes (RC)

  • ABENDs

  • ABENDs específicos

  • Steps executados ou não

  • Steps dentro de procedures

  • Condições combinadas (AND / OR)

  • Variáveis simbólicas

  • Fluxos aninhados (nested IF)

Agora vamos aos 50 cenários.


🔴 PARTE 1 — ABENDs Específicos (Sistema)

Captura via:

IF ABENDCC = Sxxx THEN
  1. S806 — Programa não encontrado (STEPLIB incorreto)

  2. S0C7 — Erro numérico COBOL (Data exception)

  3. S0C4 — Violação de memória

  4. S0C1 — Instrução inválida

  5. S913 — Falha de autorização RACF

  6. S878 — Falta de memória virtual

  7. S80A — Falta de storage abaixo da linha

  8. S837 — Falta de espaço em disco

  9. S522 — Timeout de CPU

  10. Uxxxx — User abend específico da aplicação

Uso típico: gerar dump, enviar notificação, disparar rollback.


🔴 PARTE 2 — Qualquer ABEND

IF ABEND THEN
  1. Capturar qualquer falha anormal

  2. Acionar rotina de recovery

  3. Enviar alerta para operações

  4. Forçar rollback

  5. Gerar log especial

O IF permite separar erro técnico de erro lógico (RC alto).


🔴 PARTE 3 — RC de Step Específico

IF STEP1.RC NE 0 THEN
  1. RC diferente de zero

  2. RC maior que 4 (warning elevado)

  3. RC igual a 4 (tratamento especial de warning)

  4. RC igual a 8

  5. RC igual a 12

  6. RC maior que 16

  7. RC entre 4 e 8

  8. RC fora da faixa esperada

  9. RC crítico mas sem abend

  10. RC inesperado para aquele step

Permite tratamento diferenciado por programa.


🔴 PARTE 4 — RC Global (último step executado)

IF (RC > 8) THEN
  1. Falha acumulada

  2. Erro lógico geral

  3. Inconsistência de processamento

  4. Validação negativa

  5. Resultado parcial não aceitável

Esse é o controle clássico de continuidade de fluxo.


🔴 PARTE 5 — Step Não Executado

IF ¬STEP1.RUN THEN
  1. Step bypassado por COND

  2. Step ignorado por IF anterior

  3. Step pulado por restart

  4. Step cancelado por lógica condicional

  5. Step não iniciado por erro estrutural

Excelente para auditoria e rastreabilidade.


🔴 PARTE 6 — Step Executado

IF STEP1.RUN THEN
  1. Confirmar execução de etapa crítica

  2. Validar dependência

  3. Garantir execução de PROC

  4. Verificar step condicional

  5. Auditoria de fluxo

Muito usado em ambientes com compliance.


🔴 PARTE 7 — Condições Combinadas (AND)

IF (RC > 4 & RC < 16) THEN
  1. Intervalo de erro médio

  2. Dupla condição obrigatória

  3. RC alto e step executado

  4. Falha parcial e dependência satisfeita

  5. Tratamento gradual por severidade

Controle refinado de severidade.


🔴 PARTE 8 — Condições Alternativas (OR)

IF (RC = 8 | RC = 12) THEN
  1. Dois códigos críticos específicos

  2. Warning ou erro leve

  3. Dois tipos diferentes de inconsistência

  4. Cenários alternativos aceitáveis

  5. Multi-falhas com mesma ação corretiva

Permite lógica flexível sem duplicar código.


🔥 EXTRA — Dentro de Procedures

IF STEP1.PROCSTEP.RC > 8 THEN

Controle granular dentro de PROCs reutilizáveis.

Ambiente corporativo pesado usa isso diariamente.


⚠ Limitações Importantes

  1. IF não executa após S122 ou S222 (cancelamentos externos).

  2. IF não roda se COND no JOB já tiver terminado o job.

  3. Todo IF precisa de ENDIF.

  4. RC final do job pode ser afetado por JOBRC.


🏛 Quando Usar IF em vez de COND?

CenárioMelhor escolhaLógica simplesCONDLógica estruturadaIFMúltiplos cenáriosIFControle de variável simbólicaIFClareza e manutençãoIF


🎯 Conclusão

O IF no JCL não é apenas um detalhe sintático.

Ele é:

  • Arquitetura de controle

  • Ferramenta de resiliência

  • Mecanismo de tratamento de falha

  • Base para automação robusta

  • Ponte entre aplicação e scheduler

Quem domina IF domina o fluxo batch.

EXEC STEP 
    │
    ▼
  ABEND ?
    │
    ├── S122/S222 → STOP
    │
    └── Outro ABEND
         │
         ├── Próximo STEP tem COND=EVEN ? → EXECUTA
         └── Senão → FLUSH
   │
   ▼
COND no JOB ?
   │
   ├── Verdadeiro → STOP JOB
   └── Falso → Continua
   │   
   ▼
  IF ?
   │
   ├── Verdadeiro → Executa bloco
   └── Falso → ELSE ou FLUSH
   │
   ▼
COND no EXEC ?
   │
   ├── Verdadeiro → FLUSH STEP
   └── Falso → Executa STEP

E no mundo mainframe, quem domina o fluxo… domina a produção.

🧠 Visual Mental Simplificado

ABEND crítico?
   ↓
COND JOB?
   ↓
IF?
   ↓
COND EXEC?
   ↓
Executa ou FLUSH
Esses abends me deixam louco

https://www.linkedin.com/pulse/50-erros-que-voc%C3%AA-pode-capturar-com-em-jcl-vagner-bellacosa-zqm8f




domingo, 22 de fevereiro de 2026

🔥 31 Bits?! O Bug que Virou Arquitetura: o Segredo Oculto do MVS que Quase Quebrou o Mainframe (e Salvou Tudo)

 

Bellacosa Mainframe explica os 31 bits de endereçamento de memoria no IBM MVS


🔥 “31 Bits?! O Bug que Virou Arquitetura: o Segredo Oculto do MVS que Quase Quebrou o Mainframe (e Salvou Tudo)”

Se você chegou até aqui, jovem padawan do aço e silício… prepare-se: essa não é só uma história técnica — é um daqueles momentos em que uma limitação virou genialidade.

Hoje você vai entender por que o MVS roda em 31 bits, mesmo em um mundo que já flertava com 32 bits — e como isso se conecta diretamente com compatibilidade, performance e… um bit que virou lenda. 🧠⚡


🧠 O Contexto: Quando 32 bits Ainda Era Ficção Científica Prática

Voltamos para os anos 70/80, época do OS/360 e da evolução para o MVS.

Naquele tempo:

  • 24 bits era o padrão (endereçamento até 16 MB 😱)
  • A IBM precisava evoluir
  • Mas não podia quebrar NADA do que já existia

💡 Tradução Bellacosa:

“Evoluir sem quebrar legado — o esporte olímpico do mainframe.”


⚙️ A Chegada dos 32 bits… com um Plot Twist

Quando a IBM decidiu expandir para 32 bits, veio o dilema:

👉 Como crescer sem destruir milhares de aplicações escritas para 24 bits?

A solução foi engenhosa e ousada:

➡️ Usar apenas 31 bits para endereço
➡️ E reservar 1 bit para controle


💥 O Bit 0: O Verdadeiro Protagonista

Aqui entra o easter egg mais clássico do mundo mainframe:

O bit mais significativo (bit 0) foi separado para indicar o modo de endereçamento.

📌 Resultado:

Bit 0Significado
0Endereço válido (modo 31 bits)
1Controle especial (ex: retorno de subrotina)

💡 Isso permitia:

  • Misturar código 24 bits com 31 bits
  • Manter compatibilidade TOTAL
  • Evitar crashes catastróficos

🧬 O Nascimento do “Modo 31”

O MVS passou a operar em algo híbrido:

  • 24-bit mode (legado)
  • 31-bit mode (expansão)

E isso foi formalizado em arquiteturas como:

👉 System/370-XA


🎮 Exemplo Prático (Estilo Raiz)

Imagine um programa chamando uma subrotina:

BALR R14,R15

O endereço de retorno fica no registrador com o bit 0 ligado (1).

🔍 Isso significa:

“Ei! Isso não é um endereço comum — é um ponteiro de controle!”

🔥 Resultado:

  • O sistema sabe diferenciar código de controle
  • Evita confusão com endereços reais
  • Permite transições seguras entre modos

🧪 Analogias para Padawans

Pense assim:

O MVS usa 31 bits como endereço e guarda o último bit como se fosse um "selo VIP" no ingresso 🎟️

  • Sem selo → endereço normal
  • Com selo → instrução especial

🧠 Por que isso foi GENIAL?

Porque resolveu 3 problemas gigantes de uma vez:

1. 🛡️ Compatibilidade absoluta

Programas antigos continuaram funcionando.

2. 🚀 Expansão de memória

Sai de 16 MB → até 2 GB

3. 🧩 Controle inteligente

O sistema ganhou uma forma de distinguir contextos sem custo extra


🐣 Easter Egg que poucos contam

Muitos bugs clássicos em assembler vinham de:

👉 esquecer de limpar o bit 0

Resultado?

💥 Endereço inválido
💥 S0C4 (proteção)
💥 Caos existencial do operador


⚡ Comentário Bellacosa Mainframe

Se você acha isso gambiarra…

💬 “No mundo distribuído, isso seria um workaround.
No mainframe… virou ARQUITETURA OFICIAL.”

E mais:

👉 Essa decisão influenciou diretamente o caminho até o 64 bits no z/Architecture


🚀 Moral da História

O MVS não é 31 bits por limitação.

Ele é 31 bits por estratégia, elegância e sobrevivência.

Às vezes, a melhor inovação não é avançar tudo…
é avançar sem quebrar nada.


🔥 TL;DR para o Padawan Apressado

  • MVS usou 31 bits para endereço
  • 1 bit virou controle (bit 0)
  • Garantiu compatibilidade com 24 bits
  • Evitou reescrever o mundo inteiro
  • Criou um dos hacks mais elegantes da história da computação 

sábado, 21 de fevereiro de 2026

📊 Da Era dos 16MB ao Infinito: A Linha do Tempo que Explica 24 → 31 → 64 bits no Mainframe

 

Bellacosa Mainframe explica o endereçamento de memoria no IBM Mainframe 24 31 e 64 bits

📊 “Da Era dos 16MB ao Infinito: A Linha do Tempo que Explica 24 → 31 → 64 bits no Mainframe”

Prepare-se, padawan… agora você vai enxergar a evolução do mainframe como um verdadeiro mapa de poder computacional — cada salto não foi só técnico… foi uma jogada estratégica digna de xadrez. ♟️


🟢 1. Era 24 bits — O Mundo Cabia em 16MB

🔹 Contexto

  • Arquitetura do OS/360
  • Endereçamento: 24 bits
  • Limite: 16 MB

🧠 O que isso significava?

  • Tudo precisava caber em um espaço minúsculo
  • Programas eram ultra otimizados
  • Overlays eram comuns (carregar partes do programa sob demanda)

💬 Bellacosa insight:

“Aqui nasceu o DNA da eficiência — cada byte valia ouro.”


🟡 2. Era 31 bits — O Hack Mais Elegante da História

🔹 Contexto

  • Evolução para o MVS
  • Introdução da System/370-XA

⚙️ O que mudou?

  • Endereçamento: 31 bits (não 32!)
  • Limite: 2 GB
  • 1 bit reservado (bit 0) para controle

🔥 O pulo do gato:

  • Compatibilidade TOTAL com 24 bits
  • Mistura de modos (24 + 31)
  • Controle inteligente via bit mais significativo

🧪 Conceito-chave:

O endereço não é só endereço — ele carrega “intenção”

💬 Bellacosa insight:

“Enquanto o mundo queria mais bits… o mainframe queria mais inteligência.”


🔵 3. Era 64 bits — O Universo Expandido

🔹 Contexto

  • Arquitetura moderna: z/Architecture
  • Sistemas como z/OS

🚀 O que mudou?

  • Endereçamento: 64 bits
  • Limite teórico: exabytes
  • Espaço virtual gigantesco

🧠 Novos conceitos:

  • Above the bar / below the bar
  • Memory objects
  • Large memory exploitation

💬 Bellacosa insight:

“Agora não é mais sobre caber… é sobre escalar sem limites.”


📊 Timeline Simplificada (Estilo Raiz)

1970s ───────────────► 24 bits (16 MB)
OS/360

1980s ───────────────► 31 bits (2 GB)
MVS / System/370-XA
(bit 0 reservado 👀)

2000+ ───────────────► 64 bits (exabytes)
z/Architecture / z/OS

🧬 Conexão Evolutiva (O Segredo por Trás)

EraProblemaSoluçãoFilosofia
24 bitsMemória limitadaOtimização extrema“Faça caber”
31 bitsCrescer sem quebrarBit de controle“Evolua com legado”
64 bitsEscalabilidadeEspaço massivo“Expanda sem limites”

🐣 Easter Egg de Mestre

Mesmo no mundo 64 bits…

👉 O conceito de “compatibilidade com legado” continua vivo
👉 E o espírito do bit 0 ainda ecoa nas decisões de design

💥 Ou seja:

O passado do mainframe nunca foi descartado — ele foi incorporado


⚡ Fechamento Estilo Bellacosa

Se você entendeu essa timeline, você desbloqueou algo raro:

🧠 Você não vê mais bits… você vê decisões arquiteturais

Porque no mainframe:

Cada bit tem história
Cada limitação vira estratégia
E cada evolução respeita o passado

 

sexta-feira, 20 de fevereiro de 2026

🔥 “Pandas: O ‘SORT’ do Python que Vai Fazer Você Repensar Tudo que Sabe sobre Arquivos Sequenciais”

 

Bellacosa Mainframe apresenta Pandas a Biblioteca poderosa do Python

🔥 “Pandas: O ‘SORT’ do Python que Vai Fazer Você Repensar Tudo que Sabe sobre Arquivos Sequenciais”


Se você vem do mundo COBOL, prepare-se: este não é apenas mais um artigo sobre Python.

É um choque de paradigma.

É como sair do SORT FIELDS=(...) no JCL e descobrir que você pode fazer tudo isso… e mais… em uma única linha de código.

Hoje vamos falar da biblioteca pandas — mas no estilo Bellacosa Mainframe: com história, bastidores, comparações práticas com COBOL, exemplos reais e até alguns easter eggs que vão te surpreender.


☕ 1. A Origem do Pandas — Não, Não Tem Nada a Ver com o Animal 🐼

O nome pandas vem de:

PANel DAta Structure

Criada em 2008 por Wes McKinney, a biblioteca nasceu dentro de um problema real:

👉 manipular dados financeiros de forma eficiente (algo que qualquer sistema em COBOL faz há décadas).

Ou seja…

💡 Pandas nasceu resolvendo problemas que você já resolve no mainframe.

A diferença?

👉 Ele fez isso com uma abordagem muito mais dinâmica e interativa.


🧠 2. O “choque cultural” para quem vem do COBOL

Se você trabalha com:

  • Arquivos VSAM
  • Sequential files
  • SORT / ICETOOL
  • DFSORT
  • DB2 queries

Então o pandas vai parecer… estranho no começo.

Mas depois:

🔥 viciante

Veja essa comparação:

COBOL / JCLPandas
SORT FIELDSsort_values()
READ FILEread_csv()
WRITE FILEto_csv()
IF / EVALUATEfiltros (query / loc)
FILE LAYOUTDataFrame

👉 O DataFrame é o seu novo “registro + tabela + dataset + tudo junto”


📊 3. O coração do Pandas: DataFrame

Imagine isso:

01 CLIENTE.
05 ID PIC 9(05).
05 NOME PIC X(30).
05 SALDO PIC 9(10)V99.

Agora pense nisso como uma tabela inteira carregada na memória.

👉 Isso é um DataFrame

Exemplo em Python:

import pandas as pd

dados = {
"ID": [1, 2, 3],
"NOME": ["ANA", "JOAO", "CARLA"],
"SALDO": [1500.50, 230.00, 9999.99]
}

df = pd.DataFrame(dados)

print(df)

Resultado:

ID NOME SALDO
0 1 ANA 1500.50
1 2 JOAO 230.00
2 3 CARLA 9999.99

💡 Pense assim:

👉 Você carregou um arquivo inteiro na WORKING-STORAGE… mas com superpoderes.


⚡ 4. Filtrando dados — o “IF” mais poderoso que você já viu

COBOL:

IF SALDO > 1000
DISPLAY CLIENTE
END-IF

Pandas:

df[df["SALDO"] > 1000]

Sim.

Só isso.

🔥 Sem loop. Sem READ. Sem controle manual.


🔀 5. Ordenação — adeus SORT JCL?

JCL:

SORT FIELDS=(SALDO, D)

Pandas:

df.sort_values(by="SALDO", ascending=False)

👉 Em memória
👉 Instantâneo
👉 Encadeável com outras operações


🧩 6. JOIN (sim, tipo DB2)

COBOL tradicional sofre aqui…

Mas pandas:

df1.merge(df2, on="ID", how="inner")

💡 É como um:

SELECT *
FROM A, B
WHERE A.ID = B.ID

🧠 7. Agrupamento (o famoso SUM + BREAK logic)

COBOL:

  • Sort
  • Control break
  • Acumuladores
  • Mil linhas de código 😅

Pandas:

df.groupby("NOME")["SALDO"].sum()

🔥 Isso substitui um programa inteiro de batch.


🥚 8. Easter Eggs do Pandas (sim, existem!)

🐼 1. Representação visual amigável

O pandas automaticamente formata tabelas no estilo “relatório bonito”.

👉 Parece um mini-ISPF tabular 😄


🧪 2. Você pode encadear tudo

df[df["SALDO"] > 1000] \
.sort_values(by="SALDO") \
.head(2)

💡 Isso seria:

  • filtro
  • sort
  • limitar registros

👉 tudo em pipeline


🧙 3. Pandas aceita dados de tudo

  • CSV (sequencial)
  • Excel
  • JSON
  • SQL
  • APIs

👉 É como se o COBOL lesse qualquer formato… sem FD.


🏛️ 9. Curiosidade histórica (nível mainframe)

Enquanto o mundo distribuído evoluía…

👉 o mainframe já fazia:

  • processamento massivo
  • batch
  • ETL
  • consistência

O pandas basicamente trouxe essa filosofia para o mundo Python.

💡 Em outras palavras:

Pandas é o “mini-mainframe” do desenvolvedor moderno


🚀 10. Onde isso muda sua carreira

Se você domina COBOL e aprende pandas:

🔥 você vira um profissional híbrido raríssimo

Você passa a atuar em:

  • Engenharia de dados
  • Data analytics
  • Integração legado + moderno
  • Automação de processos batch fora do mainframe

👉 E o melhor:

Você não joga fora seu conhecimento COBOL.

Você expande ele.


🧠 11. Mentalidade nova (o pulo do gato)

COBOL:

👉 Processamento linha a linha

Pandas:

👉 Processamento em conjunto (vetorizado)

Esse é o maior shift.


☕ Conclusão no estilo Bellacosa

Se o COBOL te ensinou disciplina…

Se o JCL te ensinou controle…

Se o SORT te ensinou performance…

Então o pandas vai te ensinar:

🔥 liberdade

Mas cuidado…

Depois que você fizer um groupby().sum() em uma linha…

👉 você nunca mais vai olhar um control-break da mesma forma.