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

quarta-feira, 1 de julho de 2026

Capítulo 1 — O Funeral que Nunca Aconteceu

Bellacosa Mainframe e o funeral que nunca aconteceu


Uma viagem histórica pelas previsões que anunciaram a morte do mainframe e pela engenharia que manteve COBOL, CICS, Db2, JCL, z/OS e IBM Z essenciais até 2026.

Por


☕ Um Café no Bellacosa Mainframe

Capítulo 1 — O Funeral que Nunca Aconteceu

"Existem três coisas extremamente perigosas na Tecnologia da Informação: benchmark sem contexto, buzzword da moda e jornalista anunciando a morte de uma tecnologia que movimenta bilhões de dólares por dia."
— Bellacosa Mainframe


O dia em que enterraram um computador... que continuou trabalhando

Imagine a cena.

Março de 1991.

Um auditório lotado.

Executivos de gravata.

Consultores distribuindo transparências de retroprojetor.

Especialistas apontando para gráficos coloridos.

No centro da sala, um palestrante sobe ao palco e anuncia, com a confiança de quem acredita estar vendo o futuro:

— "O mainframe morreu."

A plateia aplaude.

Outro completa:

— "Agora tudo será Client/Server."

Mais um responde:

— "COBOL acabou."

Um terceiro acrescenta:

— "Em poucos anos ninguém mais usará JCL."

Lá no fundo alguém grita:

— "Windows NT vai dominar o mundo!"

E outro completa:

— "UNIX substituirá tudo."

Naquele instante parecia impossível discordar.

A imprensa repetia.

Os analistas confirmavam.

Os fabricantes concorrentes comemoravam.

As consultorias vendiam projetos milionários de migração.

Os buzzwords surgiam mais rápido do que versões de frameworks aparecem hoje.

Enquanto isso...

A milhares de quilômetros dali...

Sem plateia.

Sem marketing.

Sem PowerPoint.

Sem keynote.

Um IBM Mainframe continuava fazendo exatamente o que sempre fez.

Processando folha de pagamento.

Autorizando compras.

Movimentando contas bancárias.

Controlando companhias aéreas.

Executando milhões de transações CICS.

Atualizando tabelas Db2.

Executando milhares de JOBs JES2.

Processando COBOL.

Respondendo IMS.

Gerenciando VSAM.

Sem saber que, segundo alguns especialistas, ele já estava morto.


Bellacosa Mainframe e o IBM S390 que atravessou o olho do furacão

O morto mais produtivo da história da computação

Existe uma ironia maravilhosa nessa história.

Poucas tecnologias receberam tantos atestados de óbito quanto o mainframe.

E poucas sobreviveram tão bem.

Durante praticamente toda a década de 1990 surgiu uma nova manchete anunciando que aquele enorme computador centralizado finalmente havia chegado ao fim.

Era compreensível.

Os PCs evoluíam rapidamente.

As redes Ethernet cresciam.

Os servidores UNIX ficavam mais baratos.

Windows NT surgia como promessa corporativa.

A internet começava sua explosão.

Tudo parecia apontar para um futuro distribuído.

O problema não era enxergar essas tendências.

O problema era acreditar que evolução significava substituição.

Foi exatamente esse erro que boa parte da indústria cometeu.


A década dos Buzzwords

Se você é um Padawan COBOL em 2026, talvez ache engraçado imaginar uma época sem Cloud, Kubernetes, DevOps, IA Generativa ou LLMs.

Mas toda geração cria seus próprios modismos.

Na década de 1990 eles tinham nomes diferentes.

Client/Server.

Downsizing.

Open Systems.

Distributed Computing.

Network Computing.

Workstations.

RISC.

Windows NT.

Cada um era apresentado como "o futuro inevitável".

Bastava colocar um desses nomes em um folder colorido e, magicamente, o produto parecia revolucionário.

Era como se existisse um encantamento corporativo.

Se um software fosse chamado apenas de "Sistema Financeiro", ninguém prestava atenção.

Mas bastava renomeá-lo para:

Open Distributed Client/Server Enterprise Architecture Framework

...e imediatamente ele parecia valer dez vezes mais.

Mudou alguma coisa desde então?

Talvez apenas os nomes.

Hoje trocamos "Client/Server" por "AI Native".

"Distributed Computing" virou "Cloud First".

"Open Systems" virou "Platform Engineering".

