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

quarta-feira, 11 de novembro de 2026

🦖 MIKE COWLISHAW E O DINOSSAURO QUE APRENDEU A AUTOMATIZAR O MAINFRAME: REXX, A LINGUAGEM NASCIDA ÀS 3 DA MADRUGADA QUE CONQUISTOU O z/OS!

 

Bellacosa Mainframe e uma revisão do rexx

☕ UM CAFÉ NO BELLACOSA MAINFRAME

🦖 MIKE COWLISHAW E O DINOSSAURO QUE APRENDEU A AUTOMATIZAR O MAINFRAME: REXX, A LINGUAGEM NASCIDA ÀS 3 DA MADRUGADA QUE CONQUISTOU O z/OS!

De uma ideia concebida em 1979 aos ambientes IBM Z de 2026: sob a ótica de Mike Cowlishaw, vamos descobrir como uma linguagem criada para simplificar a programação se transformou numa poderosa ferramenta de automação. Uma jornada por COBOL, JCL, TSO, ISPF, EXECIO, Data Stack, LINKMVS, SYSREXX, DevOps e os perigos silenciosos de um script que funciona perfeitamente — até chegar à produção.

Bellacosa Mainframe — Arqueologia da Computação, IBM Z, COBOL, REXX, Automação e os Mistérios da Tecnologia



🎬 Prólogo — 03h17: o homem que acordou com uma linguagem de programação na cabeça

Inglaterra, 20 de março de 1979.

Enquanto boa parte do mundo dormia, um engenheiro da IBM acordava com uma ideia que mudaria discretamente a história da programação.

Seu nome era Mike Cowlishaw.

Naquela época, os computadores pessoais ainda estavam conquistando espaço, os mainframes dominavam o processamento corporativo e escrever programas exigia familiaridade com linguagens, comandos e convenções nem sempre intuitivas.

Cowlishaw enxergava um problema que muitos especialistas pareciam aceitar como inevitável: por que as linguagens de programação precisavam impor tantas dificuldades aos seus usuários?

Por que transformar tarefas simples em exercícios de memorização de símbolos e regras?

Segundo o relato histórico preservado pela Rexx Language Association, naquele dia ele despertou por volta das três da madrugada com uma visão clara do que pretendia desenvolver. Ao final do dia, já havia compartilhado uma especificação inicial para receber comentários.

Era o nascimento do REXX.

Décadas depois, em novembro de 2026, imaginemos o mesmo Mike Cowlishaw entrando num moderno centro de processamento IBM Z.

Diante dele, monitores exibem jobs executando no JES2, aplicações COBOL processam informações bancárias, operadores investigam mensagens pelo SDSF e desenvolvedores utilizam ferramentas modernas de automação.

Em uma tela, aparece um programa:

/* REXX */
say 'Bom dia, Mainframe!'

Cowlishaw sorri.

A linguagem criada para tornar a programação mais acessível continua viva.

Mas ele encontra algo ainda mais interessante.

Aquele pequeno programa agora pode fazer parte de sistemas que consultam datasets, executam comandos, monitoram processos e integram aplicações escritas em diferentes linguagens.

O pequeno script cresceu.

E o dinossauro aprendeu a automatizar seu próprio castelo.

Esta cena é uma dramatização literária. A história do nascimento do REXX e os princípios de Cowlishaw são documentados; o encontro imaginário em 2026 não aconteceu.



🧠 Capítulo I — Quem é Mike Cowlishaw e por que devemos estudar sua filosofia?

Mike Cowlishaw é um cientista da computação britânico conhecido por seu trabalho no desenvolvimento do REXX e por contribuições posteriores ao processamento decimal em computadores.

No final dos anos 1970, ele trabalhava no laboratório da IBM em Hursley, na Inglaterra.

Sua preocupação não era simplesmente criar mais uma linguagem.

Ele buscava uma ferramenta que pudesse ser compreendida por profissionais de informática e também por usuários que não fossem programadores especializados.

O nome REXX representa REstructured eXtended eXecutor.

O projeto recebeu contribuições e comentários de usuários durante seu desenvolvimento. Essa característica é fundamental para compreender sua filosofia.

Em vez de criar uma linguagem pensando exclusivamente na facilidade de implementação do interpretador, Cowlishaw procurou observar as necessidades de quem realmente escreveria os programas.

Seu artigo The Design of the REXX Language, publicado no IBM Systems Journal em 1984, explica justamente essa preocupação com simplicidade, legibilidade e utilização prática.

O REXX foi apresentado publicamente em 1981, durante o SHARE 56, em Houston. Em 1983, passou a integrar oficialmente o ambiente VM/SP da IBM.

E aqui encontramos nossa primeira grande curiosidade.

🥚 Easter egg nº 1 — O REXX quase teve outro nome!

O projeto foi originalmente chamado REX, de Reformed EXecutor.

Segundo o histórico publicado pela IBM, o segundo X foi acrescentado para evitar problemas relacionados a marcas registradas.

Uma pequena alteração no nome ajudou a construir uma identidade que sobreviveria durante décadas.

A primeira lição de Cowlishaw é extraordinariamente atual:

Uma tecnologia não precisa ser difícil de compreender para ser poderosa.

E isso vale tanto para um estudante de COBOL em 2026 quanto para um programador que utilizava VM/CMS em 1983.



🖥️ Capítulo II — O castelo IBM Z: onde COBOL, JCL e REXX trabalham juntos

Imagine um enorme castelo tecnológico.

Dentro dele, milhares de programas COBOL processam pagamentos, atualizam saldos, consultam contratos, calculam juros e movimentam informações empresariais.

O COBOL representa os trabalhadores especializados, responsáveis pelas regras de negócio.

O JCL organiza o processamento batch, indicando programas, datasets, parâmetros e recursos necessários.

O JES2 recebe e gerencia os trabalhos submetidos.

O Db2 e o VSAM armazenam informações fundamentais.

O RACF controla identidades e permissões.

E o REXX?

O REXX atua como um assistente extremamente versátil.

Ele não precisa substituir os especialistas.

Sua função pode ser coordenar atividades, verificar condições, consultar resultados e eliminar procedimentos manuais repetitivos.

Considere uma operação noturna com cinco etapas:

  1. Verificar se o dataset de entrada está disponível.

  2. Validar os parâmetros do processamento.

  3. Executar ou preparar as operações autorizadas.

  4. Consultar resultados e códigos de retorno.

  5. Registrar o estado final para análise operacional.

Um operador poderia realizar parte dessas atividades manualmente.

Mas, quando as mesmas verificações precisam acontecer diariamente, surge uma oportunidade de automação.

É aqui que REXX se destaca.

Na apresentação APPDEV2, encontramos uma frase que resume essa relação:

"REXX não substitui COBOL. Ele substitui o humano apertando tecla."

A frase é uma metáfora, mas transmite uma distinção importante.

COBOL continua sendo especialmente adequado para a implementação de regras empresariais. REXX oferece uma maneira prática de automatizar diversas operações ao redor dessas aplicações.

Um não precisa eliminar o outro.

Em muitos ambientes, os dois trabalham melhor juntos.



📜 Capítulo III — Aprendendo REXX: o primeiro programa de um futuro Mestre Jedi

Vamos começar do zero.

Quem conhece COBOL perceberá imediatamente uma diferença.

No COBOL, normalmente declaramos variáveis e estruturas em seções específicas. No REXX, podemos trabalhar com variáveis de forma muito mais direta.

Nosso primeiro programa será:

/* REXX */
say 'Bem-vindo ao Bellacosa Mainframe!'

A primeira linha é um comentário.

A instrução SAY exibe uma mensagem.

Pronto!

Agora vamos introduzir uma variável:

/* REXX */
nome = 'Mike Cowlishaw'
ano = 1979

say nome
say 'Ano de nascimento do REXX:' ano

Resultado esperado:

Mike Cowlishaw
Ano de nascimento do REXX: 1979

Observe que não precisamos definir antecipadamente um campo PIC X(30) ou PIC 9(4).

Entretanto, essa flexibilidade traz responsabilidades.

Em COBOL, a definição de dados ajuda a organizar as informações. No REXX, o programador precisa estabelecer regras claras para os valores que suas variáveis podem receber.

Nosso primeiro processamento repetitivo

/* REXX */
do i = 1 to 5
  say 'Executando rotina numero' i
end

Resultado:

Executando rotina numero 1
Executando rotina numero 2
Executando rotina numero 3
Executando rotina numero 4
Executando rotina numero 5

O DO executa o bloco repetidamente.

O END encerra o bloco.

Para um iniciante, essa estrutura é fácil de compreender.

Mas vamos avançar.

/* REXX */
parse arg cliente

if cliente = '' then do
  say 'ERRO: cliente nao informado'
  exit 8
end

say 'Processando cliente:' cliente
exit 0

O comando PARSE ARG permite receber argumentos.

O código de retorno 8 indica, por convenção definida nesse exemplo, que houve uma falha de validação.

O código zero indica conclusão normal.

Dica de produção: não utilize códigos de retorno apenas como números decorativos. Documente seu significado, pois eles poderão influenciar decisões em JCL e ferramentas de automação.


🧩 Capítulo IV — Compound Variables: os arrays que não são exatamente arrays

Aqui começa uma das partes mais interessantes do REXX.

Imagine que precisamos armazenar informações de três clientes.

Podemos escrever:

/* REXX */
cliente.1 = 'ANA'
cliente.2 = 'BRUNO'
cliente.3 = 'CARLA'
cliente.0 = 3

do i = 1 to cliente.0
  say cliente.i
end

O resultado será:

ANA
BRUNO
CARLA

Para quem conhece arrays, parece um vetor convencional.

Mas existe uma diferença conceitual.

Em REXX, cliente.1, cliente.2 e cliente.3 são variáveis compostas.

A parte anterior ao ponto é chamada stem. A parte posterior pode ser construída dinamicamente.

Isso permite criar estruturas flexíveis, inclusive utilizando chaves textuais.

/* REXX */
cidade.ITATIBA = 'SAO PAULO'
cidade.LISBOA = 'PORTUGAL'
cidade.YORK = 'INGLATERRA'

