☕ EXECIO no REXX Mainframe O canivete suíço de I/O que todo mundo usa… e quase ninguém respeita

 

☕ EXECIO no REXX Mainframe

O canivete suíço de I/O que todo mundo usa… e quase ninguém respeita

“Quando o REXX toca no disco, o EXECIO está por trás.
E quando o disco fica lento, geralmente é culpa de quem não entendeu o EXECIO.”

---

🧠 Introdução – Onde o REXX encontra o mundo real

REXX é excelente para controle, decisão e orquestração.
Mas em algum momento ele precisa fazer o que todo batch faz desde 1964:

👉 Ler dados
👉 Escrever dados

É aí que entra o EXECIO.

Simples no nome.
Perigoso no impacto.

---

🕰️ Origem histórica – Por que o EXECIO nasceu?

Antes do EXECIO:

• REXX era fortemente interativo

• I/O era dependente de comandos externos

• Ler arquivos sequenciais era lento e improvisado

Com a popularização do REXX no TSO/E e no batch, a IBM precisava de:

• Um método padrão

• Um comando eficiente

• Compatível com DDNAME

• Funcional tanto em TSO quanto em batch

Assim nasceu o EXECIO, no final dos anos 80, como ponte direta entre:

REXX ⇄ QSAM ⇄ MVS

---

📜 O que é EXECIO?

EXECIO é o comando REXX responsável por:

• Ler registros de um DDNAME

• Escrever registros em um DDNAME

• Transferir dados entre datasets e variáveis REXX

Ele trabalha sempre com:

• DDNAME alocado

• Registros sequenciais

• Stem variables

---

🧪 Sintaxe essencial