"SOA" virou "Microservices".

"Big Data" virou "Data Fabric".

"Machine Learning" virou "Generative AI".

A tecnologia evolui.

Os buzzwords apenas mudam de roupa.


O professor que resolveu guardar a história

Anos depois, o professor Wilhelm G. Spruth, uma das maiores autoridades mundiais em Enterprise Computing e tecnologia IBM Z, teve uma ideia brilhante.

Em vez de simplesmente dizer que aquelas previsões estavam erradas...

Ele resolveu preservá-las.

Em seu famoso trabalho "The Death of the Mainframe", Spruth reuniu exatamente essas manchetes históricas publicadas por jornais, revistas e analistas de mercado. Seu objetivo não era ridicularizar ninguém, mas mostrar como previsões tecnológicas podem ser influenciadas pelo entusiasmo do momento e pelo marketing da indústria.

Graças a esse trabalho, hoje podemos olhar para aquelas páginas quase como um arqueólogo observa um fóssil.

Cada manchete conta uma história.

Cada previsão revela como a indústria pensava.

Cada erro ensina uma lição.


Este artigo não é sobre rir do passado

Seria muito fácil fazer piada.

E faremos algumas.

Mas o objetivo aqui é outro.

Vamos entender por que pessoas extremamente inteligentes chegaram à conclusão de que o mainframe morreria.

Na época, isso parecia lógico.

Muitos dos argumentos eram tecnicamente consistentes.

O problema é que quase todos analisavam apenas o hardware.

Pouquíssimos observavam aquilo que realmente sustentava o mundo corporativo:

  • décadas de regras de negócio;

  • milhões de linhas de COBOL;

  • consistência transacional;

  • disponibilidade próxima de 100%;

  • segurança;

  • auditoria;

  • governança;

  • integração;

  • custo gigantesco de uma migração.

Eles olharam para o computador.

Esqueceram de olhar para o negócio.

E negócios raramente seguem modismos.


Trinta anos depois...

Agora avance o calendário.

Não estamos mais em 1991.

Nem em 1996.

Estamos em 2026.

Enquanto muitos dos "assassinos do mainframe" desapareceram, foram comprados, mudaram de nome ou simplesmente deixaram de existir, o IBM Z continua evoluindo.

Hoje temos:

  • IBM z17;

  • aceleração de IA integrada;

  • watsonx;

  • IBM Build Open Builder (BOB);

  • OpenShift;

  • Ansible;

  • Zowe;

  • DevOps;

  • APIs REST;

  • containers Linux;

  • Enterprise COBOL cada vez mais otimizado;

  • Db2 mais inteligente;

  • CICS mais moderno;

  • z/OS integrando cloud híbrida e inteligência artificial.

O "dinossauro" aprendeu a conversar com Kubernetes.

Aprendeu a executar IA.

Aprendeu a expor APIs.

Aprendeu DevOps.

E fez tudo isso sem abandonar aquilo que sempre soube fazer melhor: executar cargas críticas com confiabilidade extraordinária.


Bem-vindo ao maior "post-mortem" da história da TI

Nos próximos capítulos vamos abrir uma verdadeira cápsula do tempo.

Vamos revisitar, uma a uma, as reportagens da Forbes, The New York Times, InfoWorld e Business Week.

Você verá o contexto histórico.

Os argumentos utilizados.

O que acertaram.

O que erraram.

Como aquelas previsões influenciaram toda uma geração de arquitetos e executivos.

E, principalmente, por que o tempo mostrou que o futuro costuma ser muito mais complexo do que qualquer manchete de capa consegue prever.

Pegue seu café.

Abra o ISPF.

Porque a autópsia vai começar.

E, curiosamente, o paciente ainda está trabalhando.

Bellacosa Mainframe e a serie o Funeral que nunca aconteceu


 

C:\BELLACOSA\COBOL\FUNERAL_QUE_NUNCA_ACONTECEU.HTML
★ BELLACOSA MAINFRAME APRESENTA ★

A MORTE DO COBOL

O Funeral que Nunca Aconteceu

Uma investigação histórica em 14 capítulos sobre as previsões, reportagens, buzzwords e profetas que anunciaram repetidamente o fim do COBOL — enquanto bilhões de transações continuavam sendo processadas silenciosamente.

SISTEMA ONLINE — 14 CAPÍTULOS DISPONÍVEIS
▼ DIRETÓRIO DE CAPÍTULOS ▼

