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

sábado, 3 de outubro de 2026

REXX 1995: O dia em que a IBM quis conquistar o mundo — uma aventura mainframe sob a batuta de Spike Spiegel

 

Bellacosa Mainframe comenta sobre a conferencia que apresentou o REXX ao mundo

☕ UM CAFÉ NO BELLACOSA MAINFRAME

REXX 1995: O dia em que a IBM quis conquistar o mundo — uma aventura mainframe sob a batuta de Spike Spiegel

Bellacosa Mainframe — Arqueologia da Computação, COBOL, REXX e os fantasmas do código legado

Por Vagner Bellacosa — Bellacosa Mainframe

“See you, Space Cowboy…” — Cowboy Bebop







1. Introdução — Uma nave chamada IBM e um caçador de recompensas chamado REXX

Imagine a cena.

Estamos em maio de 1995. A Internet começa a conquistar universidades, empresas e os primeiros aventureiros digitais. O Windows 95 ainda não chegou oficialmente ao mercado. O Linux é uma promessa jovem, o OS/2 tenta conquistar seu território e os mainframes IBM continuam processando uma quantidade gigantesca de informações empresariais.

Em algum ponto desse universo tecnológico, 130 especialistas se reúnem no Stanford Linear Accelerator Center, na Califórnia, para discutir o futuro de uma linguagem que nasceu discretamente nos corredores da IBM.

Seu nome: REXX.

Agora imagine Spike Spiegel, o despreocupado caçador de recompensas de Cowboy Bebop, entrando numa sala repleta de terminais, fitas magnéticas e programadores experientes.

De mãos nos bolsos, observa as telas, pergunta onde está o café e descobre que há uma recompensa muito mais interessante do que alguns milhares de woolongs.

A recompensa é compreender como uma linguagem criada em 1979 estava se preparando para conquistar o universo da computação.

A bordo desta Bebop imaginária, nossa tripulação será formada por COBOL, REXX, JCL, CICS, Db2 e alguns personagens históricos da IBM.

Spike assume a batuta narrativa. Mike Cowlishaw é o arquiteto da linguagem. Melinda Varian, de Princeton, é nossa correspondente especial no simpósio.

E o programador COBOL iniciante? Esse será o novo tripulante que aprenderá a navegar por sistemas com décadas de história.

O mais interessante é que o simpósio realmente aconteceu.

O Sexto Simpósio Internacional de REXX, realizado de 1 a 3 de maio de 1995, deixou um documento histórico extraordinário: o relatório de Melinda Varian, preservado pela REXX Language Association.

Nele encontramos anúncios controversos, discussões técnicas, ideias inovadoras, previsões ousadas e até comentários sobre decisões equivocadas de projeto.

Vamos embarcar nessa aventura.


2. Episódio 1 — A origem de REXX: uma ideia no meio da noite

Nossa viagem começa em março de 1979.

Mike Cowlishaw, engenheiro da IBM no laboratório de Hursley, na Inglaterra, desperta durante a noite pensando em uma nova linguagem de programação.

Sua preocupação não era simplesmente produzir mais uma ferramenta.

Ele queria desenvolver uma linguagem fácil de aprender, fácil de lembrar e suficientemente expressiva para resolver problemas reais.

Naquela época, usuários de VM/CMS trabalhavam com linguagens como EXEC e EXEC2.

Essas ferramentas eram úteis, mas podiam produzir programas difíceis de ler, especialmente pela quantidade de símbolos e convenções sintáticas.

Cowlishaw desejava algo diferente.

Uma linguagem em que o programador pudesse concentrar a atenção no problema, e não na pontuação.

Foi assim que nasceu o REXX, cujo nome se relaciona à expressão Restructured Extended Executor.

A primeira implementação foi distribuída pela rede interna VNET da IBM em 21 de maio de 1979.

Essa rede conectava profissionais distribuídos por diferentes instalações da empresa.

Cowlishaw enviava propostas, recebia comentários, corrigia comportamentos e desenvolvia novas funcionalidades.

A linguagem cresceu por meio da colaboração.

Curiosidade: uma espécie de desenvolvimento comunitário antes do GitHub

O processo descrito por Cowlishaw lembra bastante práticas modernas de engenharia de software.

Primeiro, ele documentava uma funcionalidade.

Depois, compartilhava a proposta com outros profissionais.

Em seguida, escrevia exemplos para verificar se a ideia realmente fazia sentido.

Somente então avançava na implementação.

Hoje chamaríamos parte desse processo de desenvolvimento orientado por especificações, testes e feedback.

Em 1979, tudo isso acontecia por uma rede corporativa.

Ao final do primeiro ano, Cowlishaw havia dedicado aproximadamente mil horas ao projeto, produzido dez mil linhas de Assembler e escrito cinco mil linhas de documentação.

Observe o detalhe: o interpretador era desenvolvido em Assembler, mas seu objetivo era oferecer ao usuário uma linguagem muito mais acessível.

É como construir uma nave espacial sofisticadíssima para que seu piloto precise lidar apenas com comandos compreensíveis.

Primeiro programa REXX

/* BELLACOSA - PRIMEIRO REXX */

say "Bem-vindo ao universo mainframe"
say "Ano historico: 1995"
say "Missao: aprender REXX"
exit 0

A instrução SAY apresenta uma mensagem.

Os comentários ficam entre /* e */.

A instrução EXIT 0 encerra o programa indicando conclusão normal.

Simples, não?

Agora compare com um programa COBOL equivalente.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. PRIMEIRO.
       PROCEDURE DIVISION.
           DISPLAY "Bem-vindo ao universo mainframe"
           DISPLAY "Ano historico: 1995"
           DISPLAY "Missao: aprender COBOL"
           GOBACK.

O exemplo COBOL utiliza formato fixo tradicional, com as instruções iniciando na área apropriada.

Ambos apresentam mensagens, mas suas estruturas são diferentes.

COBOL é especialmente adequado ao desenvolvimento de aplicações empresariais com regras de negócio e dados estruturados.

REXX é excelente para automação, interpretação de comandos e criação de utilitários.

Primeira lição da Bebop: não existe obrigação de escolher uma linguagem e abandonar todas as outras. O bom programador aprende a utilizar a ferramenta apropriada para cada missão.


3. Episódio 2 — A reunião secreta de 1995

Avancemos dezesseis anos.

Stanford Linear Accelerator Center, Califórnia.

Programadores, pesquisadores e especialistas se reúnem para o Sexto Simpósio Internacional de REXX.

Entre os participantes estão Mike Cowlishaw, Charles Daney, Ian Collier e Anders Christensen.

Cada um representa uma parte da evolução da linguagem.

O encontro tinha aproximadamente 130 participantes, o dobro do ano anterior.

Durante três dias, discutiram o REXX tradicional, sua evolução orientada a objetos, ferramentas de desenvolvimento, UNIX, Web, sistemas distribuídos, OS/2 e CICS.

Mas havia uma notícia que preocupava a comunidade.

A IBM havia anunciado a transferência do desenvolvimento de REXX de Endicott, nos Estados Unidos, para Böblingen, na Alemanha.

Segundo Melinda Varian, nenhum dos desenvolvedores existentes seria transferido junto com o projeto.

A autora demonstrou grande preocupação com essa decisão.

Ela estimou que a transferência poderia provocar um período de 18 a 24 meses de pouco avanço.

Essa estimativa era uma opinião registrada em 1995, não uma medição posterior do que efetivamente aconteceu.

O problema do conhecimento que desaparece

Imagine um sistema COBOL desenvolvido durante vinte anos.

Seu programador original conhece particularidades do código, regras de negócio, registros históricos e situações especiais que talvez nunca tenham sido documentadas.

Agora imagine que a equipe inteira seja substituída.

O código continua funcionando.

Os datasets continuam armazenados.

As transações CICS continuam sendo executadas.

Mas parte do conhecimento desaparece.

É exatamente essa a preocupação expressa por Varian.

Um dos maiores riscos de um sistema legado não é sua idade. É perder o conhecimento necessário para compreendê-lo e mantê-lo.

Essa lição permanece relevante para empresas que dependem de COBOL, PL/I, Assembler, REXX e JCL.

Dica Bellacosa Mainframe

Sempre que encontrar um programa antigo, investigue:

  1. Quem desenvolveu o programa?

  2. Qual problema empresarial ele resolve?

  3. Quais arquivos e tabelas utiliza?

  4. Quais outros programas dependem dele?

  5. Como é executado?

  6. Quais são seus códigos de retorno?

  7. Existem procedimentos documentados para recuperação de erros?

Documentação é uma forma de preservar conhecimento.

E conhecimento preservado reduz o custo de manutenção.


4. Episódio 3 — A IBM queria levar REXX para Linux

Entre os anúncios apresentados no simpósio estava uma novidade surpreendente.

A IBM planejava disponibilizar Object REXX para diferentes plataformas.

O cronograma divulgado incluía:

PlataformaPrevisão apresentada
LinuxJulho de 1995
PowerPCSetembro de 1995
OS/2Outubro de 1995
MVSDezembro de 1995
AIXDurante 1995
WindowsDurante 1995
VMMarço de 1996

Atenção: essas eram previsões divulgadas no evento, não comprovação de que todos os lançamentos ocorreram nas datas propostas.

O plano para Linux possuía uma característica especialmente interessante.

A IBM pretendia disponibilizar o código-fonte de sua implementação, permitindo que terceiros construíssem versões para outros sistemas UNIX e comercializassem suas soluções sem pagar royalties à empresa.

Não se tratava necessariamente de software livre nos moldes da GPL.

O anúncio estabelecia condições próprias.

Mesmo assim, para 1995, era uma decisão estratégica importante.

A IBM reconhecia que sua linguagem poderia ter um futuro além dos sistemas operacionais tradicionais da companhia.

Uma linguagem viajando entre planetas

Dentro da nossa analogia com Cowboy Bebop, cada sistema operacional representa um planeta.

VM/CMS é um dos mundos antigos.

MVS é uma enorme estação espacial corporativa.

OS/2 é uma colônia de computadores pessoais.

UNIX e Linux representam novos territórios.

REXX seria um viajante tentando circular entre todos eles.

Naturalmente, cada implementação possui particularidades.