say cidade.YORK

Entretanto, o funcionamento das caudas das variáveis compostas depende das regras de avaliação do REXX, que devem ser compreendidas antes de utilizar essas estruturas em aplicações complexas.

O perigoso valor padrão

Observe:

/* REXX */
saldo. = 0
saldo.123 = 500

say saldo.123
say saldo.999

Resultado:

500
0

O valor de saldo.999 não significa que uma conta com esse identificador foi encontrada.

Ele aparece porque estabelecemos zero como valor padrão para o stem.

Agora imagine uma aplicação bancária.

Uma conta com saldo zero existe.

Uma conta inexistente não existe.

Um saldo ainda não consultado é desconhecido.

São três situações diferentes.

Se nosso programa tratar todas como equivalentes, teremos um problema de lógica empresarial.

🥚 Easter egg nº 2 — O fantasma mora na variável que você não inicializou

A apresentação APPDEV2 alerta para um problema clássico: variáveis compostas podem conservar informações de operações anteriores.

Imagine carregar uma lista com cem clientes e, depois, carregar outra com apenas dez.

Se não houver limpeza adequada, elementos da primeira operação poderão permanecer na estrutura.

Para evitar resultados residuais, podemos usar:

drop cliente.

Também devemos validar se determinada variável foi inicializada.

/* REXX */
drop saldo.
saldo.123 = 500

if symbol('SALDO.999') = 'VAR' then
  say 'Variavel definida'
else
  say 'Variavel nao definida'

SYMBOL() é útil, mas não substitui a validação empresarial da existência do registro.

Lição de Cowlishaw aplicada à produção: simplicidade sintática não elimina a necessidade de compreender profundamente o comportamento dos dados.


📚 Capítulo V — Data Stack: a pilha que pode salvar ou sabotar sua automação

Imagine uma pequena agência dos correios.

As mensagens chegam, são armazenadas e posteriormente retiradas para processamento.

Essa é uma analogia útil para entender a Data Stack do REXX.

Duas instruções merecem atenção:

QUEUE adiciona informações ao final da fila.

PUSH coloca informações no início.

Considere:

/* REXX */
queue 'CLIENTE A'
queue 'CLIENTE B'
push 'URGENTE'

parse pull mensagem1
parse pull mensagem2
parse pull mensagem3

say mensagem1
say mensagem2
say mensagem3

A saída será:

URGENTE
CLIENTE A
CLIENTE B

Aqui encontramos duas estruturas clássicas de computação.

FIFO — First In, First Out: o primeiro elemento inserido é o primeiro a sair.

LIFO — Last In, First Out: o último elemento inserido é o primeiro a sair.

A Data Stack permite organizar fluxos temporários de informações, mas ela não é equivalente a um stem.

A pilha pertence ao contexto de execução e pode ser compartilhada por diferentes operações.

Um stem, por outro lado, é uma estrutura de variáveis submetida às regras de escopo do programa.

O perigo da stack suja

Imagine um exec que coloca vinte mensagens na stack, mas consome apenas quinze.

Sob determinadas condições, as cinco mensagens restantes podem interferir em operações posteriores.

A apresentação APPDEV2 resume o risco:

"Stack é compartilhada. Stem é sua."

É uma boa regra didática, embora existam mecanismos de compartilhamento e exposição de variáveis que exigem atenção.

Como isolar uma pilha temporária?

/* REXX */
call newstack

queue 'TAREFA001'
queue 'TAREFA002'

do while queued() > 0
  parse pull tarefa
  say 'Executando:' tarefa
end

call delstack

NEWSTACK estabelece uma nova pilha.

DELSTACK elimina essa pilha e retorna ao contexto anterior.

Dica: em uma aplicação real, estruture também o tratamento de erros para assegurar que os recursos temporários sejam liberados mesmo diante de falhas.


💾 Capítulo VI — EXECIO: quando o REXX abre as portas dos datasets

Agora entramos no território clássico do mainframe.

O mundo IBM Z trabalha intensamente com datasets.

Para um iniciante em COBOL, acessar um arquivo frequentemente significa aprender SELECT, FD, OPEN, READ, WRITE e CLOSE.

O REXX possui uma alternativa poderosa no ambiente TSO/E: EXECIO.

Esse comando permite operações de leitura e escrita de registros em datasets compatíveis.

Passo 1 — Preparar o arquivo

Imagine um dataset sequencial denominado:

APPDEV2.DADOS.CLIENTES

Com os seguintes registros:

00001;ANA;1000
00002;BRUNO;2500
00003;CARLA;750

Passo 2 — Alocar o dataset

No ambiente TSO/E, podemos usar:

address tso

"ALLOC FI(ENTRADA) DA('APPDEV2.DADOS.CLIENTES') SHR"

ALLOC associa um dataset a um nome lógico, neste caso ENTRADA.

Passo 3 — Ler os registros

drop rec.

"EXECIO * DISKR ENTRADA (STEM rec. FINIS"
leituraRC = rc

DISKR realiza leitura.

STEM rec. armazena os registros em variáveis compostas.

FINIS encerra a utilização do arquivo nessa operação.

RC informa o resultado do comando.

Quando a leitura é concluída normalmente, rec.0 contém a quantidade de registros carregados.

Passo 4 — Percorrer os dados

do i = 1 to rec.0
  parse var rec.i codigo ';' nome ';' saldo
  say codigo nome saldo
end

O comando PARSE VAR permite separar os campos utilizando o ponto e vírgula como delimitador.

Passo 5 — Liberar o dataset

"FREE FI(ENTRADA)"

Naturalmente, precisamos verificar o código de retorno da alocação antes de executar a leitura e também validar o resultado da operação.

O que significa FINIS?

Uma dúvida frequente é imaginar que basta terminar a execução do programa para que o dataset tenha sido corretamente tratado.

A documentação IBM explica que alguns recursos podem ser liberados automaticamente ao final de determinados ambientes de execução.

Entretanto, recomenda explicitamente fechar os datasets quando não forem mais necessários.

Essa é uma excelente prática de programação defensiva.

🥚 Easter egg nº 3 — O número de registros não controla automaticamente o DISKW *

Ao escrever registros com EXECIO, podemos usar uma quantidade explícita:

"EXECIO" rec.0 "DISKW SAIDA (STEM rec. FINIS"

Ou o asterisco:

"EXECIO * DISKW SAIDA (STEM rec. FINIS"

Mas existe um detalhe: na escrita a partir de um stem, o asterisco não significa simplesmente utilizar o valor de rec.0.

O processamento pode continuar até encontrar uma variável não inicializada ou um registro nulo, conforme as regras documentadas.

Por isso, quando conhecemos a quantidade exata de registros, frequentemente é mais seguro indicá-la explicitamente.

Outra limitação importante: não devemos presumir que EXECIO oferece acesso direto a todas as organizações de datasets.

Para VSAM, especialmente arquivos indexados, devem ser consideradas interfaces apropriadas.


🚂 Capítulo VII — IKJEFT01 contra IRXJCL: dois caminhos para executar REXX em batch

Uma rotina que funciona perfeitamente no terminal pode falhar quando executada em batch.

Por quê?

Porque o ambiente importa.

A apresentação APPDEV2 destaca duas alternativas de execução.

IKJEFT01 executa comandos TSO/E em background.

IRXJCL permite executar REXX em um ambiente que não oferece automaticamente os mesmos serviços de uma sessão TSO/E.

Essa diferença afeta os comandos disponíveis e as dependências do programa.

Exemplo de JCL com IKJEFT01

//REXXJOB  JOB (ACCT),'REXX TESTE',
//             CLASS=A,MSGCLASS=X
//STEP01   EXEC PGM=IKJEFT01,DYNAMNBR=30
//SYSEXEC  DD DSN=APPDEV2.REXX.EXEC,DISP=SHR
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
  %TESTE
/*

O job executa o membro TESTE localizado na biblioteca informada em SYSEXEC.

Os parâmetros do JOB e os nomes de datasets precisam ser adaptados ao ambiente de cada organização.

E por que não utilizar sempre IRXJCL?

Porque a escolha depende das necessidades do programa.

Um exec que utiliza comandos TSO/E pode exigir um ambiente diferente de outro que executa apenas lógica REXX e serviços disponíveis em MVS.

Não existe um mecanismo universalmente superior.

Existe o mecanismo adequado à aplicação.

O inimigo invisível: PULL em batch

Veja este código:

say 'Digite o numero do cliente:'
pull cliente

Em um terminal interativo, alguém pode fornecer a informação.

Em batch, porém, a origem dos dados depende da stack e do fluxo de entrada disponibilizado.

O resultado pode ser completamente diferente daquilo que o programador imaginou.

É preferível receber informações explicitamente:

parse arg cliente

if cliente = '' then do
  say 'ERRO: parametro ausente'
  exit 8
end

A automação precisa saber exatamente o que fazer sem depender de uma pessoa diante da tela.


🔗 Capítulo VIII — LINK, LINKMVS e LINKPGM: quando REXX conversa com COBOL

Aqui encontramos uma das partes mais sofisticadas do material.

Imagine que uma empresa possua um programa COBOL escrito em 1995.

Esse programa calcula uma regra financeira utilizada há décadas.

Você precisa automatizar sua utilização, mas não deseja reescrever a lógica.

Seria possível chamar diretamente esse programa a partir de REXX?

Dependendo da interface, sim.

O z/OS oferece ambientes como LINK, LINKMVS e LINKPGM.

Entretanto, eles não representam simplesmente três nomes diferentes para a mesma funcionalidade.

A principal dificuldade está na convenção de passagem de parâmetros.

Alguns módulos esperam receber uma cadeia de caracteres.

Outros esperam uma lista de endereços.

Existem ainda diferenças relacionadas aos comprimentos dos parâmetros e à possibilidade de modificar informações fornecidas pelo chamador.

Um exemplo conceitual de integração:

/* REXX */
cliente = '00000123'

address linkpgm 'CONSULTA cliente'

say 'Retorno:' rc

Nesse exemplo, CONSULTA seria um módulo hipotético preparado para receber parâmetros pela interface correspondente.