README.TXT

Esta série investiga uma das narrativas mais repetidas da história da tecnologia: a suposta morte do COBOL. Durante décadas, revistas, jornais, consultorias e especialistas anunciaram seu desaparecimento. Entretanto, o COBOL permaneceu processando bancos, seguradoras, governos, cartões, pagamentos e sistemas críticos.

Os títulos e links acima são elementos HTML reais, permitindo que mecanismos de busca encontrem e rastreiem todos os capítulos. Os iframes funcionam apenas como previews visuais.

C:\> RUN BELLACOSA.EXE /COBOL /HISTORY /NO-FUNERAL _

★ BELLACOSA MAINFRAME ★ COBOL ★ IBM Z ★ HISTÓRIA DA COMPUTAÇÃO ★

Melhor visualizado em qualquer navegador com café disponível.

 


sexta-feira, 12 de junho de 2026

☕🚀 COBOL FORA DO MAINFRAME: POR QUE ELE NÃO CONQUISTOU O MUNDO COMO JAVA, C# E PYTHON?


Bellacosa Mainframe e tenta entender a razao do Cobol nao existir fora do Mainframe

☕🚀 COBOL FORA DO MAINFRAME: POR QUE ELE NÃO CONQUISTOU O MUNDO COMO JAVA, C# E PYTHON?

Quando alguém fala em COBOL, a maioria das pessoas imediatamente imagina um enorme IBM Z, salas refrigeradas, bancos, seguradoras e sistemas que movimentam bilhões de dólares por dia.

Mas existe uma curiosidade que poucos conhecem:

O COBOL nunca foi exclusivo do Mainframe.

Durante décadas existiram versões para:

  • MS-DOS

  • Windows

  • Linux

  • Unix

  • AIX

  • HP-UX

  • Solaris

  • AS/400

  • VMS

  • até mesmo Raspberry Pi atualmente

Empresas como Micro Focus, Fujitsu, RM/COBOL, Acucobol, GNUCobol e outras investiram milhões tentando popularizar o COBOL fora do universo IBM.

Mesmo assim, quando ouvimos a palavra COBOL em 2026, quase todo mundo associa imediatamente ao Mainframe.

A pergunta é inevitável:

Por que isso aconteceu?

Por que Java virou universal?

Por que C conquistou sistemas operacionais?

Por que Python dominou a automação?

E por que COBOL permaneceu praticamente "preso" ao Mainframe?

A resposta envolve tecnologia, mercado, marketing, história, cultura corporativa e até psicologia.

Pegue seu café.

Hoje vamos mergulhar em uma das maiores curiosidades da história da computação.


O MAIOR MITO SOBRE COBOL

Existe uma crença popular:

"COBOL só funciona em Mainframe."

Isso nunca foi verdade.

Desde os anos 70 já existiam compiladores COBOL para minicomputadores.

Nos anos 80 surgiram versões para:

  • DOS

  • Unix

  • VAX/VMS

Nos anos 90:

  • Windows

  • OS/2

  • Linux

Nos anos 2000:

  • .NET

  • JVM

  • Web Services

Tecnicamente falando, o COBOL poderia ter seguido praticamente qualquer caminho.

Mas não seguiu.


O PROBLEMA NUNCA FOI A LINGUAGEM

Essa é a primeira coisa que surpreende muita gente.

O COBOL não fracassou fora do Mainframe porque era ruim.

Na verdade ele possuía diversas vantagens.

Extremamente legível

Exemplo:

IF SALDO-CONTA IS GREATER THAN LIMITE-CREDITO
   DISPLAY "LIMITE EXCEDIDO"
END-IF

Até alguém sem conhecimento profundo consegue entender.


Excelente para regras de negócio

Bancos adoram COBOL porque ele descreve regras empresariais com clareza.

Por exemplo:

COMPUTE JUROS =
    VALOR * TAXA / 100

Não existe mistério.


Forte manipulação de registros

Antes dos bancos relacionais se popularizarem, isso era ouro.


Precisão decimal

Enquanto várias linguagens sofriam com arredondamentos, COBOL nasceu para dinheiro.

E dinheiro não aceita erro.


O VERDADEIRO PROBLEMA: O COBOL NASCEU PARA NEGÓCIOS

A palavra COBOL significa:

Common Business Oriented Language

Observe:

Não é:

  • Common Game Language

  • Common Scientific Language

  • Common Internet Language

É:

Business.

Negócios.

Empresas.

Contabilidade.

Folha de pagamento.

Seguros.

Finanças.

Faturamento.

Desde o nascimento, ele tinha um propósito extremamente específico.


ENQUANTO ISSO, O MUNDO MUDOU

Na década de 1960 isso era perfeito.

Mas nas décadas seguintes surgiram novos mercados.


Computação científica

FORTRAN dominou.


Sistemas operacionais

C dominou.


Inteligência Artificial

LISP dominou inicialmente.


Aplicações gráficas

C++


Internet

Java

PHP

Perl

JavaScript


Ciência de Dados

Python

R


O mundo começou a exigir coisas que nunca foram prioridade para o COBOL.


O COBOL NÃO FOI FEITO PARA SER "COOL"

Aqui existe um fator psicológico interessantíssimo.

Pense nos heróis da programação:

  • Linus Torvalds → C

  • Guido van Rossum → Python

  • Bjarne Stroustrup → C++

  • James Gosling → Java

Agora pense em COBOL.

A maioria das pessoas nem sabe quem foi Grace Hopper.

Grace Hopper ajudou a criar conceitos fundamentais que levariam ao COBOL.

Mas a linguagem nunca foi vendida como algo revolucionário.

Ela foi vendida como algo:

  • estável

  • corporativo

  • burocrático

E isso afasta jovens desenvolvedores.


O EFEITO "BANCO"

Imagine dois anúncios.

Linguagem A

"Crie jogos incríveis!"

Linguagem B

"Automatize cálculos atuariais."

Qual parece mais divertida?

Foi exatamente isso que aconteceu.

COBOL ficou associado a:

  • bancos

  • seguradoras

  • governos

  • sistemas legados

Enquanto outras linguagens ficaram associadas à inovação.


O ERRO DE MARKETING MAIS CARO DA HISTÓRIA

Durante os anos 80 e 90, universidades começaram a ensinar:

  • C

  • Pascal

  • C++

  • Java

COBOL desapareceu dos cursos.

A consequência foi devastadora.

Menos estudantes.

Menos projetos.

Menos comunidade.

Menos livros.

Menos ferramentas.

Menos conteúdo.

Menos adoção.

Criou-se um círculo vicioso.


O PROBLEMA DAS FERRAMENTAS

Vamos ser honestos.

Nos anos 90 era muito mais divertido programar Visual Basic do que COBOL.

Visual Basic tinha:

  • botões

  • janelas

  • eventos

Você arrastava componentes.

Tudo aparecia na tela.

COBOL continuava focado em:

OPEN INPUT CLIENTES
READ CLIENTES

O apelo visual era praticamente zero.


O MUNDO APAIXONOU-SE POR INTERFACES GRÁFICAS

Quando o Windows explodiu, surgiu uma nova geração de desenvolvedores.

Eles queriam construir:

  • telas

  • jogos

  • multimídia

COBOL não era o candidato natural.


O MAINFRAME PROTEGEU O COBOL

Aqui está a maior ironia.

O Mainframe foi simultaneamente:

  • a maior força do COBOL

  • e sua maior prisão

Sem Mainframe talvez COBOL tivesse desaparecido.

Mas graças ao Mainframe ele sobreviveu.

Por outro lado, o sucesso no Mainframe reduziu o incentivo para conquistar outros mercados.

Os bancos já estavam satisfeitos.

Por que mudar?


O FATOR ECONÔMICO

Imagine um banco.

Você possui:

  • 50 milhões de linhas COBOL

  • 40 anos de história

  • bilhões movimentados diariamente

Qual decisão é mais segura?

Opção A

Migrar tudo.

Opção B

Continuar usando COBOL.

A resposta é óbvia.


O EFEITO "SE ESTÁ FUNCIONANDO, NÃO MEXA"

Poucas linguagens tiveram a sorte de trabalhar em ambientes tão conservadores.

Um sistema bancário precisa:

  • estabilidade

  • previsibilidade

  • auditoria

Não precisa ser moderno.

Precisa funcionar.

E COBOL funciona.

Muito bem.


A CHEGADA DA INTERNET

Nos anos 90 surgiu a Web.

Foi uma nova corrida do ouro.

Linguagens correram para conquistar esse território.

  • Java

  • PHP

  • Perl

  • ASP

COBOL chegou depois.