Um script que executa comandos específicos de TSO não funcionará automaticamente em Linux.

A sintaxe básica pode ser semelhante, mas os comandos disponíveis dependem do ambiente.

Essa distinção é fundamental para iniciantes.

Portabilidade da linguagem não significa portabilidade automática de todos os programas.

Um script REXX que utiliza SAY, IF, DO e operações comuns sobre strings pode ser relativamente simples de adaptar.

Já um script que utiliza LISTDS, ALLOC, EXECIO ou serviços específicos de TSO/E exige um ambiente compatível ou alterações.


5. Episódio 4 — COBOL encontra REXX: duas linguagens, uma missão

Vamos imaginar uma empresa financeira.

Todos os dias, um programa COBOL processa movimentações e produz resultados.

O programa executa cálculos, valida registros e grava informações.

Mas alguém precisa preparar o ambiente, executar o processamento, conferir retornos e produzir relatórios.

É aqui que o REXX pode ajudar.

COBOL executa a regra de negócio.

JCL descreve e submete o trabalho em lote.

REXX pode automatizar tarefas operacionais e de desenvolvimento, inclusive a submissão de jobs e a análise de informações.

Vejamos um pequeno laboratório.

Laboratório 1 — Criando um programa COBOL para calcular saldos

Nosso programa inicial não acessará um banco de dados real nem movimentará dinheiro.

Ele trabalhará com valores fixos para facilitar a aprendizagem.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. SALDOB01.

       DATA DIVISION.
       WORKING-STORAGE SECTION.

       01 WS-SALDO-INICIAL PIC 9(7)V99 VALUE 1500.00.
       01 WS-DEPOSITO      PIC 9(7)V99 VALUE 250.00.
       01 WS-SAQUE         PIC 9(7)V99 VALUE 100.00.
       01 WS-SALDO-FINAL   PIC 9(7)V99 VALUE ZERO.
       01 WS-SALDO-EDIT    PIC Z(6)9.99.

       PROCEDURE DIVISION.

           COMPUTE WS-SALDO-FINAL =
               WS-SALDO-INICIAL
               + WS-DEPOSITO
               - WS-SAQUE

           MOVE WS-SALDO-FINAL TO WS-SALDO-EDIT

           DISPLAY "BELLACOSA MAINFRAME"
           DISPLAY "SALDO FINAL: " WS-SALDO-EDIT

           GOBACK.

Esse exemplo usa formato fixo tradicional de COBOL, apropriado para ilustrar fontes clássicos.

Vamos entender os elementos.

WORKING-STORAGE SECTION contém variáveis usadas durante a execução.

PIC 9(7)V99 define um campo numérico com sete posições inteiras e duas decimais implícitas.

A letra V não ocupa espaço físico no campo.

COMPUTE executa o cálculo.

MOVE transfere o resultado para um campo editado.

DISPLAY apresenta informações na saída do programa.

GOBACK retorna o controle ao chamador ou ao ambiente de execução.

O saldo esperado é:

1500 + 250 − 100 = 1650.

O programa deverá apresentar o valor formatado como 1650.00, com os espaços iniciais previstos no campo editado.

O que acontece num sistema real?

Em uma aplicação empresarial, esses valores provavelmente seriam obtidos de arquivos sequenciais, VSAM, Db2 ou outra fonte.

Também seria necessário verificar saldos insuficientes, tipos de operação, consistência dos registros e possíveis falhas.

O programa acima demonstra apenas o cálculo.

A vantagem é que o iniciante consegue compreender sua estrutura antes de acrescentar complexidade.

6. Episódio 5 — JCL: o controlador de tráfego da Bebop

No ambiente z/OS, programas batch frequentemente são executados por meio de jobs descritos em JCL.

JCL significa Job Control Language.

Não é uma linguagem de programação de aplicação como COBOL.

Sua função é informar ao sistema quais programas executar, quais recursos utilizar e como tratar entradas e saídas.

Supondo que nosso programa COBOL já esteja compilado e linkeditado numa biblioteca de carga, poderíamos utilizar um job semelhante ao seguinte:

//BELLJOB  JOB (ACCT),'BELLACOSA',
//             CLASS=A,MSGCLASS=X,
//             NOTIFY=&SYSUID
//*
//RUNCOB   EXEC PGM=SALDOB01
//STEPLIB  DD DSN=USER.COBOL.LOAD,DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//

Os nomes de dataset e os parâmetros do JOB são ilustrativos e devem ser adaptados às regras da instalação.

A instrução JOB identifica o trabalho.

EXEC PGM=SALDOB01 solicita a execução do programa.

STEPLIB informa uma biblioteca de carga em que o sistema poderá localizar o módulo executável.

SYSOUT e SYSPRINT representam definições de saída frequentemente utilizadas em jobs.

O que acontece quando o job é submetido?

O JES recebe o trabalho, verifica suas condições de execução e o encaminha conforme a configuração do sistema.

O programa é carregado.

O cálculo é executado.

A saída pode ser examinada no spool, utilizando SDSF ou ferramentas equivalentes.

Passo a passo no ambiente TSO/ISPF

Passo 1: acesse o ambiente de desenvolvimento autorizado.

Passo 2: crie um membro de fonte COBOL em uma biblioteca apropriada.

Passo 3: digite o programa SALDOB01.

Passo 4: compile o programa utilizando o procedimento de compilação disponível na instalação.

Passo 5: verifique mensagens de erro, warnings e o código de retorno.

Passo 6: confirme que o módulo executável foi gravado na biblioteca de carga.

Passo 7: adapte o JCL de execução.

Passo 8: submeta o job.

Passo 9: examine o resultado no SDSF.

Passo 10: compare o saldo apresentado com o valor esperado.

Em muitos ambientes educacionais, existem procedimentos de compilação prontos. Utilize-os antes de tentar construir um JCL de compilação completo.

Dica de veterano

Um código de retorno zero geralmente representa conclusão normal, mas o significado depende da aplicação e de seus contratos de execução.

Não trate todos os retornos diferentes de zero como iguais.

Investigue também mensagens, condições de execução e eventuais abends.

Uma aplicação pode produzir resultado incorreto mesmo terminando com retorno zero.

7. Episódio 6 — REXX entra na sala de controle

Agora precisamos automatizar parte da missão.

Suponha que o programador execute frequentemente o mesmo job COBOL.

Em vez de navegar manualmente até o membro JCL e submetê-lo repetidamente, podemos criar um pequeno exec REXX.

No TSO/E, uma forma de submeter um membro JCL é utilizar o comando SUBMIT.

/* BELLJOB - ENVIO DE JOB COBOL */

say "BELLACOSA MAINFRAME"
say "Iniciando submissao do job..."

address tso

"SUBMIT 'USER.JCL(BELLJOB)'"

say "Retorno do comando SUBMIT:" rc

exit rc

Observe os elementos.

ADDRESS TSO direciona os comandos ao ambiente TSO.

O comando SUBMIT envia o JCL ao JES.

A variável especial RC recebe o código de retorno do comando executado.

O programa apresenta esse valor e termina.

Importante: o retorno de SUBMIT não representa necessariamente o resultado final do processamento COBOL. Ele informa o retorno do comando de submissão.

O job pode ter sido aceito e ainda estar aguardando execução.

Para conhecer o resultado final, será necessário verificar o job no JES/SDSF ou usar uma interface apropriada de consulta.

Essa distinção evita um erro comum entre iniciantes.

Como executar o REXX

Em uma instalação TSO/E, você pode criar um membro chamado BELLJOB numa biblioteca REXX e executá-lo com uma instrução semelhante a:

EXEC 'USER.REXX(BELLJOB)' EXEC

A biblioteca precisa existir, e o usuário deve ter as permissões necessárias.

O nome USER é apenas ilustrativo.

Em ambientes reais, cada instalação define seus padrões de nomenclatura, segurança e autorização.

O que ganhamos?

Ganhamos repetibilidade.

Uma operação executada várias vezes pode ser encapsulada em um procedimento simples.

Mas não devemos exagerar.

O pequeno exec não substitui o monitoramento do JES, não resolve falhas de aplicações e não transforma automaticamente um programa COBOL em um serviço Web.

Ele automatiza uma tarefa específica.

E esse é justamente um dos segredos da produtividade: começar automatizando tarefas pequenas, repetitivas e bem compreendidas.

8. Episódio 7 — REXX dentro do CICS: uma revolução inesperada

Entre as apresentações mais interessantes do simpósio estava a de Bob Vogel, gerente de desenvolvimento da IBM.

Seu tema era REXX for CICS/ESA.

Para compreender a importância dessa apresentação, precisamos conhecer o CICS.

CICS significa Customer Information Control System.

Ele é um servidor de aplicações transacionais utilizado em ambientes empresariais.

Imagine milhares de usuários consultando saldos, registrando pedidos, atualizando contas ou realizando operações simultaneamente.

CICS ajuda a gerenciar a execução dessas transações, coordenando programas e recursos conforme a arquitetura da aplicação.

Historicamente, COBOL ocupa um lugar importante nesse ecossistema.

No simpósio de 1995, Bob Vogel apresentou uma implementação de REXX destinada ao CICS.

Ela utilizava como base o núcleo do interpretador TSO/E REXX.

A solução acrescentava recursos específicos para CICS, incluindo integração com Db2, editor de texto, shell interativo, facilidades de painéis e um sistema de arquivos baseado em VSAM.

A surpresa: produtividade de 10 a 20 vezes

Vogel relatou que sua equipe, composta principalmente de programadores COBOL/CICS, estimava ganhos de produtividade entre dez e vinte vezes em determinadas atividades realizadas com REXX.

Calma, jovem tripulante!

Isso não significa que um programa REXX execute vinte vezes mais rápido que um programa COBOL.

Também não demonstra que REXX seja universalmente superior ao COBOL.

A declaração se referia à produtividade percebida pelos desenvolvedores em seu contexto de trabalho.

São coisas completamente diferentes.

Uma ferramenta pode permitir construir um protótipo em poucas horas sem necessariamente oferecer o melhor desempenho para processar milhões de registros.

Quando utilizar cada tecnologia?