Não basta possuir um programa COBOL compilado para garantir que qualquer uma dessas chamadas funcione.

É preciso verificar sua convenção de entrada, o layout de parâmetros, as exigências de runtime e as características do módulo.

Uma recomendação para iniciantes

Antes de integrar um programa COBOL a REXX:

  1. Identifique o módulo que será chamado.

  2. Consulte sua documentação de interface.

  3. Verifique os parâmetros esperados.

  4. Confirme a compatibilidade com o ambiente de chamada.

  5. Teste entradas válidas e inválidas.

  6. Examine os códigos de retorno.

  7. Documente o comportamento em caso de falha.

Esse processo é menos espetacular do que simplesmente escrever um comando LINK.

Mas é justamente ele que permite construir integrações confiáveis.


⚙️ Capítulo IX — REXX compilado: colocar um motor maior não conserta um carro quebrado

Uma dúvida inevitável surge quando os programas começam a crescer.

Se REXX é interpretado, por que não compilar tudo?

A IBM oferece tecnologia para compilar programas REXX.

A compilação pode melhorar o desempenho em determinadas circunstâncias, principalmente reduzindo parte do trabalho necessário para interpretar expressões e instruções.

Mas ela não transforma automaticamente um programa ruim em um programa eficiente.

Imagine um exec que demora cem segundos.

Durante vinte segundos, ele executa lógica REXX.

Nos oitenta segundos restantes, aguarda operações de entrada e saída.

Se a compilação reduzir o tempo da lógica pela metade, o processamento passará de cem para noventa segundos.

A redução total será de apenas dez por cento.

Nada desprezível.

Mas muito diferente da expectativa de executar tudo duas vezes mais rapidamente.

Por isso, antes de compilar, precisamos medir.

A curiosidade das opções SLINE, ALT, CONDENSE e XREF

A apresentação menciona essas opções em sua seção de REXX compilado.

É importante compreender que, no contexto do IBM Compiler for REXX, elas dizem respeito à compilação, representação e informações associadas ao programa.

Não devem ser confundidas com comandos genéricos de processamento de arquivos.

O significado de cada opção precisa ser consultado na documentação da versão do compilador utilizada.

Essa distinção é valiosa porque evita ensinar uma nomenclatura equivocada ao iniciante.

Regra de ouro: primeiro melhore o algoritmo, depois investigue as possibilidades de compilação.


🚨 Capítulo X — ADDRESS CONSOLE: o momento em que o script encontra a operação do z/OS

Até agora, nosso REXX leu variáveis, percorreu estruturas e acessou datasets.

Mas o z/OS possui outro universo.

O universo dos comandos operacionais.

É nele que encontramos mensagens de sistema, informações de recursos, respostas de subsistemas e procedimentos executados por operadores.

Determinados ambientes REXX permitem interagir com comandos de console, desde que as autorizações e as condições técnicas sejam atendidas.

Isso abre possibilidades para ferramentas de monitoramento.

Imagine um exec que verifica se um recurso operacional está respondendo normalmente.

Ele emite uma consulta autorizada, aguarda a resposta, interpreta o resultado e registra a situação.

Mas surge um problema.

E se vários comandos estiverem sendo executados simultaneamente?

Como identificar a resposta correspondente a cada solicitação?

Uma das ferramentas envolvidas nessa situação é o CART — Command and Response Token.

O token ajuda a correlacionar comandos e mensagens de resposta.

Funções como GETMSG podem ser utilizadas para recuperação das mensagens em contextos apropriados.

É uma ideia semelhante à utilização de identificadores de correlação em sistemas distribuídos modernos.

🥚 Easter egg nº 4 — O console também precisa de identificadores

Muita gente associa identificadores de correlação exclusivamente a microsserviços, APIs e computação em nuvem.

Entretanto, a necessidade de associar solicitações às suas respostas também aparece na operação tradicional de mainframes.

A tecnologia muda.

O problema fundamental permanece.

E essa é uma das razões pelas quais estudar IBM Z ajuda a compreender arquiteturas modernas.


🛡️ Capítulo XI — SYSREXX: o poder exige responsabilidade

Chegamos ao nível mais avançado de nossa jornada.

System REXX permite executar programas em ambientes específicos do z/OS, fora do modelo tradicional de uma sessão interativa TSO/E.

Entre suas possibilidades estão a emissão de comandos de sistema e a recuperação de informações para processamento automatizado.

A IBM documenta dois ambientes importantes:

TSO=YES

TSO=NO

A distinção afeta os serviços disponíveis, a integração com TSO/E e as características de execução.

No ambiente System REXX encontramos funções como:

AXRCMD: utilizada para trabalhar com comandos de sistema e respectivas respostas.

AXRWTO: permite emitir mensagens por meio dos serviços correspondentes.

AXRWAIT: oferece mecanismos de espera controlada.

Essas ferramentas permitem construir assistentes operacionais, diagnósticos e rotinas de apoio ao operador.

Mas surge uma pergunta essencial.

Se um exec possui capacidade de interagir com funções sensíveis do sistema, quem controla o que ele pode fazer?

A resposta envolve segurança, autorizações, bibliotecas confiáveis e governança.

O RACF e os demais mecanismos de controle do z/OS desempenham papéis fundamentais.

Não basta que um programa execute corretamente.

Ele precisa executar somente aquilo que está autorizado a fazer.

Uma automação com privilégios excessivos pode se transformar em um risco operacional significativo.

O princípio do menor privilégio

Imagine um programa cuja única função seja consultar determinado recurso.

Ele não deveria receber permissões amplas para alterar configurações críticas, encerrar subsistemas ou modificar informações desnecessárias à consulta.

A simplicidade desejada por Cowlishaw precisa caminhar ao lado da responsabilidade exigida pela operação moderna.

Facilitar a programação não significa facilitar operações perigosas.


🧪 Capítulo XII — Mão na massa: nosso primeiro monitor de indicadores em REXX

Vamos reunir alguns conhecimentos em um projeto prático.

Nosso objetivo será criar um programa simples que leia informações de um dataset e identifique valores superiores a um limite estabelecido.

Imagine o arquivo:

APPDEV2.DADOS.HEALTH

Conteúdo:

CPU;65
MEMORIA;72
FILAS;91
IO;40

Esses valores são indicadores didáticos, não medições reais do sistema.

Passo 1 — Definir o limite

limite = 85

Passo 2 — Ler os registros

/* REXX */
address tso
drop dados.

"ALLOC FI(HCIN) DA('APPDEV2.DADOS.HEALTH') SHR"
if rc <> 0 then exit 12

"EXECIO * DISKR HCIN (STEM dados. FINIS"
leituraRC = rc

"FREE FI(HCIN)"

if leituraRC <> 0 then exit 12

Passo 3 — Verificar cada indicador

alertas = 0

do i = 1 to dados.0
  parse var dados.i indicador ';' valor

  if \datatype(valor,'W') then do
    say 'ERRO: valor invalido'
    exit 12
  end

  if valor < 0 | valor > 100 then do
    say 'ERRO: fora da escala'
    exit 12
  end

  if valor > limite then do
    say 'ALERTA:' indicador valor
    alertas = alertas + 1
  end
  else
    say 'OK:' indicador valor
end

if alertas > 0 then exit 4
exit 0

Passo 4 — Interpretar o resultado

Para os dados apresentados, esperamos:

OK: CPU 65
OK: MEMORIA 72
ALERTA: FILAS 91
OK: IO 40

O retorno será 4, indicando que pelo menos um indicador ultrapassou o limite.

Observe o que acabamos de construir.

Nosso programa possui:

  • Leitura de dataset.

  • Variáveis compostas.

  • Laço de repetição.

  • Validação de dados.

  • Lógica condicional.

  • Código de retorno.

  • Identificação de anomalias.

É um pequeno laboratório, mas contém os fundamentos de uma automação real.

Naturalmente, antes de utilizar essa ideia em produção, precisaríamos acrescentar tratamento completo de falhas, validação do formato dos registros, definição de limites por indicador, registros de auditoria e testes com entradas problemáticas.

Uma evolução interessante

Imagine substituir o dataset simulado por informações coletadas através de serviços autorizados do ambiente.

Poderíamos construir um monitor que identificasse condições operacionais e produzisse alertas.

A próxima etapa seria encaminhar os resultados para uma ferramenta de observabilidade.

E, posteriormente, integrar os registros a sistemas analíticos.

A partir daí, nossa automação começaria a participar de um ecossistema de operação inteligente.


🤖 Capítulo XIII — REXX, DevOps e inteligência artificial: a surpreendente modernidade de uma linguagem de 1979

É curioso imaginar que uma linguagem concebida antes da popularização dos computadores pessoais possa continuar relevante num mundo dominado por APIs, Git, automação e inteligência artificial.

Mas a explicação está na natureza do problema que REXX resolve.

Empresas continuam precisando coordenar processos.

Continuam precisando validar entradas.

Continuam precisando interpretar resultados.

Continuam precisando automatizar operações.

A inteligência artificial pode ajudar a explicar código, gerar testes, documentar rotinas e identificar padrões suspeitos.

Mas o modelo de IA não substitui automaticamente a necessidade de interfaces corretas, permissões apropriadas e validação empresarial.

Imagine um assistente inteligente encarregado de analisar uma rotina REXX.

Ele pode sugerir melhorias, identificar um RC ignorado ou observar que determinado dataset não foi corretamente fechado.

Entretanto, antes de aceitar qualquer modificação, será necessário confirmar que a alteração preserva o comportamento esperado.

Essa é uma das razões pelas quais conhecer profundamente REXX, COBOL e JCL continua importante.

A inteligência artificial pode acelerar o trabalho.

Mas a compreensão técnica permite verificar se o trabalho foi realizado corretamente.

Uma arquitetura possível

Um fluxo moderno pode utilizar:

Git para versionamento.

Uma pipeline CI/CD para testes e validações.

Zowe para integração com serviços do IBM Z.

JCL para processamentos batch.

COBOL para regras empresariais.

REXX para operações especializadas de automação.

RACF para controles de autorização.