Muito depois.

Quando chegou, o mercado já tinha donos.


O PROBLEMA DA COMUNIDADE

Uma linguagem vive ou morre pela comunidade.

Python possui:

  • milhões de usuários

  • milhares de bibliotecas

  • eventos globais

Java possui ecossistema gigantesco.

COBOL sempre teve uma comunidade menor.

Extremamente qualificada.

Mas menor.


O FATOR OPEN SOURCE

Outro golpe importante.

O movimento Open Source impulsionou:

  • Linux

  • Python

  • PHP

  • Perl

COBOL permaneceu muito ligado ao mundo corporativo.

Licenças caras.

Compiladores pagos.

Ferramentas empresariais.

Isso limitou sua expansão.


MAS EXISTE COBOL OPEN SOURCE

Hoje existe o fantástico:

GNUCobol

GnuCOBOL Official Project

Ele compila COBOL para C e roda em:

  • Linux

  • Windows

  • macOS

Mostrando que o COBOL continua vivo fora do Mainframe.


O COBOL É LENTO?

Outro mito.

Na verdade, muitas implementações COBOL são extremamente rápidas.

Especialmente em processamento transacional.

O problema nunca foi desempenho.


O COBOL É ANTIGO DEMAIS?

Também não.

Veja a ironia.

Hoje temos:

  • APIs REST

  • JSON

  • XML

  • Kafka

  • Containers

  • Docker

E o COBOL já conversa com tudo isso.

Inclusive o usuário Bellacosa Mainframe frequentemente explora integrações modernas entre COBOL, JSON, CICS Web Services e z/OS Connect.

O problema não é tecnológico.

É percepção de mercado.


O PARADOXO DO SUCESSO

O COBOL sofreu do mesmo problema que o DB2 Mainframe.

Ele ficou tão bom no que fazia que nunca precisou mudar radicalmente.

Enquanto outras linguagens lutavam para sobreviver, o COBOL já tinha conquistado o setor financeiro.


O QUE ACONTECERIA SE O COBOL FOSSE CRIADO HOJE?

Imagine uma linguagem com:

  • sintaxe legível

  • precisão decimal nativa

  • foco em regras de negócio

  • forte tipagem

  • excelente auditoria

Provavelmente seria vendida como:

  • FinTech Language

  • Banking Language

  • Enterprise Language

E talvez fosse considerada revolucionária.


O COBOL PERDEU A GUERRA?

Não.

Na verdade, ele venceu uma guerra diferente.

Enquanto milhares de linguagens nasceram e morreram, COBOL continua executando sistemas críticos após mais de seis décadas.

Poucas tecnologias na história conseguiram isso.


A VERDADE QUE POUCOS ADMITEM

Quando um programador Python cria um sistema hoje, ninguém sabe se ele existirá daqui a 30 anos.

Quando um programador COBOL cria um sistema bancário, existe uma boa chance de alguém ainda estar executando aquele código décadas depois.

Isso muda completamente a forma de projetar software.


A GRANDE LIÇÃO PARA OS PADAWANS

A pergunta correta não é:

"Por que COBOL ficou nichado no Mainframe?"

A pergunta correta é:

"Por que o Mainframe continuou sendo o melhor lugar para executar aquilo que o COBOL foi criado para fazer?"

Porque o COBOL nasceu para resolver problemas empresariais gigantescos.

E o Mainframe continua sendo a plataforma mais eficiente para executar esses processos com:

  • confiabilidade

  • segurança

  • disponibilidade

  • escalabilidade

  • integridade transacional

O COBOL não ficou preso ao Mainframe.

Na realidade, ele encontrou seu habitat natural.

As versões para DOS, Windows e Linux sempre existiram, continuam existindo e funcionam muito bem.

Mas fora do Mainframe ele precisava competir com centenas de linguagens.

Dentro do Mainframe ele se tornou rei.

E existe uma enorme diferença entre participar de uma competição e dominar um reino.

Mais de 65 anos depois de seu nascimento, o COBOL continua processando salários, aposentadorias, seguros, cartões de crédito, transferências bancárias e operações financeiras que sustentam boa parte da economia mundial.

Poucas linguagens podem dizer isso.

E talvez esse seja o maior paradoxo da computação:

O COBOL não conquistou todas as plataformas porque nunca precisou.

Ele já estava ocupado movendo o mundo. ☕🚀



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