NecessidadeTecnologia frequentemente adequada
Regras empresariais complexasCOBOL
Aplicações transacionaisCICS com COBOL ou outras linguagens suportadas
Processamento batchCOBOL e JCL
Automação TSO/ISPFREXX
Consultas e atualização de dados relacionaisSQL/Db2
Organização da execução batchJCL/JES
Investigação de jobsSDSF e ferramentas associadas

Essas tecnologias podem colaborar.

Não precisam disputar espaço como inimigas.

O sucesso de uma arquitetura depende da combinação correta de responsabilidades.

9. Episódio 8 — Object REXX: quando a linguagem ganhou novos poderes

Outra grande atração do simpósio foi o Object REXX.

Rick McGuire apresentou funcionalidades relacionadas à programação orientada a objetos.

Para um iniciante, orientação a objetos pode parecer um conceito complicado.

Mas sua ideia básica é relativamente simples.

Imagine que precisamos representar uma conta bancária.

Uma conta possui características:

  • Número.

  • Titular.

  • Saldo.

  • Situação.

E possui operações:

  • Consultar saldo.

  • Depositar.

  • Sacar.

  • Bloquear.

Em programação orientada a objetos, podemos organizar parte desses dados e comportamentos numa estrutura chamada classe.

Os objetos são instâncias dessa classe.

A proposta do Object REXX era acrescentar recursos desse modelo à linguagem tradicional.

Exemplo conceitual em Object REXX

/* Exemplo para Object REXX / ooRexx */

conta = .Conta~new
conta~depositar(250)

say "Saldo:" conta~saldo

::class Conta

::attribute saldo get

::method init
  expose saldo
  saldo = 1000

::method depositar
  expose saldo
  use arg valor
  saldo = saldo + valor

Esse exemplo ilustra uma implementação moderna compatível com os conceitos centrais de Object REXX. Não deve ser interpretado como uma reprodução literal de uma demonstração de 1995.

A classe Conta define um objeto.

O método init estabelece o saldo inicial.

O método depositar altera o saldo.

O símbolo ~ é utilizado para enviar mensagens aos objetos.

Mas COBOL também possui orientação a objetos?

Sim. Existem extensões e funcionalidades de COBOL orientado a objetos, dependendo do compilador e do ambiente.

Entretanto, é importante diferenciar o COBOL procedural tradicional das implementações com recursos orientados a objetos.

Grande parte dos sistemas empresariais COBOL utiliza estruturas procedurais, chamadas de programas, divisões, seções, parágrafos e módulos.

Para quem está começando, é mais importante dominar primeiro:

  • Estrutura de programa.

  • Tipos de dados.

  • Instruções condicionais.

  • Laços.

  • Processamento de arquivos.

  • Chamadas entre programas.

  • Tratamento de erros.

Depois disso, aprender novos paradigmas torna-se muito mais fácil.

10. Episódio 9 — REXX na Internet antes de muita gente conhecer a Web

Talvez a apresentação mais visionária do simpósio tenha sido a de Les Cottrell e Bebo White.

O assunto era a construção de scripts CGI para a World Wide Web utilizando REXX.

CGI significa Common Gateway Interface.

Era uma maneira de permitir que servidores Web executassem programas externos para produzir respostas dinâmicas.

Imagine que alguém acessa uma página de consulta.

O servidor recebe a solicitação.

Um programa processa informações.

O resultado é devolvido ao navegador.

Hoje esse modelo parece bastante familiar.

Mas em 1995 a Web ainda estava em sua infância.

Segundo o relatório, o SLAC havia instalado o primeiro servidor Web dos Estados Unidos em setembro de 1991.

Os apresentadores demonstraram principalmente soluções UNIX utilizando Uni-REXX, mas também discutiram ambientes VM.

Um exemplo didático de resposta HTTP

Um script CGI muito simples poderia produzir algo semelhante a:

/* Exemplo conceitual de CGI com REXX */

say "Content-Type: text/html"
say
say "<html>"
say "<body>"
say "<h1>Bellacosa Mainframe</h1>"
say "<p>REXX e a historia da Web</p>"
say "</body>"
say "</html>"

Em um ambiente CGI devidamente configurado, a primeira linha define o tipo de conteúdo.

A linha vazia separa os cabeçalhos do corpo da resposta.

O restante forma uma pequena página HTML.

Naturalmente, um servidor real precisaria estar configurado para executar o interpretador e o programa com permissões apropriadas.

Esse exemplo tem finalidade histórica e educacional. Não é uma recomendação para publicar diretamente um CGI antigo na Internet atual.

O alerta de segurança de 1995

Os apresentadores também discutiram riscos de segurança.

Melinda Varian destacou o cuidado necessário com a instrução INTERPRET.

Em REXX, INTERPRET permite executar uma string como instruções da linguagem.

Imagine receber um texto de um usuário externo e executá-lo diretamente.

Se o conteúdo não for confiável, o resultado poderá ser extremamente perigoso.

A mesma categoria de problema aparece em outras linguagens quando desenvolvedores utilizam recursos equivalentes a eval com entradas não confiáveis.

Lição de segurança: nunca transforme dados fornecidos por usuários em comandos executáveis sem controles rigorosos.

Evitar a execução dinâmica de conteúdo externo costuma ser a abordagem mais segura.

Em sistemas empresariais, valide dados, restrinja permissões e utilize interfaces estruturadas.

Esse aviso já estava presente em 1995.

Os piratas digitais não nasceram ontem.

11. Episódio 10 — O grande segredo: REXX e a preservação dos sistemas legados

Uma das mensagens mais importantes do simpósio não estava relacionada a uma funcionalidade específica.

Era a preocupação com a continuidade tecnológica.

Melinda Varian registrou o receio de que a transferência da equipe de desenvolvimento provocasse perda de conhecimento.

Mike Cowlishaw explicou como a linguagem havia evoluído graças ao retorno de seus usuários.

Os participantes demonstraram interesse em manter a compatibilidade e ampliar a presença do REXX.

Tudo isso revela uma realidade que permanece fundamental nos ambientes mainframe.

Sistemas empresariais são construídos por pessoas.

Programas sobrevivem décadas porque equipes os mantêm, documentam, corrigem e adaptam.

Um sistema COBOL de 1985 pode continuar útil em 2026.

Mas sua manutenção dependerá de profissionais capazes de compreender tanto o código quanto as regras de negócio.

A idade do programa, isoladamente, não determina sua qualidade.

O que importa é sua confiabilidade, segurança, documentação, desempenho, suporte e capacidade de evolução.

Dica prática: seja um arqueólogo de código

Quando receber a missão de analisar um programa COBOL desconhecido, não comece alterando instruções.

Primeiro, investigue a estrutura.

Procure o PROGRAM-ID.

Identifique arquivos no FILE-CONTROL.

Examine os registros na FILE SECTION.

Observe variáveis na WORKING-STORAGE SECTION.

Localize o início do processamento na PROCEDURE DIVISION.

Procure instruções CALL, READ, WRITE, REWRITE, START e EXEC SQL.

Depois, construa um mapa das dependências.

Somente então prepare testes.

Se houver REXX associado ao processo, examine o que ele automatiza.

Se houver JCL, identifique o fluxo dos jobs.

Se houver CICS, investigue as transações, programas e recursos envolvidos.

Essa metodologia permite compreender o sistema antes de modificá-lo.

12. Episódio 11 — Um pequeno laboratório de automação

Vamos criar um segundo exemplo REXX.

Desta vez, nosso objetivo será validar dados numéricos antes de realizar um cálculo.

/* BELLVAL - VALIDACAO SIMPLES */

saldo = "1500.00"
deposito = "250.00"
saque = "100.00"

if \datatype(saldo, "N") |
   \datatype(deposito, "N") |
   \datatype(saque, "N") then do

   say "ERRO: VALOR NAO NUMERICO"
   exit 8
end

saldoFinal = saldo + deposito - saque

say "SALDO INICIAL:" saldo
say "DEPOSITO:" deposito
say "SAQUE:" saque
say "SALDO FINAL:" saldoFinal

exit 0

A função DATATYPE verifica características de um valor.

Com o argumento "N", podemos testar se o conteúdo corresponde a uma representação numérica aceita pelo interpretador.

O operador \ representa negação lógica.

O operador | representa OU lógico.

A estrutura IF ... THEN DO ... END permite executar várias instruções quando uma condição é verdadeira.

Esse exemplo é apenas uma validação introdutória.

Para operações financeiras reais, também seria necessário verificar escala decimal, limites, valores negativos, regras monetárias e consistência empresarial.

Exercício para o leitor

Modifique o programa para que o saque seja maior do que o saldo disponível.

Depois acrescente uma condição impedindo que o saldo fique negativo.

Uma possível solução é:

if saque > saldo + deposito then do
   say "ERRO: SALDO INSUFICIENTE"
   exit 12
end

Repare que agora estamos aproximando um script simples de uma regra de negócio.

É exatamente nesse ponto que o programador precisa pensar na responsabilidade de cada componente.

Uma validação feita em REXX não deve substituir os controles obrigatórios da aplicação COBOL que efetivamente processa a transação.

A segurança e a integridade devem ser garantidas no componente responsável pela operação.

13. Episódio 12 — Easter eggs e curiosidades do simpósio

Toda boa aventura possui seus segredos.

E o encontro de 1995 preservou alguns detalhes deliciosos para quem gosta da história da computação.

Easter egg 1 — A letra X de um milhão de dólares

Segundo Cowlishaw, a mudança do nome REX para REXX teria provocado custos internos estimados em aproximadamente um milhão de dólares.

O motivo envolvia atualizações de documentação e materiais já existentes.

Uma simples letra.

Um milhão de dólares.

É o tipo de história que demonstra como pequenas mudanças podem produzir enormes efeitos em ambientes corporativos.

Easter egg 2 — A mudança que quebrou milhões de programas

Cowlishaw também mencionou que a alteração de ARGS para ARG teria afetado aproximadamente 2,5 milhões de programas.

Essa quantidade era uma estimativa histórica apresentada pelo próprio criador da linguagem.

Para o programador COBOL iniciante, a lição é clara.

Alterar uma interface utilizada por outros sistemas pode produzir consequências muito maiores do que modificar uma variável local.

Compatibilidade é um patrimônio.

Easter egg 3 — O criador reconheceu os próprios erros

Cowlishaw comentou decisões que reconsideraria.

