sábado, 8 de novembro de 2025

☕🚀 REXX NO MODO TURBO: O DIA EM QUE O EXECIO VIROU UM CANHÃO DE AUTOMAÇÃO NO z/OS 🚀☕

Bellacosa Mainframe Lendo e gravando dataset em REXX

☕🚀 REXX NO MODO TURBO: O DIA EM QUE O EXECIO VIROU UM CANHÃO DE AUTOMAÇÃO NO z/OS 🚀☕

“Quem domina I/O em REXX deixa de escrever scripts… e começa a construir infraestrutura invisível dentro do mainframe.”

— Bellacosa Mainframe

📚 Introdução

Existe um momento específico na jornada de qualquer profissional mainframe em que tudo muda.

Até então:

o REXX parecia apenas uma linguagem de comandos,
alguns SAY,
uns PARSE,
um loop aqui,
um LISTDSI ali.

Mas então surge ele:

🔥 EXECIO 🔥

E junto dele:

datasets,
streams,
automação JES,
geração dinâmica de JCL,
pipelines batch,
processamento massivo,
e aquele sentimento perigoso de:

“Acho que agora consigo automatizar o datacenter inteiro…”

E sinceramente?

Talvez consiga mesmo.

🏛️ O VERDADEIRO PODER DO REXX

Muita gente acha que o poder do mainframe está:

no COBOL,
no CICS,
no DB2,
ou no JES2.

Mas existe um herói silencioso escondido no TSO:

⚡ O REXX ⚡

Porque ele conecta tudo.

O REXX:

conversa com datasets,
conversa com JES,
conversa com ISPF,
conversa com SDSF,
conversa com USS,
conversa com RACF,
conversa com operadores,
conversa com o sysprog,
e às vezes…
conversa até com entidades sobrenaturais chamadas ABENDs.

💾 O PRIMEIRO CONTATO COM O EXECIO

O programador iniciante vê isso:


"EXECIO * DISKR INDD (STEM REC. FINIS"

E pensa:

“Ok… parece simples.”

O sysprog experiente olha o mesmo comando e pensa:

“Esse cidadão acabou de carregar 12 milhões de linhas na memória…”

☠️ O ASTERISCO QUE DESTRÓI REGIÕES

Vamos falar sobre o famoso:

No EXECIO ele significa:

“Leia TUDO.”

Parece inocente.

Mas imagine executar isso em:

um SYSLOG gigantesco,
um dump textual,
um relatório SMF,
ou uma saída monstruosa de SORT.

Resultado:


IEF374I REGION BELOW 16M EXHAUSTED

Ou pior:


S878

O momento em que o operador começa a procurar seu userid no console…

🧠 O SEGREDO DOS PROFISSIONAIS: STEM VARIABLES

A IBM acertou em cheio aqui.

O uso de STEM transforma o REXX em algo elegantíssimo.

📦 Exemplo


/* LEITURA DE DATASET */

"ALLOC FI(INPUT) DA('USER.TEST.DATA') SHR"

"EXECIO * DISKR INPUT (STEM DADOS. FINIS"

SAY "TOTAL DE REGISTROS:" DADOS.0

DO I = 1 TO DADOS.0
   SAY DADOS.I
END

"FREE FI(INPUT)"

🔍 O DETALHE QUE MUITA GENTE NÃO PERCEBE


DADOS.0

NÃO é um registro.

Ele contém:

a quantidade de linhas lidas.

Isso virou praticamente um padrão “sagrado” no universo REXX.

🧙‍♂️ O FEITICEIRO DOS DATASETS

Depois de algum tempo usando EXECIO, acontece algo curioso.

Você para de pensar em:

datasets

E começa a pensar em:

fluxos,
pipelines,
transformação de dados,
automação operacional.

O REXX começa a parecer um mini shell Unix dentro do z/OS.

E isso NÃO é coincidência.

🌊 STREAMS — QUANDO O REXX DESCOBRE O UNIX

A chegada das Stream Functions foi revolucionária.

Antes:

tudo era “registro”.

Depois:

tudo virou “fluxo”.

📜 Exemplo com LINEIN()


ARQ = STREAM("'USER.INPUT.DATA'","C","OPEN READ")

DO WHILE LINES(ARQ)

   LINHA = LINEIN(ARQ)

   SAY LINHA

END

CALL STREAM ARQ,"C","CLOSE"

Isso parece:

shell scripting,
C,
Python,
Perl,
Unix clássico.

A IBM basicamente trouxe a filosofia POSIX para dentro do REXX.

🤯 O DIA EM QUE O REXX VIRA DEVOPS

Agora observe isso:


JOB.1="//TESTJOB JOB (ACCT),'REXX'"
JOB.2="//STEP1 EXEC PGM=IEFBR14"
JOB.0=2

SAY SUBMIT("JOB.")

Sim.

Você acabou de:

gerar um JOB,
montar o JCL,
submeter para o JES2,
tudo dinamicamente.

☕ EASTER EGG #1 — O “SKYNET JES2”

Em algum momento da carreira todo profissional REXX cria um loop acidental assim:


DO FOREVER

   SAY SUBMIT("JOB.")

END

Cinco minutos depois:


$HASP375 JOB99999 ESTIMATED LINES EXCEEDED

E nasce uma nova lenda no CPD.

⚡ EXECIO vs STREAMS

EXECIO

Modo clássico mainframe:

robusto
tradicional
extremamente usado

STREAMS

Modo moderno:

mais portátil
mais elegante
mais próximo de Unix/Linux

🏗️ O MAINFRAME É UM ECOSSISTEMA DE I/O

O z/OS inteiro gira em torno de:

datasets,
buffers,
canais,
spool,
VSAM,
logs,
streams,
records.

Quem domina I/O:

domina automação.

Quem domina automação:

domina operação.

Quem domina operação:

vira indispensável.

💥 O ERRO CLÁSSICO DO INICIANTE


"EXECIO * DISKR HUGEFILE (STEM BIG."

Quando:

HUGEFILE tem 48 milhões de registros.

O storage começa a evaporar.

O SDSF fica lento.

O operador abre incidente.

O sysprog começa a investigar.

E você:

apenas queria “dar uma olhadinha no arquivo”.

🧠 O PADRÃO PROFISSIONAL REAL

Os veteranos fazem assim:


DO FOREVER

   "EXECIO 100 DISKR INPUT (STEM REC."

   IF RC <> 0 THEN LEAVE

   DO I = 1 TO REC.0

      SAY REC.I

   END

END

Isso:

escala melhor,
consome menos memória,
evita tragédias operacionais.

☕ EASTER EGG #2 — O “FINIS ESQUECIDO”

Poucas coisas assustam mais um sysprog do que descobrir:


"EXECIO * DISKR INPUT (STEM REC."

Sem:


FINIS

O dataset continua aberto…

E às vezes:

lockado,
preso,
pendurado,
amaldiçoado pelo espírito ancestral do ENQ.

👻 O FANTASMA DO DATASET EM USO

Todo mundo já viu:


DATA SET IN USE

E passou 40 minutos procurando:

TSO preso,
ISPF órfão,
batch zombie,
ou um REXX abandonado.

🚀 BPXWDYN — O SUPER SAIYAJIN DO ALLOC

Depois vem ele:

BPXWDYN

O allocation moderno do z/OS.

📜 Exemplo


CALL BPXWDYN "ALLOC FI(INPUT) DA(USER.TEST) SHR"

Muito mais poderoso que:

ALLOC tradicional.

Mais elegante.
Mais flexível.
Mais “Unixificado”.

🌌 O REXX COMO LINGUAGEM UNIVERSAL DO z/OS

Poucas linguagens conseguem:

operar JES,
ler spool,
manipular datasets,
chamar ISPF,
usar USS,
conversar com RACF,
abrir sockets,
automatizar operações.

O REXX consegue.

E faz isso há décadas.

☕ EASTER EGG #3 — O SYSADM OCULTO

Existe uma regra não escrita no mainframe:

“Se um ambiente está funcionando perfeitamente há 20 anos… provavelmente existe um REXX misterioso sustentando tudo.”

Ninguém sabe:

quem escreveu,
quando escreveu,
ou como funciona.

Mas todos têm medo de apagar.

🧬 O DNA DO MAINFRAME MODERNO

Hoje:

DevOps,
automação,
pipelines,
integração contínua,
observabilidade,
self-healing systems…

Tudo isso já existia conceitualmente no z/OS há muito tempo.

E o REXX participou disso silenciosamente.

🎯 Conclusão

Aprender:

EXECIO,
STREAMS,
LINEIN,
LINEOUT,
BPXWDYN,
SUBMIT,

não é apenas aprender I/O.

É aprender:

como o mainframe respira.

Porque no fundo:

o z/OS é movimento de dados,
fluxo de informação,
buffers,
registros,
streams,
spool,
mensagens,
eventos.

E o REXX é uma das linguagens que melhor conversa com esse universo.

☕ Bellacosa Mainframe Final Advice

Se você realmente quiser evoluir em REXX:

Pare de fazer apenas:

scripts.

Comece a construir:

automações,
frameworks,
pipelines,
ferramentas operacionais,
inteligência operacional.

El Jefe Midnight Lunch

Translate

sábado, 8 de novembro de 2025