E ferramentas de observabilidade para acompanhamento dos resultados.

Cada componente possui uma responsabilidade.

O segredo está na integração disciplinada.


🦖 Capítulo XIV — Dez erros que transformam um script REXX num pesadelo de produção

Depois de explorar os fundamentos, precisamos discutir as armadilhas.

1. Ignorar o RC. Um comando pode falhar sem que o restante do programa seja interrompido automaticamente.

2. Não inicializar estruturas. Variáveis residuais podem produzir resultados inesperados.

3. Confundir stem com array convencional. As regras de variáveis compostas precisam ser compreendidas.

4. Deixar a Data Stack contaminada. Informações pendentes podem interferir em operações posteriores.

5. Esquecer o FINIS. Recursos de I/O precisam ser gerenciados corretamente.

6. Presumir que EXECIO funciona com qualquer dataset. A organização e a interface de acesso importam.

7. Utilizar entrada interativa sem planejamento em batch. A ausência de um terminal altera as condições de execução.

8. Escolher LINK, LINKMVS ou LINKPGM sem compreender os parâmetros. A incompatibilidade de interfaces pode provocar falhas graves.

9. Compilar um programa sem medir seu desempenho. O ganho pode ser pequeno ou irrelevante para o problema real.

10. Automatizar comandos privilegiados sem controles adequados. Quanto maior a autoridade de um programa, maior a responsabilidade sobre sua segurança.

O que todos esses problemas possuem em comum?

Eles revelam a diferença entre conhecer a sintaxe de uma linguagem e compreender o ambiente em que ela funciona.


🏆 Capítulo XV — A trilha do Mestre Jedi do REXX

Se eu estivesse organizando uma formação de REXX para um iniciante em COBOL, dividiria o aprendizado em cinco estágios.

Primeiro estágio — Padawan da linguagem

Aprender SAY, PARSE, IF, DO, SELECT, PROCEDURE, funções e variáveis compostas.

O objetivo é escrever pequenos programas que possam ser compreendidos, testados e modificados.

Segundo estágio — Guardião dos datasets

Aprender EXECIO, Data Stack, tratamento de registros, validação de entradas e fechamento de recursos.

O objetivo é construir utilitários que trabalhem com dados sem comprometer sua integridade.

Terceiro estágio — Cavaleiro do batch

Aprender JCL, IKJEFT01, IRXJCL, parâmetros, DDs, RC e análise de resultados no SDSF.

O objetivo é executar programas de maneira reproduzível, sem dependência de interação humana.

Quarto estágio — Especialista em integração

Estudar LINK, LINKMVS, LINKPGM, interfaces COBOL, módulos carregáveis e convenções de parâmetros.

O objetivo é conectar componentes sem precisar reescrever sistemas que já executam regras empresariais confiáveis.

Quinto estágio — Mestre Jedi da produção

Estudar System REXX, console, autorizações, logs, auditoria, recuperação, controle de mudanças e automação operacional.

O objetivo é compreender não apenas como executar uma operação, mas também seus riscos e consequências.

Essa progressão acompanha a filosofia central da apresentação APPDEV2: sair do pequeno script e avançar, com responsabilidade, para a automação do z/OS.


🔍 Capítulo XVI — O que Mike Cowlishaw nos ensinaria sobre programação em 2026?

Não podemos atribuir a Cowlishaw opiniões que ele não expressou sobre todos os desafios atuais.

Mas podemos refletir sobre os princípios documentados de sua linguagem.

REXX foi desenvolvido com atenção especial à experiência dos usuários.

Sua sintaxe procurava ser legível e coerente.

A linguagem deveria ajudar a resolver problemas reais, em vez de transformar cada atividade numa batalha contra a notação.

Esses princípios continuam extraordinariamente relevantes.

Em 2026, um iniciante pode pedir a uma inteligência artificial que escreva cinquenta linhas de REXX.

Mas isso não garante que ele compreenda o programa.

A IA pode gerar código que parece correto, mas utiliza um serviço indisponível no ambiente de execução.

Pode interpretar incorretamente um código de retorno.

Pode produzir uma chamada incompatível com a interface de um módulo COBOL.

Pode esquecer de liberar recursos.

Por isso, existe uma diferença fundamental entre gerar código e compreender sistemas.

O futuro não pertence apenas a quem consegue produzir programas mais rapidamente. Pertence também a quem consegue demonstrar que esses programas funcionam corretamente, com segurança e dentro das regras do negócio.

Essa reflexão está perfeitamente alinhada à filosofia de uma linguagem que nasceu procurando facilitar a compreensão humana.


🎬 Epílogo — 03h17: o criador do REXX encontrou o futuro dentro de um mainframe

Voltemos ao nosso centro de processamento imaginário.

São 03h17.

Um job termina com RC zero.

Uma rotina verifica a existência de um dataset.

Outra analisa registros de controle.

Um monitor identifica uma condição incomum e registra um alerta.

Uma aplicação COBOL continua executando suas regras empresariais.

E um pequeno programa REXX reúne informações que antes exigiam diversas operações manuais.

Mike Cowlishaw observa a cena.

A linguagem que nasceu de uma ideia simples agora participa de uma infraestrutura tecnológica que movimenta instituições financeiras, empresas e serviços essenciais.

Mas talvez o aspecto mais interessante não seja sua longevidade.

É o fato de que sua filosofia original continua fazendo sentido.

Uma linguagem pode ser acessível sem ser limitada.

Pode ser simples sem ser superficial.

Pode ter décadas de existência e continuar resolvendo problemas modernos.

Em um mundo fascinado pelas novidades, o REXX lembra que inovação nem sempre significa abandonar o passado.

Às vezes, significa descobrir novas possibilidades numa ferramenta que já estava diante de nossos olhos.

E quando o último monitor apaga sua mensagem de processamento, uma frase permanece na tela:

"O verdadeiro Mestre Jedi do Mainframe não é aquele que conhece todos os comandos. É aquele que entende as consequências de cada comando que executa."

O pequeno dinossauro sorri.

O REXX continua vivo.

E sua próxima aventura acaba de começar.


📚 Referências e material de aprofundamento

  • Mike F. Cowlishaw — The Design of the REXX Language, IBM Systems Journal, 1984.

  • IBM — z/OS TSO/E REXX User's Guide.

  • IBM — z/OS TSO/E REXX Reference.

  • IBM — System REXX e documentação de serviços de console.

  • IBM — Compiler for REXX on IBM Z.

  • Rexx Language Association — História da linguagem REXX.

  • APPDEV2 — REXX Mainframe: Do Script ao Motor de Automação z/OS, novembro de 2026.

  • Bellacosa Mainframe — Artigos sobre REXX.

  • GitHub — REXX MiniCurso: scripts e exercícios práticos.

Bellacosa Mainframe — Porque compreender o passado da computação é uma das melhores maneiras de construir seu futuro.

sábado, 12 de setembro de 2026

👄 COBOL Horror Picture Show — Frank-N-Furter e a Estranha Arte de Modernizar sem Matar a Criatura

 

Bellacosa Mainframe e a modernização do cobol

☕ Um Café no Bellacosa Mainframe

👄 COBOL Horror Picture Show — Frank-N-Furter e a Estranha Arte de Modernizar sem Matar a Criatura

“Don’t dream it. Be it.” — e, se estiver em produção há quarenta anos, talvez seja melhor descobrir primeiro todas as dependências antes de tentar transformá-lo.

Há alguma coisa deliciosamente apropriada em colocar Frank-N-Furter, de The Rocky Horror Picture Show, diante de uma arquitetura de modernização COBOL.

Pense na cena.

No centro do laboratório existe uma aplicação COBOL.

Ela é antiga.

Muito antiga.

Há décadas recebe transações, abre arquivos, atualiza bancos de dados, processa lotes durante a madrugada e alimenta sistemas que provavelmente nem existiam quando sua primeira versão foi compilada.

Em volta dela aparecem engenheiros carregando Git, Jenkins, Terraform, Ansible, AWS EC2, RDS, Secrets Manager e CloudWatch.

Luzes piscam.

Pipelines começam a executar.

Playbooks descem do Git.

EC2s surgem.

O banco ganha vida.

E alguém grita:

“IT'S ALIVE!”

Calma.

Frank-N-Furter ficaria encantado.

Eu ficaria procurando o JCL.

Porque existe uma diferença monumental entre fazer um programa COBOL executar em outro lugar e modernizar o sistema empresarial do qual aquele programa faz parte.

E é justamente essa diferença que vamos explorar.

Bem-vindo ao laboratório.



🎭 1. Antes de tudo: conheça o Dr. Frank-N-Furter

The Rocky Horror Picture Show nasceu como adaptação cinematográfica do musical The Rocky Horror Show, criado por Richard O'Brien, e chegou aos cinemas em 1975.

No centro daquela insanidade musical está o Dr. Frank-N-Furter, interpretado por Tim Curry.

Cientista.

Showman.

Manipulador.

Extravagante.

E, sobretudo, criador.

Frank não quer simplesmente estudar aquilo que existe.

Ele quer construir sua própria criatura.

Rocky nasce dentro do laboratório como materialização dessa ambição.

E é exatamente por isso que Frank é nosso tutor perfeito para esta conversa.

Modernização de sistemas também pode sofrer da síndrome de Frank-N-Furter:

ficamos tão fascinados com nossa capacidade de construir alguma coisa nova que esquecemos de perguntar se entendemos completamente aquilo que estamos substituindo.



⚡ 2. Há uma criatura COBOL sobre a mesa

Nossa arquitetura começa com algo aparentemente simples:

COBOL
   +
AWS EC2
   +
AWS RDS
   +
Ansible
   +
Terraform
   +
CI/CD

A proposta é elegante.

Temos ambientes:

DEV
 ↓
SIT
 ↓
UAT
 ↓
PRE-PROD
 ↓
PROD

Terraform provisiona infraestrutura.

Ansible configura máquinas e instala o ambiente necessário.

O pipeline controla o processo.

RDS fornece banco de dados gerenciado.

Git preserva código e configuração.

CloudWatch observa o ambiente.

Excelente.