Entre elas estavam as comparações sensíveis a maiúsculas e minúsculas, o uso de DO em diferentes estruturas e a complexidade do mecanismo de parsing.

Essa atitude merece destaque.

Reconhecer limitações de projeto é uma qualidade importante de engenharia.

O fato de uma linguagem possuir milhões de usuários não significa que todas as escolhas originais tenham sido perfeitas.

Easter egg 4 — Perl virou motivo de brincadeira

Melinda Varian registrou uma piada em que Perl foi comparado ao REXX escrito apenas com caracteres especiais.

É uma brincadeira relacionada à conhecida densidade sintática de certas construções em Perl.

A curiosidade revela como as comunidades de programação já discutiam legibilidade, produtividade e estilos de linguagem.

Easter egg 5 — Os exemplos eram distribuídos em disquete

O simpósio começou com tutoriais apresentados por Chip Davis.

Os programas demonstrados foram disponibilizados no disquete do evento.

Hoje compartilhamos exemplos por repositórios digitais e plataformas de colaboração.

Naquela época, um pequeno disco magnético transportava parte do conhecimento técnico da conferência.

Easter egg 6 — Um problema real com ASCII, EBCDIC e PostScript

No final do relatório, Melinda Varian incluiu um exemplo de REXX e CMS Pipelines para processar um arquivo PostScript relacionado à proposta do padrão ANSI.

O arquivo apresentava diferenças nas terminações de linha e exigia conversões de caracteres.

A autora utilizou recursos de pipelines, conversão ASCII/EBCDIC e separação do documento em partes.

Esse trecho demonstra algo valioso: REXX também era uma ferramenta prática para resolver problemas de interoperabilidade entre sistemas.

Quem trabalha com mainframe conhece a importância de compreender codificações, formatos de registros e convenções de armazenamento.

Um arquivo aparentemente simples pode se tornar um quebra-cabeça quando atravessa plataformas.

14. Episódio 13 — O que o iniciante deve estudar depois dessa viagem?

A melhor maneira de aproveitar essa história é transformá-la em conhecimento prático.

Proponho uma trilha de estudos organizada em sete missões.

Missão 1 — COBOL básico. Aprenda a estrutura de um programa, campos PIC, instruções MOVE, DISPLAY, COMPUTE, IF, EVALUATE e PERFORM.

Missão 2 — JCL. Compreenda JOB, EXEC, DD, bibliotecas de carga, datasets, condições de execução e códigos de retorno.

Missão 3 — TSO/ISPF. Aprenda a navegar por bibliotecas, editar membros e localizar programas e jobs.

Missão 4 — REXX. Estude SAY, PARSE, IF, DO, DATATYPE, ADDRESS e o tratamento da variável RC.

Missão 5 — SDSF. Aprenda a consultar a execução de jobs, examinar saídas e interpretar mensagens.

Missão 6 — CICS e Db2. Conheça os fundamentos das aplicações transacionais e dos dados relacionais.

Missão 7 — Automação segura. Construa utilitários pequenos, documentados e testados para reduzir tarefas repetitivas.

O importante é não tentar aprender tudo simultaneamente.

Domine um fundamento.

Pratique.

Cometa erros em um ambiente autorizado de laboratório.

Leia as mensagens.

Corrija.

Depois avance.

Um programador não se torna experiente apenas assistindo a demonstrações.

Ele precisa executar, investigar e compreender.

15. Episódio 14 — O legado de 1995 em 2026

Trinta e um anos se passaram desde o simpósio.

O mercado de computação mudou profundamente.

A Internet se tornou infraestrutura essencial.

Linux passou a ocupar um lugar central em servidores e ambientes corporativos.

Serviços distribuídos, APIs, contêineres, computação em nuvem e inteligência artificial transformaram a maneira como construímos sistemas.

Mas COBOL continua presente em aplicações empresariais importantes.

REXX ainda é utilizado para automação em ambientes IBM Z.

JCL permanece essencial em muitos fluxos batch.

CICS e Db2 continuam associados a aplicações críticas.

Isso não significa que todos os planos apresentados em 1995 tenham se concretizado.

Alguns produtos evoluíram.

Outros perderam espaço.

Algumas arquiteturas foram substituídas por soluções diferentes.

O ponto importante é que a necessidade de integrar sistemas, preservar conhecimento e automatizar operações não desapareceu.

Ela apenas ganhou novas ferramentas.

Hoje podemos utilizar REXX para tarefas tradicionais, Python para automações externas, Zowe para interação com recursos z/OS, APIs para integração e ferramentas de DevOps para organizar entregas.

Cada tecnologia precisa ser avaliada conforme o ambiente, a segurança, o suporte e os objetivos do projeto.

A lição do simpósio é que modernização não começou com a computação em nuvem.

Ela já era uma preocupação concreta dos desenvolvedores de mainframe em 1995.

16. Episódio final — O último café da Bebop

Nossa nave retorna ao presente.

Spike Spiegel observa um antigo terminal.

Na tela, um programa COBOL apresenta seu resultado.

Ao lado, um pequeno exec REXX automatiza uma tarefa.

No spool do JES, um job termina normalmente.

Nada parece extraordinário.

Entretanto, cada componente carrega décadas de decisões arquiteturais, aprendizagem e engenharia.

O REXX nasceu da vontade de tornar a programação mais acessível.

O COBOL consolidou-se como instrumento fundamental para representar e executar regras empresariais.

O JCL organizou a execução de trabalhos.

O CICS ajudou a construir ambientes transacionais.

E os profissionais que desenvolveram essas tecnologias enfrentaram muitos dos mesmos problemas que encontramos hoje: produtividade, interoperabilidade, documentação, segurança e preservação do conhecimento.

O simpósio de 1995 nos ensina que o futuro raramente surge completamente separado do passado.

Muitas vezes ele nasce de uma melhoria aparentemente pequena, de uma necessidade operacional ou de uma ideia discutida entre programadores.

Como na jornada de Spike Spiegel, cada missão deixa alguma coisa para trás.

Algumas decisões não podem ser desfeitas.

Alguns erros continuam presentes.

Mas há sempre uma nova oportunidade para compreender melhor o sistema e construir uma solução mais elegante.

Para o novo programador COBOL, fica uma última recomendação.

Não trate o mainframe como uma caixa-preta.

Abra os manuais.

Leia os programas.

Experimente REXX.

Entenda JCL.

Investigue os jobs.

Aprenda com os profissionais que vieram antes.

E, quando encontrar um programa escrito há trinta ou quarenta anos, lembre-se de que alguém precisou imaginar, desenvolver, testar e colocar aquele código em produção.

Um sistema legado não é apenas um programa antigo. É uma história que continua sendo executada.

Até a próxima missão.

See you, Space Cowboy…


Referências históricas

  1. Melinda Varian — REXX Symposium, May 1995. Relatório do Sexto Simpósio Internacional de REXX, publicado em 1995.
    https://www.rexxla.org/events/1995/report.html

  2. Proceedings of the 6th International REXX Symposium. SLAC-R-95-464, Stanford Linear Accelerator Center.
    https://www.slac.stanford.edu/pubs/slacreports/reports21/slac-r-464.pdf

  3. Mike Cowlishaw — REXX 1995: The Growth of a Language. Apresentação histórica sobre as origens e a evolução do REXX, incluída nos anais do simpósio.

  4. REXX Language Association — Arquivo de apresentações históricas.
    https://www.rexxla.org/events/presentation.rsp

Nota editorial: os personagens e as situações envolvendo Spike Spiegel e a nave Bebop constituem uma homenagem narrativa a Cowboy Bebop. Não representam acontecimentos reais do simpósio. Os programas didáticos foram elaborados para este artigo, e não extraídos literalmente das apresentações históricas. Os números de mercado, previsões de lançamento e estimativas de produtividade são apresentados no contexto em que foram relatados em 1995.


Bellacosa Mainframe
Preservando o passado, compreendendo o presente e programando o futuro.

See you, Mainframe Cowboy…

terça-feira, 17 de março de 2026

O Que Todo Programador COBOL Padawan Precisa Saber Sobre Como o Java Evoluiu de uma Linguagem Acadêmica para um dos Pilares da Computação Moderna

 

Bellacosa Mainframe e a evolucao do java

☕ Um Café no Bellacosa Mainframe

A Evolução Contínua do Java

O Que Todo Programador COBOL Padawan Precisa Saber Sobre Como o Java Evoluiu de uma Linguagem Acadêmica para um dos Pilares da Computação Moderna

"Você não está apenas aprendendo Java. Está estudando uma linguagem que, assim como o COBOL, sobreviveu às mudanças tecnológicas, reinventou-se diversas vezes e continua sendo uma das plataformas mais importantes do planeta."


Introdução

Existe uma frase muito comum no mundo da tecnologia:

"Java morreu."

Curiosamente, ela é repetida praticamente todos os anos... há mais de vinte anos.

Enquanto isso...

  • Bancos continuam utilizando Java.

  • Empresas aéreas utilizam Java.

  • Amazon utiliza Java.

  • Netflix utiliza Java.

  • Google utiliza Java.

  • IBM utiliza Java.

  • Android nasceu utilizando Java.

  • Bilhões de dispositivos executam código Java diariamente.

Parece familiar?

Quem trabalha com COBOL já ouviu exatamente a mesma história.

Há décadas anunciam a morte do COBOL.

E, décadas depois, ele continua processando trilhões de dólares diariamente.

Java e COBOL compartilham algo muito raro:

São linguagens que aprenderam a evoluir sem abandonar seu passado.

Essa talvez seja sua maior qualidade.


O nascimento do Java

Em 1991, a Sun Microsystems iniciou um projeto chamado Green Project.

O objetivo inicial não era criar uma linguagem para internet.

Era desenvolver software para eletrodomésticos inteligentes.

O líder do projeto era James Gosling.

O primeiro nome da linguagem era...

Oak

(nome inspirado em um carvalho que existia em frente ao escritório.)

Como já existia outra linguagem chamada Oak, escolheram outro nome.

Durante uma reunião, enquanto tomavam café...

Surgiu o nome:

Java

Inspirado no famoso café produzido na ilha de Java, na Indonésia.

Coincidência?

Talvez seja por isso que um Café no Bellacosa Mainframe combina tanto com Java.


