terça-feira, 4 de novembro de 2025

☕🔥 REXX: O “CALL” QUE SEPARA AMADORES DE MESTRES DO MAINFRAME 🔥☕

Bellacosa Mainframe subrotina e funções no REXX

☕🔥 REXX: O “CALL” QUE SEPARA AMADORES DE MESTRES DO MAINFRAME 🔥☕

Quando uma simples subrotina vira arquitetura corporativa no z/OS

Existe um momento curioso na vida de todo profissional de Mainframe.

No começo, o programador escreve scripts REXX pequenos:

um SAY
um PARSE
um LISTDSI
um loopzinho no TSO

Tudo parece simples…

Até o dia em que o EXEC cresce.

E cresce.

E cresce MAIS.

De repente:

o REXX virou ferramenta operacional
automatizou JES2
conversa com SDSF
consulta DB2
gera relatórios
envia alertas
dispara jobs
trata datasets
faz parsing de SYSOUT

E então nasce o monstro.

O famoso:

“REXX ESPAGUETE”

O EXEC com:

4 mil linhas
93 labels
17 GOTOs improvisados
variáveis globais brigando entre si
e um EXIT perdido que encerra tudo sem aviso.

É nesse ponto que Functions e Subroutines deixam de ser “assunto básico”.

E passam a ser:

ENGENHARIA DE SOFTWARE NO z/OS

🧠 O DIA EM QUE O REXX MUDA

A maioria aprende REXX assim:


SAY 'HELLO WORLD'

Depois:


DO I = 1 TO 10
   SAY I
END

Mas o verdadeiro salto acontece quando alguém descobre:


CALL

Parece banal.

Mas não é.

Porque o CALL introduz:

modularização
reutilização
encapsulamento
separação de responsabilidades

Ou seja:

arquitetura.

☕ A FILOSOFIA UNIX… DENTRO DO MAINFRAME

Existe uma ideia clássica no UNIX:

“Faça uma coisa… e faça bem.”

REXX absorveu isso perfeitamente.

Uma boa subrotina:

tem responsabilidade única
é reutilizável
é previsível
é segura

🔥 O ERRO QUE TODO MUNDO COMETE

O clássico:


/* REXX */

contador = 0

CALL SOMA
CALL SOMA
CALL SOMA

SAY contador

EXIT

SOMA:
contador = contador + 1
RETURN

Resultado:

O iniciante acha lindo.

O veterano começa a suar frio.

Porque:

a subrotina alterou variável global
qualquer outra rotina pode quebrar tudo
debugging vira inferno

🧨 O APOCALIPSE DAS VARIÁVEIS GLOBAIS

Em ambientes corporativos isso gera:

bugs fantasmas
comportamento imprevisível
corrupção lógica
falhas intermitentes

O tipo de erro que:

acontece só em produção
às 3h da manhã
no fechamento bancário

🛡️ PROCEDURE: O HERÓI ESQUECIDO DO REXX

Aí surge ele.

O cavaleiro do encapsulamento:


PROCEDURE

O MESMO CÓDIGO — AGORA PROFISSIONAL


/* REXX */

contador = 0

CALL SOMA
CALL SOMA
CALL SOMA

SAY contador

EXIT

SOMA:
PROCEDURE

contador = contador + 1
RETURN

Resultado:

BOOM.

Agora:

a variável ficou isolada
a rotina ficou segura
o EXEC ficou previsível

🧠 O QUE O PROCEDURE REALMENTE FAZ?

Muita gente pensa:

“Ah… ele só protege variáveis.”

Não.

Ele cria:

CONTEXTO DE EXECUÇÃO

Quase como stack frame em linguagens modernas.

Ou seja:

escopo local
isolamento
proteção de memória lógica

Isso é MUITO avançado para uma linguagem criada em 1979.

👀 EASTER EGG MAINFRAME #1

Muitos programadores COBOL estranham isso porque COBOL tradicionalmente compartilha Working-Storage de forma mais explícita.

Já o REXX:

pode ser extremamente dinâmico
extremamente perigoso
ou extremamente elegante

Tudo depende do uso do PROCEDURE.

☠️ O “EXIT” QUE MATOU PRODUÇÃO

Existe um erro lendário em REXX.

Esse aqui:


MINHAROTINA:
EXIT

O programador queria retornar.

Mas o EXIT:

encerrou o EXEC inteiro
abortou processamento
deixou JOB preso
não gerou relatório
não liberou recurso

Resultado:

operador chamou suporte
suporte chamou sysprog
sysprog chamou o programador
o programador fingiu que estava em reunião.

O CORRETO


MINHAROTINA:
RETURN

☕ EASTER EGG MAINFRAME #2

Veteranos de TSO geralmente têm trauma de:

IKJ56500I
loops infinitos
EXEC preso consumindo CPU
SDSF mostrando step “ativo eternamente”

Muitas vezes a causa era:

RETURN faltando
variável compartilhada
parsing errado

🔍 FUNCTIONS: A JOIA DO REXX

Subrotina executa ações.

Função:

calcula
transforma
retorna valor

EXEMPLO CLÁSSICO


nome = 'MAINFRAME'

tam = LENGTH(nome)

SAY tam

Resultado:

A função:

recebe argumento
processa
devolve resultado

O PODER DAS BUILT-IN FUNCTIONS

REXX é quase um canivete suíço textual.

Tem funções para:

palavras
parsing
HEX
EBCDIC
decimal
binary
formatação
datas
sistema

🔥 O MOMENTO “MATRIX” DO MAINFRAME

Quando alguém descobre:


C2X()
X2C()

o cérebro explode.

Porque agora:

dumps fazem sentido
buffers CICS fazem sentido
mensagens MQ fazem sentido
VSAM hexadecimal faz sentido

EXEMPLO


SAY C2X('A')

Resultado:

C1

E aqui está a magia.

No Windows:

“A” normalmente seria 41 hexadecimal

No Mainframe:

é C1

Porque o z/OS vive no glorioso mundo:

EBCDIC

👀 EASTER EGG MAINFRAME #3

Você sabe que alguém virou “mainframer raiz” quando ele olha:

F1F2F3

e instantaneamente pensa:

🚀 PARSE ARG — A ARTE DO REXX

Outras linguagens:


campos = texto.split()

REXX:


PARSE ARG nome sobrenome idade

Fim.

Elegante.
Natural.
Humano.

EXEMPLO PROFISSIONAL


/* REXX */

CALL PROCESSA 'VAGNER BELLACOSA MAINFRAME'

EXIT

PROCESSA:
PROCEDURE

PARSE ARG nome sobrenome area

SAY 'NOME      :' nome
SAY 'SOBRENOME:' sobrenome
SAY 'AREA      :' area

RETURN

Saída:


NOME      : VAGNER
SOBRENOME : BELLACOSA
AREA      : MAINFRAME

🔥 INTERNAL vs EXTERNAL ROUTINES

Esse conceito é GIGANTE.

INTERNAL

Dentro do mesmo EXEC.

EXTERNAL

Outro membro da PDS.

Isso permitiu nascer:

frameworks REXX
bibliotecas corporativas
automação enterprise
ferramentas operacionais gigantes

🏦 O REXX QUE NINGUÉM VÊ

Muita gente acha que Mainframe moderno vive só de:

COBOL
DB2
CICS

Mas nos bastidores…

REXX roda:

automação operacional
health checks
deployment
monitoramento
auditoria
SDSF automation
RACF tooling
DevOps z/OS

☕ EASTER EGG MAINFRAME #4

Em muitos bancos:

o sistema crítico é COBOL
mas quem “cola tudo” é REXX

O REXX virou:

a fita isolante do z/OS.

🎯 O VERDADEIRO ENSINAMENTO

Esse módulo parece ensinar:

CALL
RETURN
FUNCTION

Mas o que ele REALMENTE ensina é:

COMO ORGANIZAR PENSAMENTO

O SALTO DE MATURIDADE

O iniciante escreve:

scripts

O profissional escreve:

módulos

O especialista escreve:

frameworks reutilizáveis

O veterano escreve:

automação que parece sistema operacional.

💡 EXEMPLO FINAL — ESTILO CORPORATIVO


/* REXX */

CALL CABECALHO

usuario = USERID()
data    = DATE()
hora    = TIME()

msg = MONTA_MSG(usuario,data,hora)

CALL EXIBE msg

EXIT

/* ======================= */

CABECALHO:
PROCEDURE
SAY '================================='
SAY ' SISTEMA DE AUDITORIA MAINFRAME '
SAY '================================='
RETURN

/* ======================= */

MONTA_MSG:
PROCEDURE

PARSE ARG user,data,hora

RETURN 'USUARIO:' user ' DATA:' data ' HORA:' hora

/* ======================= */

EXIBE:
PROCEDURE

PARSE ARG texto

SAY texto

RETURN

RESULTADO


=================================
 SISTEMA DE AUDITORIA MAINFRAME
=================================

USUARIO: IBMUSER DATA: 2026-05-07 HORA: 14:32:10

☕ CONCLUSÃO

Functions e Subroutines não são “detalhes” do REXX.

São:

modularização
arquitetura
reutilização
encapsulamento
engenharia de software

E talvez essa seja a maior surpresa do Mainframe moderno:

Mesmo décadas depois…

O REXX ainda ensina conceitos que muitos sistemas distribuídos continuam tentando reaprender.

Translate

terça-feira, 4 de novembro de 2025