Mas Frank-N-Furter aproxima-se da mesa, levanta o lençol e pergunta:

“Isso é realmente tudo que existe dentro da criatura?”

Não.

Quase nunca.



🧟 3. COBOL não é o monstro

Esta talvez seja a primeira grande inversão que precisamos fazer.

Quando alguém anuncia:

“Temos uma aplicação COBOL de quarenta anos.”

muita gente imediatamente imagina que encontrou o problema.

Não encontrou.

Encontrou uma linguagem.

O problema real pode estar em tudo aquilo que cresceu ao redor dela:

                COBOL
                  │
       ┌──────────┼──────────┐
       │          │          │
      CICS       IMS        Db2
       │          │          │
      VSAM       MQ        Stored
       │                   Procedures
       │
      JCL
       │
   Scheduler
       │
 GDG / datasets

Depois aparecem:

SORT
IDCAMS
REXX
PROCs
copybooks
utilities
FTP/SFTP
APIs
arquivos externos
interfaces
sistemas parceiros

Então alguém encontra um programa:

CALL 'XPTO123'

Ótimo.

Onde está XPTO123?

Ninguém sabe.

Até que aquele senhor sentado no fundo da sala fala:

“Ah... isso chama uma rotina que o Pereira escreveu em 1997.”

Onde está Pereira?

Aposentado.

Documentação?

Não existe.

Código?

Está numa load library.

Bem-vindo ao castelo.


🔬 4. “I can make you a man” — recompilar não significa modernizar

Imagine que conseguimos pegar determinado programa COBOL e compilá-lo para execução em Linux numa instância EC2.

Fantástico.

COBOL/zOS
    │
    ▼
COBOL/Linux
    │
    ▼
AWS EC2

A aplicação executa.

Então:

“IT'S ALIVE!”

Sim.

Mas cuidado.

Fizemos replatforming.

Talvez isso seja exatamente aquilo que o projeto necessita. Não há absolutamente nada de errado com replatforming.

O erro está em chamar qualquer mudança de plataforma de transformação completa.

A lógica pode continuar praticamente igual.

O código pode continuar COBOL.

O que mudou foi o ambiente no qual ele vive.

É como Rocky.

Frank criou um homem.

Mas criar um corpo funcionando não resolveu automaticamente todos os problemas do castelo.


🏗️ 5. Terraform constrói o laboratório

Vamos separar responsabilidades.

Terraform pode assumir a infraestrutura:

Terraform
    │
    ├── VPC
    ├── Subnets
    ├── Security Groups
    ├── EC2
    ├── IAM
    ├── RDS
    └── outros recursos

Pense nele como quem prepara o laboratório.

Mesa instalada.

Eletricidade ligada.

Tanque montado.

Cabos conectados.

Máquinas posicionadas.

Mas Terraform não deveria necessariamente decidir cada detalhe de configuração da criatura.

Para isso entra outro personagem.


🧰 6. Ansible entra usando salto alto

Ansible entra no laboratório dizendo:

“Deixem a configuração comigo.”

E começa.

EC2
 ↓
pacotes do sistema operacional
 ↓
COBOL compiler/runtime
 ↓
environment variables
 ↓
aplicação
 ↓
configuração
 ↓
database connectivity
 ↓
services
 ↓
health checks

É aqui que a arquitetura original fica realmente interessante.

Não precisamos ter um processo artesanal para DEV, outro para SIT, outro para UAT e um ritual secreto conhecido apenas por dois operadores para PRE-PROD.

Temos automação reutilizável.

Algo conceitualmente assim:

             ANSIBLE ROLE
                  │
       ┌──────────┼──────────┐
       │          │          │
      DEV        SIT        UAT
                              │
                              ▼
                          PRE-PROD

A receita permanece.

Os ingredientes variáveis são separados.


🧓 7. O programador COBOL olha para group_vars e começa a rir

Aqui temos uma das minhas partes favoritas.

A turma DevOps explica:

“Nós separamos a lógica da automação dos parâmetros específicos do ambiente.”

O programador COBOL responde:

“Parâmetros?”

Sim.

DEV pode ter:

DB = APP_DEV
PORT = 1521
ENDPOINT = dev-database

SIT:

DB = APP_SIT
PORT = 1521
ENDPOINT = sit-database

UAT:

DB = APP_UAT
PORT = 1521
ENDPOINT = uat-database

O playbook continua fundamentalmente o mesmo.

Para alguém vindo do mainframe, isso não deveria parecer ficção científica.

Nós passamos décadas trabalhando com conceitos semelhantes através de:

JCL
PROCs
symbolic parameters
PARMLIB
SYSIN
DD statements

Mudam as ferramentas.

A ideia de externalizar configuração é muito mais antiga que os slides modernos que a apresentam.

Frank-N-Furter provavelmente acrescentaria glitter.


👄 8. “Don’t dream it. Be it.” — Infrastructure as Code

Aqui encontramos uma mudança genuinamente poderosa.

Durante décadas tivemos infraestrutura e configuração documentadas mais ou menos assim:

“Instalar pacote X, editar arquivo Y, trocar parâmetro Z, reiniciar serviço e telefonar para Carlos se não funcionar.”

Carlos sai da empresa.

Fim da documentação.

Infrastructure as Code transforma parte desse conhecimento operacional em algo executável.

CONHECIMENTO
     ↓
    CODE
     ↓
Version Control
     ↓
Automation
     ↓
Environment

Isso é importante.

Código pode ser:

revisado, versionado, comparado, testado, auditado e reproduzido.

O conhecimento deixa de existir exclusivamente na memória do operador.


🧪 9. DEV → SIT → UAT → PRE-PROD

Agora Frank conduz nossa criatura pelos diferentes aposentos do castelo.

DEV

Aqui desenvolvemos e realizamos os primeiros testes.

SOURCE
  ↓
BUILD
  ↓
TEST
  ↓
DEPLOY

SIT

System Integration Testing.

Aqui descobrimos uma verdade universal da informática:

Tudo funciona perfeitamente até precisar conversar com outra coisa.

Banco.

APIs.

Filas.

Serviços.

Arquivos.

Autenticação.

Sistemas externos.

UAT

User Acceptance Testing.

Agora a pergunta deixa de ser apenas:

“Funciona?”

e torna-se:

“Isso faz aquilo que o negócio realmente precisa?”

Diferença enorme.

PRE-PROD

Aqui chegamos ao ensaio geral.

E PRE-PROD deveria ser assustadoramente parecido com produção.


🏰 10. PRE-PROD precisa ser o castelo quase completo

Um PRE-PROD simplificado demais produz falsa segurança.

Precisamos considerar:

OS version
runtime version
COBOL compiler/runtime
database version
patches
CPU architecture
memory
network
TLS
IAM
filesystem
locale
encoding
timezone
batch
integrations
security policies

Quanto mais diferente de PROD, mais perguntas surgem.

Imagine:

UAT
COBOL Runtime 8.0

PROD
COBOL Runtime 7.4

Funcionou no UAT.

Que maravilhoso.

Mas você não testou produção.

Testou outra coisa.


📦 11. Está faltando um personagem importante: o artefato

Aqui eu faria uma alteração importante na arquitetura.

Não gosto da ideia de recompilar arbitrariamente a aplicação em cada ambiente.

Prefiro:

          SOURCE
             │
             ▼
           BUILD
             │
             ▼
            TEST
             │
             ▼
      ARTIFACT REPOSITORY
             │
     ┌───────┼─────────┐
     ▼       ▼         ▼
    DEV     SIT       UAT
                       │
                       ▼
                   PRE-PROD
                       │
                       ▼
                     PROD

Isso nos leva a um princípio extremamente poderoso:

Build once, deploy many.

Produzimos uma criatura.

Depois submetemos aquela mesma criatura aos testes.

Não fazemos Rocky 1 para DEV, Rocky 2 para SIT, Rocky 3 para UAT e Rocky 4 para produção esperando que todos sejam geneticamente idênticos.


🕵️ 12. A pergunta do auditor

Imagine uma mudança chegando a produção.

O auditor pergunta:

“Esse binário é exatamente aquele homologado?”

Se cada ambiente recompila:

SOURCE
 ↓
DEV BUILD

SOURCE
 ↓
SIT BUILD

SOURCE
 ↓
UAT BUILD

SOURCE
 ↓
PROD BUILD

temos quatro processos de construção.

Mesmo que tudo pareça igual, aumentamos nossa superfície de dúvida.

Com artefato imutável:

SOURCE
 ↓
BUILD
 ↓
ARTIFACT 7.3.17
 ↓
DEV
 ↓
SIT
 ↓
UAT
 ↓
PRE-PROD
 ↓
PROD

agora existe uma cadeia muito mais clara.


🔐 13. Sweet Transvestite não significa senha escrita no YAML

Chegamos aos secrets.

Nunca faça:

database_password: "senha_supersecreta123"

e depois:

git commit

Parabéns.

Você acaba de transformar seu Git em museu arqueológico de credenciais.

A arquitetura corretamente menciona mecanismos como Ansible Vault e AWS Secrets Manager.

O princípio é:

CODE ≠ SECRET

Idealmente:

CI/CD
   │
   ▼
IAM / temporary authorization
   │
   ▼
Secrets Manager
   │
   ▼
Runtime

O segredo aparece apenas onde e quando precisa aparecer.


🧛 14. Privilégio mínimo: nem Frank deveria ter acesso a tudo

Outro princípio:

Developer ≠ Production Admin
Application ≠ Database Admin
Pipeline ≠ Unlimited AWS Administrator

Cada componente recebe apenas aquilo de que necessita.

Isso é least privilege.

Se determinado processo precisa consultar um segredo, não existe razão automática para permitir que consulte todos.

Se uma aplicação precisa acessar determinado banco, não significa que deva possuir poder administrativo sobre ele.

É o equivalente moderno de algo que o pessoal RACF conhece muito bem:

Quem é você e por que exatamente precisa acessar isso?


🗄️ 15. RDS parece simples até começarmos a falar de Db2

A imagem permite Oracle/PostgreSQL como exemplos.

Tudo bem.

Mas um cenário vindo de mainframe pode envolver:

COBOL
  +
Db2 for z/OS

E alguém inevitavelmente pensa:

Db2 → Db2

Então deve ser simples.

Ah, meu jovem Brad...

Não necessariamente.

Db2 for z/OS
      ≠
Db2 LUW
      ≠
RDS for Db2

Existe parentesco tecnológico.

Não existe identidade operacional perfeita.

Precisamos investigar SQL utilizado, stored procedures, utilities, comportamento transacional, autorização, integração e características específicas da plataforma.

O banco pode carregar tanta arqueologia quanto o COBOL.


🗃️ 16. E o VSAM?

Agora Frank encontra um arquivo VSAM no porão.

Silêncio.

Se a aplicação original utiliza:

KSDS
ESDS
RRDS

precisamos responder:

Para onde esses dados vão?

RDS?

Arquivos?

Outro datastore?

Mantemos comportamento equivalente?

E principalmente:

a aplicação depende semanticamente da organização original?

Não basta exportar registros e dizer:

“Migrei.”

Dados possuem comportamento.

Chaves.

Ordenação.

Concorrência.

Locking.

Integridade.

Performance.

Tudo isso importa.


📜 17. E o JCL?

Aqui está uma das grandes vítimas dos diagramas bonitos de modernização.

Pegamos o COBOL.

Migramos.

E esquecemos que às 02:00 existe isto:

JOB A
 ↓
JOB B
 ↓
JOB C ─── JOB D
   │
   ▼
 JOB E
   │
   ▼
 JOB F

Existem dependências.

Calendários.

Arquivos.

Condições.

Return codes.

Restart.

Checkpoints.

SLA.

Janelas de processamento.

O JCL talvez desapareça.

A necessidade que ele implementava não desaparece.

Alguma outra coisa precisará orquestrar aquilo.


⏰ 18. O batch não quer saber que agora você é cloud

Imagine um processamento que precisa terminar até 06:00.

No mainframe:

23:00 START
...
05:31 END

Migramos para AWS.

Agora:

23:00 START
...
06:47 END

Tecnicamente funciona.

Funcionalmente funciona.

Os resultados estão corretos.

E mesmo assim:

A MIGRAÇÃO FALHOU.

Porque o negócio precisava dos dados às 06:00.

Essa é uma lição gigantesca.

Compatibilidade funcional não é suficiente.

Precisamos de compatibilidade operacional.


📊 19. CloudWatch não deveria ficar decorando o canto do desenho

Observabilidade precisa atravessar toda a solução.

Não basta:

EC2 = UP
RDS = UP

Enquanto:

Pedidos processados = ZERO

Infraestrutura saudável não significa aplicação saudável.

Precisamos enxergar:

CPU
memory
disk
network
database latency
connections
locks
errors
transaction rate
response time
batch duration
business transactions

E aqui o veterano do mainframe reconhece novamente uma velha ideia.

O importante não é saber apenas:

“A máquina está ligada?”

O importante é:

“O workload está entregando aquilo que deveria?”


💥 20. PRE-PROD também precisa morrer

Frank provavelmente aprovaria esta parte.

Testamos:

DATABASE ONLINE

Excelente.

Agora desligue o banco.

Testamos:

NETWORK OK

Excelente.

Agora introduza timeout.

Testamos:

DISK SPACE OK

Encha o disco.

Testamos:

PASSWORD VALID

Revogue a credencial.

Queremos descobrir:

database unavailable
network failure
bad credentials
timeout
disk full
process killed
duplicate transaction
corrupted input
rollback failure
partial deployment

Porque produção descobrirá essas condições por você.

E produção não agenda laboratório.


🔥 21. O health check mais importante talvez seja o ABEND

Um health check dizendo:

HTTP 200

é agradável.

Mas para uma aplicação empresarial eu quero saber:

Aplicação iniciou?
Banco conecta?
Fila responde?
Transação funciona?
Arquivo abre?
Batch executa?
Rollback funciona?
Restart funciona?
Dados permanecem consistentes?

Um sistema não é saudável porque existe um processo no ps.

Ele é saudável quando consegue realizar sua função.


🔄 22. Rollback precisa entrar no espetáculo

Deployment sem rollback testado é fé.

O pipeline deveria conhecer algo como:

VERSION 8.4
    │
    ▼
DEPLOY
    │
    ├── SUCCESS → continue
    │
    └── FAILURE
            │
            ▼
        VERSION 8.3
            │
            ▼
        VALIDATION

Mas existe uma complicação.

Rollback de executável é relativamente fácil.

Rollback de banco pode não ser.

Se versão 8.4 alterou schema e começou a gravar dados novos, voltar simplesmente o executável para 8.3 talvez não resolva.

Portanto deployment strategy precisa conversar com database migration strategy.


🧬 23. A criatura tem memória

Esse é outro erro frequente.

Tratamos aplicação como código.

Mas aplicações empresariais são:

CODE
 +
DATA
 +
STATE
 +
INTEGRATIONS
 +
HISTORY

Migrar código é apenas uma parte.

Migrar décadas de dados mantendo integridade pode ser o verdadeiro projeto.

Frank consegue construir outro corpo.

Transferir quarenta anos de memória para ele é outra história.


🕸️ 24. Discovery deveria aparecer antes de Terraform

Se eu redesenhasse completamente a figura, colocaria no início:

             DISCOVERY
                 │
      ┌──────────┼───────────┐
      │          │           │
    COBOL       JCL         DATA
      │          │           │
     CICS    Scheduler     VSAM
      │                      │
     IMS                    Db2
      │
      MQ
      │
 External Systems

Depois:

Dependency Mapping
       ↓
Workload Classification
       ↓
Modernization Strategy
       ↓
Architecture
       ↓
Terraform / Ansible / CI/CD

Essa ordem é fundamental.

Não escolha a ferramenta antes de compreender o problema.


🧭 25. Nem tudo precisa sair do mainframe

Aqui está outra heresia contra certas apresentações de modernização.

Podemos terminar com:

                   ENTERPRISE
                       │
           ┌───────────┴───────────┐
           │                       │
         IBM Z                    AWS
           │                       │
      COBOL/CICS                 Services
           │                       │
          Db2       ← API/MQ →     RDS
           │                       │
        Batch                    Analytics

Isso também é modernização.

Talvez seja uma modernização melhor.

Mainframe não precisa desaparecer para AWS existir.

AWS não precisa substituir IBM Z para gerar valor.

O objetivo deveria ser colocar cada workload onde faz sentido técnico, econômico e operacional.


🏎️ 26. Performance: “funciona” é uma palavra perigosíssima

Suponha que uma transação CICS respondesse em:

40 ms

A nova aplicação responde em:

480 ms

Funciona?

Sim.

É equivalente?

Talvez não.

Agora multiplique pela quantidade de transações.

Adicione network latency.

Database round trips.

APIs.

TLS.

Logs.

Tracing.

De repente aquela diferença aparentemente pequena torna-se enorme.

Modernização precisa de baseline antes da migração.

Sem baseline você termina dizendo:

“Parece mais lento.”

Isso não é engenharia.


💰 27. E existe FinOps

Outro easter egg escondido sob a mesa do laboratório.

No mainframe alguém pode reclamar:

“MIPS são caros!”

Migramos para cloud.

Então descobrimos:

EC2
RDS
storage
IOPS
snapshots
data transfer
NAT
logs
monitoring
backup
licenses
support

e percebemos que cloud não significa:

barato.

Significa principalmente:

modelo econômico diferente.

Se não medirmos consumo, uma arquitetura elasticamente maravilhosa pode gerar uma conta elasticamente maravilhosa também.


👄 28. “Don’t dream it. Be it.”

Chegamos finalmente à grande lição de Frank-N-Furter.

Não devemos ter medo de transformar sistemas.

COBOL pode viver em novas plataformas.

Pode participar de pipelines modernos.

Pode trabalhar com Git.

Pode ser automatizado com Ansible.

Pode ter infraestrutura criada com Terraform.

Pode conversar com cloud.

Pode expor APIs.

Pode entrar num processo CI/CD.

Não existe qualquer contradição nisso.

O problema começa quando confundimos modernização com maquiagem tecnológica.

Trocar:

z/OS

por:

Linux

não moderniza automaticamente arquitetura.

Trocar:

Db2

por:

PostgreSQL

não moderniza automaticamente dados.

Trocar:

JCL

por:

YAML

não moderniza automaticamente processos.

E trocar:

datacenter

por:

AWS

não moderniza automaticamente engenharia.


🧠 29. A verdadeira modernização

Para mim, modernização aparece quando conquistamos:

REPRODUCIBILITY
      +
AUTOMATION
      +
OBSERVABILITY
      +
TRACEABILITY
      +
SECURITY
      +
TESTABILITY
      +
RESILIENCE
      +
MAINTAINABILITY

Se conseguimos isso mantendo COBOL?

Excelente.

Se parte precisa ser reescrita?

Pode fazer sentido.

Se outra parte permanece no IBM Z?

Perfeitamente possível.

Se determinado workload vai para AWS?

Ótimo.

Tecnologia é consequência da decisão arquitetural.

Não deveria ser sua causa.


🥚 Easter egg — 03:17 no castelo

Naturalmente precisamos deixar uma pequena surpresa.

São 03:17 da madrugada.

O telefone toca.

Produção parou.

O dashboard está verde.

EC2:

RUNNING

RDS:

AVAILABLE

CPU:

12%

Memory:

41%

CloudWatch:

NO INFRASTRUCTURE ALARM

Mas o batch não termina.

Um engenheiro olha para outro.

Ninguém entende.

Então aparece um veterano COBOL carregando uma caneca de café.

Ele olha cinco minutos para os logs e pergunta:

“Onde está o arquivo que o JOB anterior deveria ter criado?”

Silêncio.

O arquivo não existe.

O JOB anterior terminou com RC=04.

O novo scheduler considerou RC=04 sucesso.

O sistema antigo possuía uma regra que tratava aquele retorno especificamente.

Ela nunca apareceu no diagrama de migração.

Frank-N-Furter olha para sua criatura.

A criatura olha para Frank.