O maior acerto da história

Em 1995 surgiu um slogan que mudou a computação.

Write Once, Run Anywhere

Escreva uma vez.

Execute em qualquer lugar.

Na época isso parecia impossível.

Cada sistema operacional utilizava APIs diferentes.

Java resolveu esse problema através da JVM.


Bellacosa Mainframe timeline do java

A JVM

Ao contrário do COBOL, que normalmente gera código nativo para z/OS ou outro sistema operacional, Java gera um arquivo intermediário:

Bytecode

Esse bytecode é executado pela:

Java Virtual Machine

Resultado:

Windows

↓

Linux

↓

Mac

↓

IBM Z

↓

AIX

↓

Cloud

↓

Containers

Tudo executa exatamente o mesmo programa.

Foi uma revolução.


Java 8 — O novo começo (Março/2014)

Muitos especialistas dizem que existem dois Java:

Antes do Java 8.

Depois do Java 8.

E existe um bom motivo para isso.

Lambdas

Antes:

Collections.sort(lista,new Comparator<Pessoa>(){...});

Depois

lista.sort((a,b)->a.nome.compareTo(b.nome));

Muito menos código.

Muito mais legibilidade.


Stream API

Antes

for
if
for
if

Depois

clientes.stream()
.filter(...)
.map(...)
.collect(...)

A programação tornou-se declarativa.


Optional

Acabou boa parte dos famosos:

NullPointerException

Date and Time API

Finalmente uma API moderna para datas.


Curiosidade

O Java 8 ainda é uma das versões mais utilizadas no mundo corporativo.

Muitas empresas migraram diretamente do Java 8 para o Java 17 ou Java 21.


Java 9 — Modularização (Setembro/2017)

Projeto:

Jigsaw

Imagine o Java como um enorme sistema COBOL.

Antes era um único monólito.

Agora tornou-se modular.

Benefícios:

  • aplicações menores

  • inicialização mais rápida

  • segurança

  • encapsulamento


JShell

Pela primeira vez o Java ganhou um REPL.

Como o TSO READY.

Você digita.

Executa.

Vê o resultado.

Sem compilar projetos inteiros.


Java 10 (Março/2018)

Poucas novidades.

Mas uma delas mudou completamente o estilo de programação.

var

Antes

HashMap<String,List<Cliente>> mapa=

Depois

var mapa=

Muito mais simples.


Dica Bellacosa

var não significa linguagem fracamente tipada.

O tipo continua existindo.

O compilador apenas o deduz.


Java 11 LTS (Setembro/2018)

Primeira versão LTS após o Java 8.

Grande parte das empresas migrou diretamente para ela.


HTTP Client

Finalmente uma API moderna.

Sem bibliotecas externas.


TLS melhorado

Mais segurança.


Garbage Collection

Novos algoritmos.


Remoção do JavaFX

Agora distribuído separadamente.


Easter Egg

A Oracle removeu diversas APIs antigas.

Muitos sistemas antigos "pararam de compilar".

Foi um grande choque para empresas.


Java 17 LTS (Setembro/2021)

Talvez a maior evolução desde o Java 8.


Records

Antes

Classe

Construtor

Getter

Setter

Equals

HashCode

ToString

Depois

record Cliente(...)

Fim.


Sealed Classes

Controle rigoroso de herança.

Muito útil para arquiteturas grandes.


Pattern Matching

Menos código.

Mais clareza.


Curiosidade

Os compiladores modernos conseguem otimizar Pattern Matching melhor do que cadeias enormes de if.


Java 21 LTS (Setembro/2023)

Aqui aconteceu algo gigantesco.


Project Loom

Virtual Threads.

Imagine um CICS.

Agora imagine milhões de transações simultâneas.

Era necessário criar milhões de Threads.

Muito caro.

Agora...

Virtual Threads.

Criadas praticamente como objetos.

Muito mais leves.


Analogia Mainframe

No z/OS existe décadas de engenharia para lidar com milhares de usuários simultaneamente.

Java começou a aproximar-se dessa eficiência.


Sequenced Collections

Coleções finalmente ganharam ordenação consistente.


Record Patterns

Mais elegância.


Foreign Function & Memory API

Interoperabilidade sem JNI tradicional.


Java 23

Versão intermediária.

Não LTS.

Seu objetivo principal foi amadurecer recursos que chegariam às versões futuras.

Isso faz parte da estratégia moderna do OpenJDK: lançar inovações em ciclos rápidos para que sejam testadas e refinadas antes de integrarem uma versão LTS.

Entre os destaques estão a continuidade do aperfeiçoamento das Virtual Threads, do Pattern Matching e das APIs em incubação relacionadas à JVM, desempenho e experiência do desenvolvedor.


Java 25 LTS (Setembro/2025)

Mais uma versão de suporte de longo prazo.

O foco esteve em:

  • maior estabilidade

  • otimizações da JVM

  • melhor gerenciamento de memória

  • reforços de segurança

  • consolidação de recursos introduzidos nas versões anteriores

Para empresas, o Java 25 representa uma excelente opção para novos projetos corporativos que buscam longevidade.


Java 26 (Março/2026)

O Java 26 dá continuidade ao ciclo semestral do OpenJDK.

Embora não seja uma versão LTS, ela demonstra o compromisso da plataforma com evolução constante.

Os temas centrais incluem:

  • evolução da JVM

  • melhorias de performance

  • otimizações do compilador JIT

  • avanços em segurança

  • preparação para futuras funcionalidades voltadas à inteligência artificial, computação em nuvem e aplicações distribuídas

Mais do que adicionar recursos isolados, o Java 26 mostra que a plataforma continua refinando sua arquitetura para os desafios da próxima década.


O que um COBOL Padawan pode aprender com Java?

Muito mais do que sintaxe.

Java ensina conceitos modernos que complementam a experiência adquirida no mainframe.

Entre eles:

  • Programação Orientada a Objetos

  • APIs REST

  • Microsserviços

  • Containers

  • Kubernetes

  • Mensageria (Kafka, MQ)

  • Programação Funcional

  • Programação Reativa

  • Virtual Threads

  • Cloud Native

Todos esses conceitos dialogam cada vez mais com ambientes IBM Z modernos.


Curiosidades

☕ O mascote Duke

O mascote oficial do Java chama-se Duke.

Foi criado ainda na Sun Microsystems e continua sendo um dos símbolos mais conhecidos da linguagem.


☕ Java e COBOL convivem

É comum encontrar sistemas onde:

COBOL
↓

CICS

↓

MQ

↓

Java

↓

REST

↓

Angular

↓

Aplicativo

As duas linguagens não competem.

Elas colaboram.


☕ IBM Z executa Java

Muita gente acredita que Java é exclusivo da nuvem.

Na realidade, a IBM investe há décadas em uma JVM altamente otimizada para o IBM Z.

O resultado é a execução de aplicações Java com excelente desempenho, aproveitando recursos avançados do hardware, como criptografia, processamento paralelo e alta disponibilidade.


☕ Java também fala com COBOL

Existem várias formas de integração:

  • CICS Transaction Gateway

  • IBM MQ

  • z/OS Connect

  • JDBC

  • Web Services

  • APIs REST

  • JNI (em cenários específicos)

Essa interoperabilidade permite modernizar aplicações sem reescrever décadas de regras de negócio.


☕ Por que existem versões LTS?

Nem toda empresa pode atualizar seus sistemas a cada seis meses.

As versões Long-Term Support (LTS) recebem suporte prolongado, correções de segurança e estabilidade, tornando-se a escolha ideal para ambientes corporativos.


☕ A cadência de lançamentos

Desde 2018, o Java segue um calendário previsível:

  • Março → versão intermediária

  • Setembro → versão intermediária ou LTS (quando aplicável)

Essa previsibilidade facilita o planejamento de atualizações em grandes organizações.


Easter Eggs

☕ Duke escondido

Diversos exemplos oficiais da Oracle possuem pequenas aparições do Duke.

É quase um "Wally" para desenvolvedores Java.


☕ Café

O logotipo do Java representa uma xícara de café.

Até hoje.

Poucas linguagens possuem uma identidade visual tão reconhecida.


☕ Java e a Ilha de Java

O nome não veio da linguagem.

Veio do café.

E o café veio da ilha indonésia.


☕ O slogan que virou realidade

"Write Once, Run Anywhere" foi alvo de muitas piadas nos anos 1990 ("Write Once, Debug Everywhere"), mas a maturidade da JVM transformou essa promessa em uma das maiores vantagens da plataforma.


Dicas do Bellacosa Mainframe

  • Aprenda conceitos, não apenas sintaxe. Um bom engenheiro entende arquitetura antes de decorar comandos.

  • Mantenha-se em versões LTS para projetos corporativos, salvo quando houver necessidade de testar novidades.

  • Explore a JVM. Entender Garbage Collection, JIT e gerenciamento de memória faz tanta diferença quanto conhecer JCL e parâmetros de execução no mainframe.

  • Experimente o JShell. É uma excelente ferramenta para aprender rapidamente novos recursos da linguagem.

  • Estude integração com IBM Z. Java e COBOL convivem muito bem quando unidos por APIs, mensageria e serviços.


Conclusão

Java não é apenas uma linguagem de programação.

É uma plataforma que evoluiu continuamente por mais de três décadas, mantendo um raro equilíbrio entre inovação e compatibilidade. Assim como o COBOL, ela demonstra que tecnologias sólidas não sobrevivem por acaso: sobrevivem porque conseguem se adaptar às mudanças sem perder a confiança de quem depende delas.

Para um Programador COBOL Padawan, conhecer a evolução do Java significa ampliar sua visão sobre arquitetura de software, computação distribuída e modernização de sistemas. O futuro das aplicações corporativas não será construído escolhendo entre COBOL ou Java, mas integrando o melhor dos dois mundos.

No Bellacosa Mainframe, costumamos dizer que um bom profissional não segue modismos: ele compreende a história da tecnologia para tomar melhores decisões no presente. A trajetória do Java, da versão 8 à 26, é um excelente exemplo de como inovação contínua e estabilidade podem caminhar lado a lado — uma lição que vale tanto para a JVM quanto para o universo do IBM Z. Afinal, as linguagens passam por transformações, mas os princípios da boa engenharia permanecem. E é justamente essa mentalidade que transforma um Padawan em um verdadeiro Mestre da Computação.