EXECIO <quantidade> DISKR <ddname> (STEM var.
EXECIO <quantidade> DISKW <ddname> (STEM var.

Exemplo básico:

EXECIO * DISKR SYSIN (STEM linhas.

Aqui:

• * = todas as linhas

• DISKR = leitura

• SYSIN = DDNAME

• linhas. = onde os dados vão morar

---

🧩 Curiosidades que pouca gente comenta

🧩 1. EXECIO não entende “arquivo”

Ele entende DDNAME.

Se o DDNAME não existe:

• RC pode ser enganoso

• O erro aparece em mensagem

• GETMSG vira obrigatório

---

🧩 2. EXECIO * carrega tudo na memória

EXECIO * DISKR BIGFILE (STEM big.

Se o arquivo tem:

• 10 mil linhas → ok

• 1 milhão → boa sorte

EXECIO * é confortável… até não ser.

---

🧩 3. A variável .0 manda mais que você

Após leitura:

say linhas.0

Ela contém quantos registros foram lidos.

Ignorar .0 é convite a loop errado.

---

🥚 Easter Eggs técnicos

🥚 1. Leitura parcial estratégica

EXECIO 1 DISKR INDD (STEM linha.

Ótimo para:

• Ler cabeçalhos

• Identificar layout

• Decidir processamento sem ler tudo

---

🥚 2. EXECIO + Data Stack

É possível combinar:

• EXECIO

• PUSH / QUEUE

• PARSE PULL

Criando pipelines “à moda antiga”.

---

🥚 3. EXECIO em SYSREXX

No batch, EXECIO:

• Roda sem terminal

• Depende totalmente do JCL

• É mais rápido

• É mais perigoso

---

🧠 Exemplo prático – Batch inteligente

EXECIO * DISKR INPUT (STEM in.
DO i = 1 TO in.0
  IF POS('ERRO', in.i) > 0 THEN DO
     SAY 'Erro detectado na linha' i
     EXIT 8
  END
END
EXECIO in.0 DISKW OUTPUT (STEM in.

Esse REXX:

• Lê

• Analisa

• Decide

• Escreve

Tudo antes do COBOL rodar.

---

⚠️ Riscos reais do EXECIO

• Arquivo grande → consumo de memória

• DISKW sem controle → overwrite silencioso

• DISKR sem validação → loop infinito

• Falta de fechamento → dados inconsistentes

Boa prática Jedi

EXECIO 0 DISKW OUTDD

Força flush e fechamento correto.

---

🛡️ EXECIO e segurança

EXECIO respeita:

• RACF

• Permissões de dataset

• Contexto do job

Mas:

REXX que escreve dados é tão poderoso quanto um utility IBM.

Controle de acesso é obrigatório.

---

☕ Comentário Bellacosa Mainframe

O EXECIO é o momento em que:

• O REXX deixa de ser “script”

• E passa a mexer em dados corporativos

Quem trata EXECIO como “detalhe”:

• Cria batch frágil

• Gera incidentes silenciosos

• Descobre o erro em produção

EXECIO não é comando.
É compromisso com o dado.

---

🧠 Frase final para colar no monitor

Se o REXX leu, ele é responsável.
Se escreveu, ele é culpado até prova em contrário.

 

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.

Porque é aí que o REXX deixa de ser linguagem…

E vira:

infraestrutura invisível do mainframe.

 

Bellacosa Mainframe apresenta o compound variables data stack no REXX

🔥 REXX: O “JSON DO MAINFRAME” ANTES DO JSON EXISTIR!

Compound Variables, Data Stack e os Superpoderes Secretos do TSO/E 🚀

“Enquanto muita gente acha que o mainframe era limitado nos anos 80… o REXX já fazia coisas que linguagens modernas demorariam décadas para popularizar.”
— Bellacosa Mainframe ☕💻

---

☕ Introdução — O Dia em que Descobri que o REXX Era MUITO Mais Moderno do que Parecia

Existe um momento na vida de todo programador mainframe em que ele percebe:

“Espera… isso aqui parece um Python disfarçado de terminal verde.”

E normalmente esse momento acontece quando ele aprende:

• Compound Variables
• OUTTRAP()
• Data Stack

Porque aqui o REXX deixa de ser apenas:

“uma linguagemzinha de automação”

…e começa a revelar algo assustadoramente avançado.

Sim…

O REXX já possuía:

✅ Estruturas associativas
✅ Chaves dinâmicas
✅ Captura de stdout
✅ Filas e pilhas
✅ Estruturas pseudo-JSON
✅ Automação textual inteligente

…quando muita linguagem moderna ainda nem existia.

---

🧠 O “Pseudo-JSON” do Mainframe

Veja isto:

cliente.100.nome   = "VAGNER"
cliente.100.cidade = "ITATIBA"
cliente.100.cargo  = "MAINFRAME SPECIALIST"

Agora compare com JSON moderno:

{
  "cliente": {
    "100": {
      "nome": "VAGNER",
      "cidade": "ITATIBA",
      "cargo": "MAINFRAME SPECIALIST"
    }
  }
}

😳

Percebe o absurdo?

O REXX fazia isso décadas antes do JSON virar padrão mundial.

---

🔥 Compound Variables — O Recurso que Quase Ninguém Explora Direito

As famosas:

Stem Variables

Estrutura:

stem.tail

Exemplo:

usuario.nome

Onde:

Parte	Significado
usuario.	stem
nome	tail

---

☠️ O Detalhe que Destrói Iniciantes

ISTO:

cliente

NÃO É IGUAL A:

cliente.

O ponto muda tudo.

---

🤯 O Stem Possui “Efeito Mágico”

Exemplo:

status. = "DESCONHECIDO"

Agora:

SAY status.job1
SAY status.job2
SAY status.qualquercoisa

Resultado:

DESCONHECIDO
DESCONHECIDO
DESCONHECIDO

Mesmo sem criar as variáveis individualmente.

---

🧙‍♂️ O Feitiço do Tail Dinâmico

Aqui o REXX começa a parecer bruxaria.

dia.1 = "SEG"
dia.2 = "TER"
dia.3 = "QUA"

x = 2

SAY dia.x

O interpretador resolve:

dia.2

Saída:

TER

---

⚡ Isso Era Um “HashMap” Antes do Java

Hoje faríamos:

Python

dias[x]

JavaScript

dias[x]

REXX (1980s 😎)

dia.x

---

☕ Easter Egg #1 — O “Banco de Dados” em REXX

Você pode montar estruturas absurdamente sofisticadas:

produto.100.desc  = "CAFÉ"
produto.100.preco = 15.90

produto.200.desc  = "COBOL"
produto.200.preco = 9999.99

Consulta:

id = 200

SAY produto.id.desc

Resultado:

COBOL

Sim…

Você acabou de criar um mini banco key-value.

---

💣 OUTTRAP() — O Recurso que Faz Operadores Virarem Semideuses

Pouca gente entende o quão poderoso isso é.

O OUTTRAP captura saída textual de comandos TSO.

---

😳 O Terminal Vira Dados

Exemplo:

x = OUTTRAP("lista.")

"LISTALC STATUS"

x = OUTTRAP("OFF")

Agora:

lista.1
lista.2
lista.3

contêm TODA a saída do comando.

---

🚀 Isso é o Equivalente Mainframe de:

Linux

comando > arquivo

Python

subprocess.capture_output()

PowerShell

$result = command

Mas no TSO/E…

isso existia há MUITO tempo.

---

☕ Easter Egg #2 — O Parser Automático de LISTCAT

x = OUTTRAP("cat.")

"LISTCAT ENT(PROD.CLIENTES)"

x = OUTTRAP("OFF")

DO i = 1 TO cat.0

   IF POS("TRACKS",cat.i) > 0 THEN
      SAY "ALOCACAO:" cat.i

END

😎

O operador vira praticamente um “detetive do catálogo”.

---

🧨 A Data Stack — O Recurso Mais Perigoso do REXX

Aqui começam os poderes obscuros do TSO/E.

A Data Stack é:

uma pilha/fila dinâmica global

---

PUSH vs QUEUE

PUSH

PUSH "A"
PUSH "B"

Saída via PARSE PULL:

B
A

LIFO.

---

QUEUE

QUEUE "A"
QUEUE "B"

Saída:

A
B

FIFO.

---

🎮 Analogia Gamer

Comando	Analogia
PUSH	pilha de inventário
QUEUE	fila de matchmaking

---

☠️ O Erro Mais Mortal do REXX

Se você terminar um exec deixando dados na stack…

…esses dados podem virar comandos TSO.

Sim.

COMANDOS.

---

😨 Exemplo de Filme de Terror Mainframe

QUEUE "DELETE PROD.CLIENTES"
EXIT

Se cair na stack errada…

adeus dataset.

---

🛡️ A Defesa dos Jedi Mainframers — NEWSTACK

Profissionais experientes SEMPRE usam:

ADDRESS TSO "NEWSTACK"

e depois:

ADDRESS TSO "DELSTACK"

---

☕ Easter Egg #3 — O “Sandbox” do REXX

O NEWSTACK funciona quase como:

• container
• sandbox
• ambiente isolado

Décadas antes de Docker existir.

😎

---

🧠 O QUEUED() Salva Vidas

Antes de:

PARSE PULL linha

Faça:

IF QUEUED() > 0 THEN
   PARSE PULL linha

Porque se stack estiver vazia…

o REXX tenta ler do terminal.

Em batch isso pode causar:

HANG
WAIT
ABEND OPERACIONAL
OPERADOR EM PÂNICO

---

🤯 MAKEBUF — O Recurso Ninja que Quase Ninguém Conhece

Sim…

o stack possui buffers internos.

ADDRESS TSO "MAKEBUF"

Pouquíssimos profissionais modernos usam isso.

Mas no passado…

isso era arma secreta de automações ISPF sofisticadas.

---

🚀 Exemplo Profissional Completo

Scanner Automático de Catálogo

/*-----------------------------------*/
/* BELLACOSA MAINFRAME SCANNER       */
/*-----------------------------------*/

ADDRESS TSO "NEWSTACK"

x = OUTTRAP("ds.")

"LISTCAT LEVEL(PROD)"

x = OUTTRAP("OFF")

DO i = 1 TO ds.0

   linha = ds.i

   IF POS("NONVSAM",linha) > 0 THEN
      SAY "DATASET ENCONTRADO:"
      SAY linha
      SAY "---------------------"

END

ADDRESS TSO "DELSTACK"

EXIT

---

☕ Easter Egg #4 — O “Python Invisível” do z/OS

Muita gente usa Python hoje para:

• parse textual
• automação
• captura de comandos

Mas o TSO/E + REXX já fazia isso muito antes.

---

📜 Filosofia do REXX

O REXX foi criado para:

✅ produtividade
✅ legibilidade
✅ automação
✅ integração
✅ simplicidade

Por isso ele parece:

• elegante
• textual
• flexível
• “humano”

---

🤖 O Mainframe Era MUITO Mais Moderno do que Parecia

Quando alguém disser:

“mainframe é ultrapassado”

Mostre:

• compound variables
• OUTTRAP
• stacks dinâmicas
• parsing inteligente

E depois pergunte:

“Seu framework moderno faz isso tudo tão elegantemente?”

😏

---

☕ Conclusão — O Verdadeiro Poder do REXX

REXX nunca foi apenas “uma linguagem de scripts”.

Ele era:

um canivete suíço de automação textual corporativa

E quando combinamos:

• Compound Variables
• OUTTRAP()
• Data Stack

…o TSO/E praticamente ganha superpoderes.

---

🚀 Bellacosa Mainframe Insight

“O REXX não envelheceu.
Apenas ficou escondido enquanto o resto do mundo reinventava suas ideias.” ☕💻