E o veterano toma outro gole de café.

O COBOL havia sido migrado perfeitamente.

O conhecimento operacional, não.


☕ 30. A lição final do Bellacosa Mainframe

Há algo profundamente fascinante nesses sistemas antigos.

Quando encontramos um programa COBOL escrito em 1989, atualizado em 1997, alterado em 2008, integrado com uma API em 2019 e ainda executando em 2026, não estamos olhando simplesmente para código legado.

Estamos olhando para história empresarial executável.

Cada IF.

Cada copybook.

Cada DD.

Cada tabela.

Cada fila.

Cada estranho RC=04.

Pode existir porque alguma coisa aconteceu.

Alguém tomou uma decisão.

Algum problema ocorreu.

Alguma regra comercial nasceu.

Algum cliente reclamou.

Algum auditor exigiu.

Alguma madrugada de produção ensinou uma lição.

Por isso, quando alguém entrar no laboratório segurando Terraform numa mão e Ansible na outra, não devemos impedi-lo.

Muito pelo contrário.

Acendam as máquinas.

Preparem AWS.

Construam pipelines.

Versionem tudo.

Automatizem.

Observem.

Testem.

Modernizem.

Só não cometam o erro de Frank-N-Furter:

não fiquem tão apaixonados pela nova criatura a ponto de esquecer de compreender o mundo no qual ela terá de sobreviver.

Porque, no final, a pergunta mais importante de uma modernização COBOL não é:

“Conseguimos fazê-lo rodar na AWS?”

É:

“Conseguimos preservar quarenta anos de comportamento, regras, dependências e conhecimento — eliminando aquilo que ficou obsoleto e melhorando aquilo que realmente precisava mudar?”

Se a resposta for sim, então podem aumentar o volume.

As luzes do laboratório podem acender.

Terraform pode subir a infraestrutura.

Ansible pode executar o playbook.

Jenkins pode promover o artefato.

CloudWatch pode começar a observar.

E Frank-N-Furter finalmente poderá anunciar:

⚡ “IT'S ALIVE!”

Enquanto o velho programador COBOL, sentado discretamente no fundo do laboratório, acrescentará:

“Muito bonito. Agora vamos ver se fecha o batch antes das seis.” ☕👄⚡



 

domingo, 30 de agosto de 2026

Dr. House Entra no Centro de Operações — Seis Etapas de IA, um Programa COBOL em Coma e o Diagnóstico que o Logo Bonito Não Faz

 

Bellacosa Mainframe e as 6 etapas de ia para um programador cobol

☕ Um Café no Bellacosa Mainframe

Dr. House Entra no Centro de Operações — Seis Etapas de IA, um Programa COBOL em Coma e o Diagnóstico que o Logo Bonito Não Faz

Ou: por que assinar vinte ferramentas de inteligência artificial não salva um processo mal definido, não conserta um S0C7 e certamente não dá alta para produção sem exame, teste e alguém disposto a dizer “isso não fecha”


Prólogo — O paciente chegou falando em produtividade

Eram 7h12 quando um jovem padawan COBOL entrou na sala de diagnóstico do hospital imaginário de Princeton-Plainsboro, carregando um notebook, três abas abertas, uma apresentação com quarenta logos coloridos e uma expressão de quem acabara de descobrir o Santo Graal da produtividade.

— Doutor House, encontrei o mapa definitivo. São seis etapas para fazer mais com IA: pensar, programar, criar conteúdo, trabalhar melhor, fazer imagens e automatizar tudo.

House nem levantou os olhos da bengala.

— “Automatizar tudo” é uma frase linda. Também é uma ótima maneira de automatizar um desastre inteiro antes do café.

O rapaz ficou imóvel.

— Mas tem ChatGPT, Claude, Perplexity, Cursor, Replit, Midjourney, n8n, Zapier…

— Exatamente — respondeu House. — Uma ambulância cheia de aparelhos não cura o paciente se ninguém souber qual órgão está falhando. Agora me diga: qual é o problema?

E ali começa a conversa que todo iniciante precisa ter. Inteligência artificial não é uma coleção de aplicativos com ícones bonitos. É uma camada de apoio para pensar, pesquisar, escrever, programar, revisar, criar, organizar e automatizar. Quando usada com método, poupa tempo e melhora a qualidade. Quando usada como caixa-preta, produz uma quantidade industrial de respostas convincentes, código aparentemente elegante, imagens espetaculares e erros muito bem embalados.

No mainframe, onde um detalhe de dado, segurança ou processamento pode afetar milhares — às vezes milhões — de operações, essa diferença é ainda maior.

O Dr. House, naturalmente, não está interessado em “qual IA é a melhor”. Ele quer saber: qual é o sintoma? Qual dado confirma a hipótese? O que pode estar escondido? E qual ação ainda precisa de um ser humano com responsabilidade e café suficiente?



1. Primeira etapa: pensar e perguntar — antes de pedir resposta, descubra a pergunta

A primeira camada do quadro reúne ferramentas como ChatGPT, Claude e Perplexity. Em aparência, elas fazem a mesma coisa: você escreve uma pergunta e recebe uma resposta. Na prática, o uso saudável é mais profundo.

Uma ferramenta conversacional pode ajudar a:

  • organizar uma ideia confusa;

  • explicar um conceito técnico em vários níveis;

  • criar exemplos;

  • comparar soluções;

  • revisar um texto;

  • transformar um requisito em casos de teste;

  • fazer o papel de aluno iniciante, arquiteto, revisor ou advogado do diabo.

Já uma ferramenta focada em pesquisa tende a ser mais útil quando você precisa localizar fontes, comparar documentação, verificar onde uma afirmação apareceu e continuar a investigação por conta própria.

A primeira lição do padawan COBOL é simples: a IA responde à pergunta que você fez, não à pergunta que você queria ter feito.

Compare:

“Explique CICS.”

Agora compare:

“Explique HANDLE CONDITION em CICS para um programador COBOL iniciante. Diferencie-o de HANDLE ABEND, apresente um exemplo de erro ao tratar NOTFND e explique por que capturar um abend e simplesmente retornar pode esconder um problema de integridade.”

A segunda pergunta tem objetivo, contexto, profundidade e critérios de qualidade. Ela força a ferramenta a trabalhar. A primeira pede uma apostila genérica, algo entre “CICS é um monitor de transações” e uma vontade súbita de fechar a aba.

House bateu com a bengala na mesa.

— Todo mundo mente. Inclusive o requisitante. Ele diz que precisa de “uma explicação sobre Db2”, mas na verdade precisa descobrir por que o programa Java recebe -805 e o SELECT no SPUFI funciona.

É uma provocação, mas ela carrega uma verdade operacional: perguntas vagas produzem respostas vagas. Em tecnologia, o problema real costuma estar escondido atrás da primeira descrição.

Um método simples para perguntar melhor

Antes de chamar uma IA, organize cinco itens:

  1. Objetivo: o que você quer decidir, aprender ou produzir?

  2. Contexto: qual ambiente, linguagem, versão, público ou restrição?

  3. Entrada: quais dados, logs, trecho de código ou fontes são confiáveis?

  4. Saída esperada: explicação, checklist, código, teste, tabela, roteiro?

  5. Critério de aceitação: como você saberá que a resposta presta?

Exemplo aplicado:

“Tenho um programa COBOL batch que lê um arquivo sequencial e recebe S0C7 ao calcular valor líquido. Crie hipóteses ordenadas por probabilidade, diga quais campos devo inspecionar, mostre um exemplo seguro de validação antes do cálculo e não invente o conteúdo do dump.”

Essa é uma excelente conversa técnica. A IA pode sugerir que campos numéricos contêm espaços, caracteres inválidos, sinal inesperado, desalinhamento de layout ou uma origem de dados mal tratada. Mas o dump, o DISPLAY, o FILE STATUS, o layout real e a evidência ainda são seus.

A IA pode levantar diagnóstico diferencial. Não pode declarar o paciente curado sem exame.


2. A segunda etapa: construir e programar — velocidade não substitui entendimento

Cursor, Replit, Lovable, Base44 e ferramentas semelhantes prometem construir aplicações rapidamente. E cumprem parte da promessa. Elas conseguem gerar telas, APIs simples, formulários, protótipos, integrações comuns e até estruturas iniciais de projetos em tempo muito menor que o desenvolvimento manual.

Mas existe uma diferença histórica entre:

  • fazer uma demonstração funcionar;

  • fazer um sistema sobreviver à realidade.

No hospital de House, o jovem padawan mostra um aplicativo de cadastro de clientes gerado em vinte minutos.

— Ele cria, altera e exclui clientes — comemora.

House olha para a tela.

— Quem pode excluir? Exclusão é física ou lógica? O CPF pode mudar? Como você evita que dois operadores alterem o mesmo registro? Cadê o log de auditoria? Onde está o rollback? O que acontece se o banco cair entre atualizar o cadastro e registrar a transação? Quem validou a autorização?

Silêncio.

Em COBOL, nós já conhecemos esse filme. Um MOVE é fácil. O difícil é saber se ele deveria acontecer. Um WRITE é fácil. O difícil é garantir que o registro não foi duplicado, que a chave é válida, que o arquivo está consistente e que o operador não está vendo uma mensagem bonita escondendo um erro grave.

A IA é muito boa para acelerar tarefas mecânicas:

  • criar o esqueleto de um programa;

  • explicar um trecho legado;

  • gerar comentários iniciais;

  • sugerir refatorações;

  • criar casos de ZUnit;

  • transformar regras descritas em linguagem natural em cenários de teste;

  • elaborar uma matriz de entradas e saídas;

  • ajudar a escrever JCL de laboratório;

  • documentar um fluxo CICS, Db2 ou VSAM.

Mas ela precisa ser tratada como um desenvolvedor júnior muito rápido, muito disponível e perigosamente confiante. Ela não conhece o seu ambiente por osmose. Ela não sabe quais copybooks são padrão, quais campos carregam regras históricas, qual job tem janela crítica, qual transação depende de outra nem que um campo aparentemente inocente é usado por um sistema de fraude há quinze anos.

O teste da pergunta incômoda