sexta-feira, 31 de outubro de 2025

☕💣 “ACHAVA QUE REXX ERA SÓ SCRIPT?” — 10 COISAS QUE TODO PROGRAMADOR COBOL JUNIOR PADAWAN DESCOBRE TARDE DEMAIS NO MAINFRAME IBM Z 💣☕

 

Bellacosa Mainframe apresenta dicas sobre REXX Mainframe que todo padawan deve dominar

☕💣 “ACHAVA QUE REXX ERA SÓ SCRIPT?” — 10 COISAS QUE TODO PROGRAMADOR COBOL JUNIOR PADAWAN DESCOBRE TARDE DEMAIS NO MAINFRAME IBM Z 💣☕

Bellacosa Mainframe apresenta 10 coisas que um dev padawan deve saber e dominar


☕💣 PARA ENCERRAR UMA JORNADA DE REXX — COISAS QUE UM PROGRAMADOR COBOL JUNIOR PADAWAN DEVE SABER 💣☕

Depois de brincar com variáveis, loops, PARSE, EXECIO, ISPF, SDSF e automações mágicas do z/OS… chega o momento em que o jovem Padawan COBOL percebe uma verdade brutal do Mainframe:

👉 REXX não é “só uma linguagem de script”.
REXX é praticamente o “canivete suíço espiritual” do ambiente IBM Z.

É aquela ferramenta que o sysprog usa às 3h da manhã.
É o remendo elegante que salva um batch.
É o automóvel improvisado do operador.
É o cola-tudo universal do TSO/ISPF.

E quando você aprende REXX… você deixa de ser apenas alguém que “programa COBOL”.

Você começa a conversar com o sistema operacional. ☕


🔥 1. O COBOL PROCESSA NEGÓCIO. O REXX CONTROLA O UNIVERSO AO REDOR.

COBOL:

  • calcula folha

  • processa contas

  • fecha banco

  • gera extrato

REXX:

  • automatiza deploy

  • chama utilitários

  • cria menus ISPF

  • lê datasets

  • manipula spool

  • dispara comandos

  • conversa com DB2

  • conversa com CICS

  • conversa com SDSF

  • conversa com JES2

O COBOL é o motor da empresa.

O REXX é o técnico escondido atrás do painel elétrico. ☕


🔥 2. TODO MAINFRAMEIRO SÊNIOR SABE REXX

Isso é quase lei não escrita do IBM Z.

Você pode encontrar:

  • especialista em CICS

  • DBA DB2

  • operador

  • sysprog

  • storage admin

  • automação

  • segurança RACF

Todos usando REXX em algum momento.

Porque chega uma hora em que:
👉 fazer manualmente vira sofrimento.

E o REXX resolve.


🔥 3. O VERDADEIRO PODER ESTÁ NA INTEGRAÇÃO

O Padawan normalmente pensa:

“REXX é linguagem.”

O veterano pensa:

“REXX é integração.”

REXX conversa com:

  • ISPF

  • SDSF

  • TSO

  • JES2

  • DB2

  • CICS

  • USS

  • MQ

  • arquivos

  • datasets

  • comandos do sistema

É por isso que ele continua vivo há décadas.


🔥 4. O REXX ENSINA VOCÊ A ENTENDER O z/OS

Muita gente aprende COBOL sem entender:

  • alocação

  • datasets

  • spool

  • comandos

  • ISPF

  • utilities

  • catalog

  • LPAR

  • JES

Mas quando começa a automatizar com REXX…

☠️ você é obrigado a entender como o ambiente REAL funciona.

E isso acelera absurdamente sua evolução.


🔥 5. REXX É O “PYTHON DO MAINFRAME” ANTES DO PYTHON EXISTIR

Muito antes da moda DevOps…

o mainframe já tinha:

  • automação

  • scripts

  • parsing

  • manipulação textual

  • integração

  • produtividade

E o nome disso era:
☕ REXX.

Inclusive muita ideia moderna já existia ali:

  • scripting rápido

  • administração automatizada

  • wrappers

  • glue language

  • interfaces operacionais


🔥 6. O PROGRAMADOR JÚNIOR DESCOBRE O TRAUMA DO EXECIO

Todo mundo passa por isso.

Primeiro contato:

"EXECIO * DISKR ARQ (STEM DADOS."

Depois:

  • RC estranho

  • dataset vazio

  • stem quebrado

  • linha truncada

  • allocation faltando

E então nasce o verdadeiro mainframeiro.

Porque EXECIO não ensina apenas I/O.

EXECIO ensina humildade. ☕💀


🔥 7. PARSE É UMA DAS COISAS MAIS GENIAIS DO REXX

Quando o Padawan entende:

PARSE VAR LINHA NOME 1 SOBRENOME

a mente explode.

Porque o REXX foi criado para:

  • texto

  • comandos

  • produtividade

  • interpretação dinâmica

O PARSE parece simples…
mas é uma arma absurdamente poderosa.


🔥 8. REXX MOSTRA QUE O MAINFRAME NÃO É “ENGESSADO”

Muita gente de fora imagina:

“Mainframe é rígido.”

Aí o cara vê:

  • menus ISPF customizados

  • automações

  • painéis

  • ferramentas internas

  • monitoramentos

  • integrações

Tudo feito em REXX.

E percebe:
☕ o IBM Z é MUITO mais flexível do que parece.


🔥 9. TODO AMBIENTE TEM “O REXX LENDÁRIO”

Sempre existe.

Aquele EXEC antigo:

  • sem documentação

  • cheio de LABEL

  • cheio de PARSE

  • com 9 mil linhas

  • ninguém sabe quem criou

  • resolve tudo

  • ninguém tem coragem de apagar

O famoso:

“Se mexer nisso o banco para.”

☠️ patrimônio histórico do datacenter.


🔥 10. APRENDER REXX MUDA SUA VISÃO DE CARREIRA

O júnior COBOL pensa em:

  • programa

  • compile

  • JCL

  • output

O cara que aprende REXX começa a enxergar:

  • automação

  • produtividade

  • operação

  • observabilidade

  • tooling

  • administração

  • integração corporativa

E isso aproxima você:

  • do sysprog

  • do operador

  • do DBA

  • da infraestrutura

  • da arquitetura

Você deixa de ver só o programa.

Você começa a enxergar o ecossistema inteiro.


☕ A GRANDE VERDADE FINAL DO MAINFRAME

O REXX ensina algo muito importante:

👉 Mainframe não é só linguagem.
👉 Mainframe é ambiente.
👉 É integração.
👉 É operação.
👉 É automação.
👉 É disciplina.
👉 É convivência com sistemas gigantescos.

E quando o Padawan entende isso…

ele deixa de ser apenas “programador COBOL”.

☕💣 Ele começa lentamente a virar um verdadeiro Mainframeiro. 💣☕


sexta-feira, 24 de outubro de 2025

☕🔥💣 IMS SYSTEM PROGRAMMER: O LADO BRUTAL DO MAINFRAME QUE SEGURA O MUNDO EM PÉ

 

Bellacosa Mainframe e o IMS System Programmer

☕🔥💣 IMS SYSTEM PROGRAMMER: O LADO BRUTAL DO MAINFRAME QUE SEGURA O MUNDO EM PÉ

O que realmente faz um especialista IMS na IBM — e por que poucos conseguem dominar esse universo

Quando alguém escuta:

“IMS System Programmer”

muita gente imagina apenas:

  • instalar software

  • rodar jobs

  • olhar logs

😄

Mas a realidade é MUITO mais pesada.

Na prática, um especialista IMS trabalha literalmente no coração operacional do sistema financeiro mundial.

Porque quando:

  • ATM para

  • autorização de cartão falha

  • telecom cai

  • fila IMS trava

  • Shared Queue degrada

  • DBRC perde sincronismo

o problema não é “apenas TI”.

💣 O impacto pode custar milhões em minutos.

E é exatamente aí que entra o profissional IMS.


🚀 Instalar, Atualizar e Manter IMS com SMP/E

Essa é uma das tarefas mais clássicas — e perigosas — do mundo z/OS.

O:

SMP/E

(System Modification Program Extended)

é o sistema responsável por instalar e manter software no mainframe IBM.

No mundo distribuído você baixa instalador.

No mainframe você trabalha com:

  • FMID

  • HOLDDATA

  • APPLY

  • ACCEPT

  • CSI

  • zones

Ou seja:

engenharia cirúrgica de software corporativo.


☠️ O Terror do APPLY CHECK

Veteranos conhecem o ritual:

SET BDY(TGT1).
APPLY CHECK.

E então começa a tensão.

Porque um PUT errado pode:

💣 quebrar IMS
💣 afetar CICS
💣 impactar DB2
💣 gerar incompatibilidades de SYSPLEX

SMP/E não é apenas “instalação”.

É controle absoluto de manutenção em ambiente crítico.


🌳 Configurar IMS Transaction Manager

Aqui começa o verdadeiro mundo IMS.

O:

IMS TM

(Transaction Manager)

é o cérebro transacional do ambiente.

Ele controla:

  • mensagens

  • filas

  • transações

  • scheduling

  • regiões online

  • comunicação terminal/programa

Quando alguém faz:

💳 pagamento
🏧 saque
📱 consulta saldo

há grandes chances de um IMS TM estar trabalhando por trás.


⚡ IMS Shared Queue — O Monstro do Paralelismo

O Shared Queue foi criado para ambientes gigantescos.

Ele permite que múltiplos IMS compartilhem:

  • filas

  • mensagens

  • workload

em ambiente SYSPLEX.

Isso traz:

✅ escalabilidade
✅ failover
✅ balanceamento
✅ alta disponibilidade

Mas também traz:

😄 pesadelos operacionais.

Porque quando Shared Queue degrada…

o caos pode ficar lindo.


🧠 Common Service Layer — A Cola do Ecossistema

O:

CSL

(Common Service Layer)

é a camada que integra diversos componentes IMS modernos.

Ela fornece:

  • Operations Manager

  • Structured Call Interface

  • Resource Manager

Sem CSL, ambientes modernos IMS praticamente não existem mais.

É ele quem permite gerenciamento mais centralizado e inteligente.


🔥 DBRC — O Guardião da Integridade

Se existe uma entidade sagrada no IMS…

ela se chama:

DBRC

(Database Recovery Control)

O DBRC controla:

  • recovery

  • logs

  • image copy

  • autorização de banco

  • integridade operacional

Ele sabe:

✅ quais logs existem
✅ quais backups são válidos
✅ qual banco pode abrir
✅ quais datasets estão consistentes

Sem DBRC:

💣 recovery vira inferno.


☕ Easter Egg Mainframe

Veteranos dizem:

“No dia que o RECON quebra…
o DBA envelhece 10 anos.”

😄

E honestamente?

Não é exagero.


🌐 IMS Connect — O Portal Entre Mundos

Hoje o IMS conversa com:

  • APIs REST

  • Java

  • JSON

  • mobile banking

  • cloud híbrida

E quem faz muita dessa ponte é o:

IMS Connect

Ele permite integração TCP/IP moderna com o velho mundo DL/I.

Ou seja:

📱 aplicativo no celular
→ API REST
→ IMS Connect
→ IMS TM
→ COBOL
→ DL/I

Cyberpunk corporativo puro.


📊 Monitorar IMS com RMF e SMF

No mundo distribuído muita gente olha dashboard bonito.

No mainframe…

o profissional IMS olha:

  • SMF

  • RMF

  • throughput

  • EXCP

  • CPU

  • enqueue

  • response time

Porque aqui performance é religião.


🚀 SMF — O DNA do z/OS

O:

SMF

(System Management Facility)

registra praticamente tudo.

É o “gravador de caixa preta” do mainframe.

Você consegue analisar:

  • uso CPU

  • transações

  • I/O

  • locks

  • workload

  • comportamento do IMS


⚡ RMF — O Olho da Performance

O:

RMF

(Resource Measurement Facility)

mede:

  • CPU

  • canais

  • memória

  • coupling facility

  • workload

Num ambiente IMS gigantesco, RMF é praticamente um estetoscópio do sistema.


💣 Analisar Abends e Problemas Complexos

Aqui mora a parte mais brutal da profissão.

Porque quando aparece:

U0777
S0C4
DFSxxxx
ABEND878

o especialista IMS entra em modo guerra.

Ele precisa analisar:

  • dumps

  • logs

  • traces

  • control blocks

  • storage overlays

  • waits

  • contention

Muitas vezes sob pressão absurda.


🌳 Alta Disponibilidade — Onde o IMS Brilha

IMS foi criado para:

missão crítica contínua.

Então arquiteturas IMS modernas usam:

  • SYSPLEX

  • Shared Queue

  • Coupling Facility

  • XRF

  • Fast Path

  • HALDB

para entregar:

✅ uptime gigantesco
✅ failover rápido
✅ workload sharing
✅ resiliência extrema


🚀 Disaster Recovery — O Dia do Juízo Final

Todo ambiente sério IMS possui:

DR TEST

Porque eventualmente:

  • data center cai

  • storage falha

  • rede quebra

  • região inteira desaparece

E o IMS precisa sobreviver.

O time testa:

  • recovery

  • restart

  • log apply

  • DBRC

  • reconnect

  • queue rebuild

Tudo sob cronômetro.


⚔️ O Arsenal Obrigatório do Profissional IMS


🟦 JCL

O idioma operacional do z/OS.

Sem JCL você literalmente não entra no jogo.


🟩 TSO/ISPF

O cockpit do operador mainframe.


🟨 JES2

Gerencia jobs, spool e execução batch.


🟪 REXX

O canivete suíço do mainframe.

Automação.

Monitoramento.

Operação.

Recovery.


🟥 SYSPLEX

O conceito que permite múltiplos z/OS trabalharem como um único sistema gigante.

Fundamental para IMS moderno.


☕ O Grande Segredo do Mundo IMS

O mercado moderno adora falar sobre:

  • cloud

  • microservices

  • kubernetes

  • serverless

Mas existe um detalhe curioso:

Boa parte das transações financeiras globais ainda depende de profissionais que dominam:

  • IMS

  • DL/I

  • DBRC

  • Shared Queue

  • SYSPLEX

  • SMP/E

Tecnologias criadas décadas atrás…

mas ainda absurdamente eficientes.


🚀 O Último Bastião da Engenharia Hardcore

Talvez seja isso que torne o universo IMS tão fascinante.

Ele não foi construído para ser bonito.

Foi construído para:

  • sobreviver

  • escalar

  • performar

  • resistir

E enquanto muita tecnologia moderna luta para manter estabilidade básica…

o velho IMS continua processando bilhões de transações silenciosamente.

Como um dinossauro mecânico escondido no subsolo do sistema financeiro mundial.


terça-feira, 21 de outubro de 2025

SCHEDULING: A Verdade Assustadora Sobre a Migração de CA-7, Control-M, ESP, Jobtrac e Zeke para IBM Z Workload Scheduler no IBM z17

 

Bellacosa Mainframe e a migração de scheduling mainframe

☕💣🚨 PADAWAN, NINGUÉM SABE COMO O BATCH FUNCIONA!

A Verdade Assustadora Sobre a Migração de CA-7, Control-M, ESP, Jobtrac e Zeke para IBM Z Workload Scheduler no IBM z17

Existe uma frase que todo profissional experiente de Mainframe já ouviu pelo menos uma vez na vida:

"Não mexe nisso porque ninguém sabe exatamente como funciona."

Normalmente ela aparece durante uma reunião de mudança.

Alguém aponta para um job.

Outro aponta para um scheduler.

Um terceiro pergunta:

— Quem criou isso?

Silêncio.

— Quem mantém isso?

Mais silêncio.

— O que acontece se parar?

Todos ficam nervosos.

Bem-vindo ao mundo real dos schedulers corporativos.

Durante décadas, empresas construíram verdadeiras cidades invisíveis dentro de ferramentas como CA-7, Control-M, ESP, Jobtrac, OPC, OPCESA, IWS, Zeke e Zebb.

Milhares de jobs.

Milhões de execuções.

Bilhões de dólares movimentados.

E, em muitos casos, sem documentação adequada.

Agora imagine o desafio de migrar tudo isso para IBM Z Workload Scheduler (IWS), rodando sobre um moderno IBM z17.

Parece simples?

Não é.

Na realidade, essa é uma das operações mais delicadas que podem acontecer dentro de um ambiente IBM Z.

E existe um motivo muito simples para isso:

O scheduler não é apenas uma ferramenta.

Ele é a memória operacional da empresa.


O Scheduler É o Maestro Invisível

Muita gente acredita que o Mainframe gira em torno de COBOL.

Outros dizem que o coração do ambiente é o DB2.

Há quem defenda o CICS.

Todos estão parcialmente certos.

Mas existe uma verdade que poucos percebem.

Quem coordena tudo é o scheduler.

Imagine uma orquestra.

Os instrumentos são:

  • COBOL

  • PL/I

  • Natural

  • Easytrieve

  • SAS

  • DB2

  • IMS

Os músicos são:

  • Operadores

  • Analistas

  • Desenvolvedores

  • Sysprogs

Mas o maestro é o scheduler.

Sem ele, cada instrumento toca em um momento diferente.

O resultado é caos.

É o scheduler que determina:

  • Quando um job inicia

  • Quem deve executar antes

  • Quem deve executar depois

  • Quem depende de arquivos

  • Quem depende de eventos

  • Quem depende de horários

  • Quem depende de calendários

Ele controla o fluxo invisível que movimenta bancos, seguradoras, governos, operadoras e bolsas de valores.


O Problema Que Ninguém Enxerga

Quando uma empresa anuncia:

"Vamos migrar de CA-7 para IWS."

Muitos imaginam algo parecido com:

Converter definições.

Importar schedules.

Executar testes.

Entrar em produção.

Fim.

Na prática, isso representa talvez 20% do trabalho.

Os outros 80% consistem em descobrir o que realmente está acontecendo.

Porque ao longo dos anos surgiram:

  • Exceções

  • Gambiarras

  • Automatizações locais

  • Processos esquecidos

  • Regras não documentadas

Em muitos ambientes existem jobs executando diariamente há mais de vinte anos sem que ninguém saiba exatamente por quê.

Eles simplesmente existem.

E continuam funcionando.


O Cemitério dos Funcionários Aposentados

Todo grande ambiente Mainframe possui fantasmas.

Não estamos falando de software.

Estamos falando de conhecimento.

O analista que criou a aplicação aposentou-se em 2003.

O operador que entendia o calendário fiscal saiu em 2008.

O administrador que configurou o scheduler foi embora em 2012.

Mas seus jobs continuam vivos.

Suas dependências continuam funcionando.

Suas regras continuam sendo executadas.

E ninguém sabe exatamente como.

A migração acaba funcionando como uma escavação arqueológica.

Cada schedule analisado revela decisões tomadas décadas atrás.


O Universo Oculto das Dependências

Considere uma cadeia aparentemente simples:

JOBA

↓

JOBB

↓

JOBC

Parece fácil.

Mas quando a equipe começa a investigar, descobre algo diferente.

JOBA gera um GDG.

JOBB processa o GDG.

JOBC só executa se o retorno do JOBB for menor que 8.

Além disso:

  • Existe um calendário especial.

  • Existe uma exceção de fechamento.

  • Existe uma regra para feriados estaduais.

  • Existe um trigger de dataset.

  • Existe um evento externo.

De repente aquilo que parecia trivial transforma-se numa rede extremamente complexa.

É exatamente nesse momento que muitas migrações falham.

O Scheduler Como Banco de Conhecimento

Um scheduler antigo acumulou durante anos:

  • Conhecimento operacional
  • Regras de negócio
  • Dependências técnicas
  • Procedimentos de recuperação

Exemplo:

JOBA
↓
JOBB
↓
JOBC

Parece simples.

Mas na realidade pode existir:

JOBA
↓
JOBB
↓
JOBC
↓
Espera arquivo FTP
↓
Dispara evento
↓
Valida dataset
↓
Executa apenas dia útil
↓
Ignora feriados estaduais
↓
Executa calendário especial de fechamento

Essas regras nem sempre estão documentadas.


O Legado de Cada Scheduler

Cada ferramenta possui uma filosofia própria.