Antes de aceitar código gerado por IA, pergunte:

  • Compila?

  • Passa nos testes?

  • Trata erro?

  • Mantém o padrão do projeto?

  • Expõe dado sensível?

  • Tem permissão excessiva?

  • Entende concorrência?

  • É reversível?

  • Foi revisado por alguém que conhece a regra de negócio?

Se a resposta a qualquer uma for “não sei”, o código não está pronto. Está apenas escrito.

A produtividade verdadeira não é gerar mais linhas. É reduzir o tempo entre entender uma necessidade e entregar uma mudança correta, testada, auditável e sustentável.


3. Terceira etapa: criar conteúdo — a IA multiplica formatos, não fabrica autoridade

A terceira faixa do mapa fala de ferramentas para texto, avatar, vídeo, edição, cortes e newsletter. Aqui existe um ganho extraordinário para quem cria conteúdo técnico.

Uma explicação boa sobre COBOL pode virar várias peças:

  • artigo detalhado para blog;

  • roteiro de vídeo;

  • short de 45 segundos;

  • carrossel para LinkedIn;

  • infográfico;

  • checklist;

  • newsletter;

  • exercício para alunos;

  • perguntas e respostas;

  • thumbnail para YouTube.

A IA reduz o esforço de conversão entre formatos. Ela pode pegar um texto longo e sugerir títulos, cortes, pontos de curiosidade, estrutura de carrossel ou uma lista de dúvidas frequentes.

Mas atenção: converter não é repetir.

Se você pega um artigo técnico e manda a IA “criar dez posts”, ela provavelmente entregará dez versões da mesma sopa requentada: “No mundo acelerado de hoje…”, “Você sabia?”, “A revolução chegou…”. É conteúdo que não ofende ninguém e também não permanece em ninguém.

A conexão nasce de uma voz própria, de um exemplo realista e de uma tese. Um texto sobre S0C7 é mais memorável quando explica que o programa não “ficou louco”: alguém mandou o COBOL tratar como número algo que, em algum ponto da cadeia, deixou de ser número. O abend é o médico gritando que o exame de sangue não combina com o diagnóstico.

House aprovaria essa parte.

— O sintoma não é a doença. Febre não é diagnóstico. S0C7 também não.

Para conteúdo técnico, a IA deve ajudar a estruturar e editar; a experiência humana deve fornecer o cheiro de produção. É ela que sabe por que um ICH408I em homologação pode ser uma configuração inocente ou a primeira pista de uma concessão de acesso feita sem controle. É ela que sabe que o programa “simples” costuma ter uma regra escondida no copybook, uma exceção em um IF e uma história antiga que ninguém documentou.

A máquina produz texto. O autor produz significado.


4. Quarta etapa: trabalhar com mais inteligência — não é só escrever melhor, é construir memória confiável

Ferramentas de correção, anotações, e-mail, ditado, pesquisa de documentos e organização parecem menos glamourosas do que gerar um vídeo cinematográfico. Mas, para quem trabalha com conhecimento, elas podem ser mais úteis.

A maior virada de chave ocorre quando a IA deixa de conversar apenas com “a internet” e passa a trabalhar sobre material confiável e permitido: documentação oficial, runbooks, procedimentos, atas, manuais, apostilas, normas, código autorizado e notas técnicas.

Imagine duas perguntas.

A primeira:

“Como resolver um ICH408I?”

A segunda:

“Com base no procedimento de acesso de homologação, explique o fluxo aprovado para investigar ICH408I, indicando que evidências devem ser coletadas antes de solicitar alteração de perfil.”

A primeira pode oferecer boas ideias gerais. A segunda pode ajudar no trabalho real — desde que a base de documentos esteja correta e que a empresa autorize esse tratamento.

Aqui entra um cuidado sério: dados de produção, dumps, credenciais, informações pessoais, chaves, código proprietário e documentação interna não devem ser enviados automaticamente para qualquer serviço externo. O entusiasmo com IA não suspende LGPD, contrato, sigilo profissional, política de segurança ou bom senso.

No mainframe, segurança não é enfeite de apresentação. É controle de acesso, segregação de funções, trilha de auditoria e mínima permissão necessária. Uma ferramenta inteligente com acesso amplo continua sendo uma ferramenta com acesso amplo. E isso é exatamente o tipo de coisa que House chamaria de “ideia ruim com interface amigável”.


5. Quinta etapa: voz, imagem, vídeo e design — visual forte exige direção, não apenas geração

Ferramentas de imagem, vídeo, música, voz e design permitem testar ideias com uma rapidez que seria impensável há pouco tempo. Você pode imaginar um mainframe como uma usina, um cowboy CICS perseguindo um abend ou Dr. House examinando um programa COBOL em coma — e transformar essa cena em imagem.

Isso é valioso. O visual prende atenção, facilita a memória e abre a porta para a explicação.

Mas imagem gerada não é documentação técnica. Ela ilustra uma ideia; não prova um fato. E qualquer texto técnico dentro de uma imagem exige revisão. Nomes de comandos, mensagens de erro, campos COBOL, números de versão e sintaxe são terreno fértil para pequenas deformações que o olho passa por cima e o leitor atento percebe.

Um bom processo visual tem quatro partes:

  1. Definir a mensagem: qual é a única ideia que a imagem deve transmitir?

  2. Gerar a cena-base: usar IA para composição, personagens, cor e atmosfera.

  3. Revisar os detalhes: corrigir termos, legibilidade, logo, dados e contexto.

  4. Manter identidade: repetir elementos visuais que façam o leitor reconhecer sua marca.

A imagem não precisa explicar tudo. Ela deve fazer o leitor querer entrar no texto.


6. Sexta etapa: automatizar — o ponto onde a produtividade vira operação

Automação é a etapa mais poderosa e, por isso mesmo, a que exige mais disciplina.

Ferramentas como n8n, Zapier, agentes, conectores, robôs de coleta e serviços de integração permitem ligar eventos e ações. Um arquivo chegou? O fluxo lê, organiza, gera resumo e envia para revisão. Uma fonte oficial publicou notícia? O fluxo coleta links, classifica assuntos e prepara o radar semanal. Uma planilha mudou? O processo atualiza uma base ou cria uma tarefa.

Isso poupa horas. Mas “automatizar tudo” é uma frase que deveria vir com sirene, extintor e uma pessoa segurando o botão de desligar.

O fluxo saudável é:

Evento → coleta → organização → rascunho → revisão humana → ação externa

O fluxo perigoso é:

Evento → IA interpreta → IA decide → IA publica → IA responde → problema

A diferença é a aprovação humana. Quanto maior o impacto da ação, maior deve ser a trava.

Para automatizar com segurança, siga o passo a passo do jovem padawan:

  1. Escolha uma tarefa repetitiva e bem compreendida.

  2. Execute o processo manualmente algumas vezes e documente cada passo.

  3. Defina entradas, saídas e exceções.

  4. Automatize primeiro apenas a coleta ou o rascunho.

  5. Mantenha aprovação humana para publicar, enviar, apagar, pagar, conceder acesso ou alterar registros críticos.

  6. Registre logs.

  7. Crie limite de volume, tentativas e custo.

  8. Teste falhas de propósito.

  9. Garanta que exista um botão de desligar.

  10. Revise o fluxo periodicamente.

Em linguagem de mainframe: não entregue ALTER, DELETE, acesso privilegiado e SUBMIT de produção para um processo que ninguém consegue explicar. Primeiro defina o procedimento. Depois teste. Depois limite. Depois monitore. Só então escale.


7. A etapa esquecida no infográfico: validar

O grande buraco de muitos mapas de IA é a ausência da validação. Eles mostram pensar, criar e automatizar, mas pulam justamente a parte em que o adulto entra na sala e pergunta: “como sabemos que isso está certo?”

A versão madura das seis etapas seria:

  1. definir o problema;

  2. pesquisar e raciocinar;

  3. produzir um rascunho;

  4. validar tecnicamente e contextualmente;

  5. publicar ou executar;

  6. automatizar o que já funciona.

A validação depende do tipo de trabalho:

EntregaValidação mínima
Texto técnicofontes, exemplos, termos e versão correta
Códigocompilação, testes, revisão e segurança
Imagemlegibilidade, fidelidade de termos e direitos
Automaçãologs, limites, falhas e reversão
Resposta operacionalevidência, procedimento e responsável

House fecha a pasta do paciente.

— Então qual é o diagnóstico?

O padawan respira e responde:

— IA não é um substituto para pensar. É uma forma de encurtar a distância entre uma pergunta bem feita e uma entrega revisada.

House dá um meio sorriso, o equivalente médico a fogos de artifício.

— Agora você pode ter alta. Mas não toque em produção.


Epílogo — O logo não tem a culpa, mas também não faz o trabalho

As ferramentas do infográfico são úteis. Muitas são excelentes. Algumas serão substituídas, incorporadas por outras ou mudarão de preço, recurso e qualidade em poucos meses. Esse é o detalhe menos importante.

O que permanece é o método.

Use IA para pensar melhor, não para terceirizar o pensamento. Use-a para acelerar código, mas teste antes de confiar. Use-a para multiplicar um conteúdo que tenha substância. Use-a para organizar conhecimento permitido e confiável. Use-a para criar visuais que abram a conversa. Use-a para automatizar o repetitivo — nunca para entregar decisões perigosas a uma caixa-preta simpática.

O programador COBOL iniciante que aprende isso cedo leva uma vantagem enorme. Ele não será a pessoa que sabe pedir “faça um sistema bancário completo”. Será a pessoa que entende a pergunta, identifica a regra, procura a evidência, testa a resposta, protege os dados e sabe onde a automação deve parar.

No fim, o mainframe e o Dr. House concordam em algo: confiança não vem de uma tela bonita dizendo que deu certo. Confiança vem de evidência, controle, rastreabilidade e da capacidade de descobrir o que aconteceu quando, inevitavelmente, alguma coisa der errado.

E quando o primeiro S0C7 aparecer no plantão, não entre em pânico. Pegue o café, reúna os fatos, faça perguntas melhores e desconfie de toda resposta que parece fácil demais.

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