E é justamente aí que mora o perigo.

CA-7

O CA-7 cresceu dentro do universo z/OS como uma poderosa plataforma baseada em requisitos e dependências.

Muitas empresas exploraram recursos avançados como:

  • Requirements

  • Dataset Triggering

  • Deadlines

  • Late Jobs

  • Forecasting

Após décadas de customizações, o ambiente torna-se praticamente uma linguagem própria.


Control-M

O Control-M trouxe uma abordagem mais moderna.

Smart Folders.

Eventos.

Variáveis.

Fluxos visuais.

Integrações distribuídas.

O desafio da migração está em reproduzir conceitos que nem sempre possuem equivalência direta dentro do IWS.


ESP

O ESP é frequentemente considerado um dos schedulers mais sofisticados do mundo Mainframe.

Sua capacidade de automação baseada em eventos é impressionante.

Mas essa mesma flexibilidade cria um problema.

Grande parte da lógica operacional pode estar escondida dentro de:

  • Macros

  • Procedures

  • Scripts

Descobrir tudo isso exige uma verdadeira investigação forense.


Jobtrac

O Jobtrac costuma esconder sua complexidade atrás de uma aparência simples.

Mas muitas vezes existem décadas de exceções acumuladas.

São justamente essas exceções que costumam quebrar durante a migração.


Zeke e Zebb

Veteranos do Mainframe conhecem bem esses nomes.

Ainda existem ambientes gigantescos executando processos críticos através deles.

Frequentemente acompanhados de:

  • CLISTs

  • REXX

  • Ferramentas locais

  • Automatizações artesanais

São ambientes extremamente poderosos, porém fortemente dependentes de conhecimento histórico.


O IBM z17 Muda o Jogo

A chegada do IBM z17 cria uma nova realidade operacional.

Mais CPU.

Mais memória.

Mais paralelismo.

Mais integração com IA.

Mais observabilidade.

Mais automação.

Porém existe um efeito curioso.

Problemas antigos tornam-se mais visíveis.

Jobs que antes eram executados de forma sequencial agora podem disputar recursos simultaneamente.

Dependências mal definidas aparecem.

Gargalos históricos tornam-se evidentes.

O z17 não cria os problemas.

Ele apenas ilumina problemas que sempre existiram.


A Descoberta de Dependências

A etapa mais importante de toda migração.

Muitos especialistas consideram essa fase mais importante do que a própria conversão.

O objetivo é responder uma pergunta simples:

"O que realmente depende do quê?"

Parece fácil.

Mas não é.


Análise Profunda de JCL

O JCL é um mapa oculto de dependências.

Um IF/THEN pode alterar completamente o fluxo operacional.

Um COND pode impedir a execução de dezenas de etapas.

Uma simples alteração de RC pode desencadear comportamentos inesperados.

Por isso a análise moderna precisa identificar:

  • EXEC

  • PROC

  • INCLUDE

  • IF/THEN/ELSE

  • COND

  • Restart Points

Tudo isso influencia diretamente a modelagem do scheduler.


O Poder dos Datasets

Datasets contam histórias.

Um arquivo criado por um job normalmente será consumido por outro.

Mapear essas relações permite construir um grafo operacional real.

Em grandes bancos encontramos:

  • Centenas de milhares de datasets

  • Milhares de GDGs

  • Dependências cruzadas

Muitas vezes o scheduler original utilizava apenas o dataset como mecanismo de sincronização.

Se isso não for identificado, a migração falha.

Dataset Flow

Mapeamento de:

//OUTFILE DD DSN=FIN.ARQ.SAIDA

para

//INFILE DD DSN=FIN.ARQ.SAIDA

Criando uma cadeia real de dependências.


GDGs

Muitas dependências estão escondidas em:

DSN=ARQ.CLIENTE(+1)

ou

DSN=ARQ.CLIENTE(0)

O scheduler antigo pode usar triggering baseado nesses datasets.


Catalog Search

Análise de:

  • ICF Catalog
  • SMS
  • GDG Bases

para descobrir relacionamentos não documentados.


O Mundo Esquecido do TSO/ISPF

Aqui mora uma das maiores armadilhas.

Muitas organizações acreditam que todos os jobs passam pelo scheduler.

Nem sempre.

Existem submissões originadas por:

  • REXX

  • CLIST

  • Painéis ISPF

  • Skeletons

  • Ferramentas internas

Às vezes um usuário executa um painel ISPF que gera JCL dinamicamente.

Esse JCL dispara outros jobs.

Que disparam outros processos.

E nada disso aparece claramente no scheduler.

É por isso que uma análise séria precisa incluir todo o ecossistema TSO/ISPF.


Engenharia Reversa do Batch

A migração moderna exige construir um mapa completo do ambiente.

Imagine visualizar:

  • 30.000 jobs

  • 50.000 dependências

  • 10.000 datasets

  • 500 calendários

Tudo conectado.

Esse mapa permite identificar:

  • Gargalos

  • Loops

  • Dependências órfãs

  • Processos redundantes

Muitas empresas descobrem pela primeira vez como seu batch realmente funciona.

Engenharia Reversa de Dependências

Ferramentas modernas constroem grafos completos.

Exemplo:

PAYROLL
├── EMPLOYEE
├── BENEFITS
├── TAX
└── REPORTS

O desafio passa a ser visualizar.

Não apenas converter.


Parallel Tracking: A Fase da Verdade

Nenhum projeto sério faz o corte diretamente.

Primeiro vem o Parallel Tracking.

O scheduler antigo continua operando.

O novo acompanha silenciosamente.

Comparando:

  • Horários

  • Dependências

  • Eventos

  • Return Codes

A cada divergência surge uma oportunidade de aprendizado.

Essa fase costuma revelar dezenas ou centenas de inconsistências que jamais haviam sido percebidas.

Comparar resultados.


Fase 1

Somente observação.

IWS simula.

Não dispara nada.


Fase 2

Shadow Execution.

IWS acompanha:

  • Start times
  • End times
  • RCs

Fase 3

Controlled Production

Parte da carga executa pelo novo scheduler.

Parte pelo antigo.


Fase 4

Cutover

Desligamento definitivo.


Validação de Schedules

Uma validação madura verifica:

Calendários

Dias úteis.

Feriados.

Fechamentos.

Ano fiscal.


Dependências

Job predecessor.

Successor.

Conditional logic.


Eventos

Arquivo recebido.

Dataset criado.

Mensagem emitida.

RC específico.


SLA

O scheduler novo deve cumprir:

  • Tempo de início
  • Tempo de término
  • Deadline 

Os Erros Clássicos

Após participar de inúmeros projetos, alguns padrões se repetem.

Job Não Dispara

Normalmente causado por dependência esquecida.

Job Dispara Antes

Calendário incorreto.

Trigger Perdido

Dataset mudou de nome.

Dependência Fantasma

Job espera algo que já não existe.

Loop Operacional

Um job espera outro.

Que espera o primeiro.

Resultado:

Nada acontece.


O Papel do Troubleshooting Moderno

No passado, investigar problemas exigia navegar por:

  • JESMSGLG

  • JESJCL

  • SYSLOG

  • SDSF

Hoje o cenário mudou.

Ferramentas modernas permitem correlacionar:

  • Eventos

  • Dependências

  • Métricas

  • Logs

  • Consumo de recursos

Tudo em tempo real.

Os incidentes mais comuns são:


Job Não Dispara

Causa:

Dependência perdida.

Exemplo:

Dataset trigger não convertido.


Job Dispara Antes da Hora

Causa:

Calendário incorreto.


Loop de Dependência

Muito comum.

Exemplo:

JOBA espera JOBB
JOBB espera JOBA

Deadlock operacional.


Dependência Fantasma

Job espera um predecessor que já não existe.

Foi removido anos atrás.

Mas continua cadastrado.


Dataset Nunca Criado

Erro clássico.

JCL correto.

Scheduler correto.

Mas o dataset trigger mudou de nome.


Observabilidade no IBM z17

O verdadeiro salto ocorre quando o IWS passa a conversar com ferramentas modernas.

OMEGAMON.

RMF.

SMF.

Instana.

IBM Z Operations Analytics.

Z APM Connect.

Agora é possível enxergar:

  • Fluxos completos

  • Tendências

  • Crescimento da janela batch

  • Jobs reincidentes

  • Processos problemáticos

Não estamos mais falando apenas de scheduling.

Estamos falando de inteligência operacional.


A Chegada da Inteligência Artificial

Talvez a transformação mais interessante dos próximos anos.

Imagine um ambiente capaz de identificar:

  • Dependências suspeitas

  • Calendários inconsistentes

  • Tendências de atraso

  • Possíveis violações de SLA

antes que o problema aconteça.

Com o z17, essa visão deixa de ser ficção.

A IA passa a atuar como um analista operacional virtual.

Monitorando milhares de eventos simultaneamente.

Detectando padrões invisíveis ao ser humano.


O Verdadeiro Objetivo da Migração

O maior erro é tratar a migração como substituição de software.

Não é.

A migração é uma oportunidade rara.

Uma oportunidade de documentar décadas de conhecimento.

De eliminar dependências obsoletas.

De corrigir erros históricos.

De modernizar processos.

De criar governança.

De preparar o ambiente para os próximos vinte anos.


Conclusão: O Scheduler Nunca Foi Apenas um Scheduler

Ao final de uma grande migração, muitas equipes chegam à mesma conclusão.

O problema nunca foi o CA-7.

Nunca foi o Control-M.

Nunca foi o ESP.

Nunca foi o Jobtrac.

Nunca foi o Zeke.

O verdadeiro desafio sempre foi compreender o ecossistema invisível que sustenta a operação.

Porque dentro de cada scheduler existe muito mais do que jobs.

Existem décadas de decisões.

Décadas de conhecimento.

Décadas de regras de negócio.

Décadas de experiência operacional.

E quando uma organização decide migrar para IBM Z Workload Scheduler em um moderno IBM z17, ela não está apenas trocando uma ferramenta.

Ela está reconstruindo o mapa que conecta toda a empresa.

E talvez essa seja a maior descoberta de todas.

O scheduler não controla apenas jobs.

Ele controla o tempo.

E, dentro de uma grande corporação, tempo é exatamente aquilo que mantém o negócio vivo.

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