 |
| Bellacosa Mainframe do rust ao cobol no zos |
☕ Um Café no Bellacosa Mainframe
De Rust ao COBOL no IBM Z
Você Não Está Abandonando a Programação Moderna. Está Descobrindo Onde a Engenharia de Software Aprendeu a Nunca Falhar.
"Rust ensina você a escrever programas seguros. O IBM Z ensina você a manter um país funcionando às três da manhã de uma segunda-feira."
Existe uma pergunta que aparece com frequência quando um desenvolvedor Rust descobre o universo IBM Z:
"Faz sentido aprender COBOL em pleno século XXI?"
Minha resposta costuma ser outra pergunta.
Você quer aprender apenas uma linguagem ou quer aprender como funcionam alguns dos sistemas mais confiáveis do planeta?
Porque existe uma enorme diferença entre essas duas coisas.
Quem programa em Rust normalmente já possui uma mentalidade extremamente valorizada no mundo Mainframe.
Você já aprendeu a respeitar memória.
Já aprendeu que performance importa.
Já aprendeu que concorrência não é brincadeira.
Já aprendeu que estabilidade vale mais que "funcionou na minha máquina".
Na verdade...
Você está muito mais preparado para aprender COBOL do que imagina.
Só precisa trocar algumas lentes.
O maior erro
Muita gente tenta comparar:
Rust × COBOL
Essa comparação é injusta.
Seria como comparar:
um bisturi
uma usina hidrelétrica
Os dois resolvem problemas.
Mas vivem em mundos completamente diferentes.
Rust nasceu para produzir software extremamente seguro.
COBOL nasceu para processar negócios.
O IBM Z nasceu para garantir que esses negócios nunca parem.
Quando entendemos isso, tudo muda.
O pensamento do desenvolvedor Rust
Quem vive em Rust normalmente pensa em:
ownership
borrowing
lifetimes
Result
Option
Traits
Enums
Pattern Matching
Zero Cost Abstractions
Async
Tokio
Cargo
Crates
módulos
performance
segurança
É uma linguagem construída para impedir erros antes mesmo da compilação.
Isso muda completamente a forma de desenvolver.
 |
| Bellacosa Mainframe rust versus cobol no zos |
O pensamento do desenvolvedor COBOL
Já o programador COBOL pensa em coisas diferentes.
Ele pensa em:
regras de negócio
consistência
auditoria
precisão decimal
processamento em lote
processamento online
disponibilidade
rastreabilidade
recuperação
confiabilidade
Observe uma curiosidade.
Rust protege memória.
COBOL protege dinheiro.
Ambos protegem algo extremamente importante.
O choque inicial
O primeiro contato costuma causar estranheza.
O desenvolvedor Rust abre um programa COBOL e pensa:
"Cadê as funções?"
"Cadê os módulos?"
"Cadê os generics?"
"Cadê os traits?"
"Cadê o Cargo?"
É normal.
Porque COBOL foi criado em outra época.
Mas existe um detalhe interessante.
As versões modernas do Enterprise COBOL evoluíram bastante.
Hoje encontramos:
variáveis locais
recursão
XML
JSON
UTF-8
chamadas para Java
interoperabilidade com C
otimizações sofisticadas
integração com APIs REST através do ecossistema IBM Z
Não é o COBOL dos anos 70.
O que você precisa desaprender
Talvez a mudança mais importante seja esta.
No mundo Rust pensamos muito em estruturas de dados.
No mundo Mainframe pensamos primeiro em processos de negócio.
A pergunta deixa de ser:
"Como armazeno isso?"
e passa a ser:
"Como um banco liquida milhões de operações sem perder um centavo?"
É outro tipo de engenharia.
O que continua igual
Mais do que muita gente imagina.
Organização
Rust organiza código.
COBOL também.
Você terá:
programas
subprogramas
copybooks
bibliotecas
interfaces
A ideia continua sendo dividir responsabilidades.
Legibilidade
Rust valoriza código limpo.
COBOL também.
Aliás...
COBOL talvez seja uma das linguagens mais próximas da linguagem humana.
IF SALDO > LIMITE
PERFORM BLOQUEAR-CONTA
END-IF
Mesmo quem nunca programou consegue entender.
Modularização
Rust:
mod
COBOL:
CALL
Em ambos os casos você evita duplicação.
Testes
Rust possui uma cultura fantástica de testes.
Leve isso para o Mainframe.
Hoje existem ferramentas como:
zUnit
COBOL Unit Test
COBOL Check
integração com Jenkins
GitHub Actions
GitLab CI
Azure DevOps
Você pode continuar praticando TDD.
Performance
Rust busca eficiência.
IBM Z vive disso.
Só que existe uma diferença.
Rust normalmente otimiza microssegundos.
IBM Z otimiza milhões de transações simultâneas.
É outra escala.
O que muda completamente
Agora começam as novidades.
Você deixa de pensar apenas em programas
No Mainframe, um programa nunca vive sozinho.
Ele conversa com um enorme ecossistema.
Você conhecerá:
JCL
JES2
TSO
ISPF
SDSF
RACF
CICS
Db2
VSAM
MQ
z/OS
Tudo faz parte do mesmo universo.
O sistema operacional é diferente
Windows e Linux nasceram para computadores relativamente independentes.
O z/OS nasceu para um computador compartilhado por milhares de pessoas ao mesmo tempo.
Cada detalhe foi pensado para isso.
É um paradigma completamente diferente.
Batch não é coisa antiga
Essa talvez seja a maior surpresa.
Muitos imaginam que Batch significa tecnologia ultrapassada.
Na verdade...
Batch significa processamento massivo.
Imagine:
fechar cartões de crédito
calcular juros
atualizar milhões de contas
gerar extratos
enviar PIX agendados
consolidar posições financeiras
Tudo isso continua acontecendo diariamente.
E continua extremamente eficiente.
CICS muda sua visão
Depois você conhecerá CICS.
E entenderá que um terminal 3270 pode responder milhares de usuários com latência impressionante.
Sem navegador.
Sem JavaScript.
Sem frameworks gigantescos.
Apenas engenharia.
O que estudar primeiro
Aqui vejo muitos alunos errando.
Eles começam por CICS.
Ou Db2.
Ou IMS.
Não faça isso.
Existe uma ordem muito melhor.
Etapa 1 — Aprenda COBOL puro
Domine:
IDENTIFICATION DIVISION
ENVIRONMENT DIVISION
DATA DIVISION
PROCEDURE DIVISION
Depois pratique:
IF
EVALUATE
PERFORM
SEARCH
OCCURS
INDEX
tabelas
arquivos sequenciais
Escreva muitos programas pequenos.
Etapa 2 — Entenda dados
Rust trabalha muito com estruturas.
No Mainframe você precisa dominar layouts.
Aprenda:
PIC
COMP
COMP-3
DISPLAY
REDEFINES
OCCURS
COPYBOOKS
Essa é uma das partes mais importantes.
Etapa 3 — Aprenda JCL
Não existe desenvolvimento Mainframe sem JCL.
Aprenda:
JOB
EXEC
DD
PROC
COND
IF/THEN
SORT
IDCAMS
IEBGENER
Pense no JCL como um orquestrador.
Etapa 4 — TSO e ISPF
Domine o ambiente.
Aprenda:
editar
compilar
navegar datasets
membros
utilitários
SDSF
Isso aumenta muito sua produtividade.
Etapa 5 — Arquivos
Estude:
Sequential
VSAM KSDS
ESDS
RRDS
Entenda quando usar cada um.
Etapa 6 — Db2
Agora sim.
Aprenda:
SQL
Embedded SQL
Cursor
Commit
Rollback
Quem conhece Rust provavelmente já trabalhou com bancos relacionais.
A adaptação será tranquila.
Etapa 7 — CICS
Somente depois.
Aprenda:
COMMAREA
Channels
Containers
BMS
Transações
Program Control
Etapa 8 — Segurança
Conheça RACF.
Entenda:
usuários
grupos
permissões
datasets
recursos
Segurança faz parte da arquitetura.
Etapa 9 — Observabilidade
Aprenda:
SDSF
mensagens
ABENDs
dumps
logs
SMF
Aqui você começa a pensar como um engenheiro de produção.
O que praticar diariamente
Uma hora por dia já produz resultados impressionantes.
Minha sugestão é:
Segunda
resolver exercícios COBOL
Terça
ler JCL
Quarta
manipular arquivos
Quinta
SQL no Db2
Sexta
estudar arquitetura IBM Z
Sábado
criar pequenos projetos
Domingo
revisar tudo
Consistência vale mais que intensidade.
Habilidades que você já possui
Como desenvolvedor Rust você provavelmente já domina:
Git
GitHub
VS Code
terminal
debugging
documentação
leitura de RFCs
APIs
JSON
testes automatizados
Continue usando tudo isso.
Hoje é perfeitamente possível editar programas COBOL no VS Code utilizando extensões modernas, Git e pipelines de integração contínua. O desenvolvimento Mainframe está cada vez mais próximo das práticas que você já conhece no ecossistema open source.
O que você deve desenvolver
Além da linguagem, treine a forma de pensar.
Aprenda a fazer perguntas como:
O que acontece se este programa falhar às 2h da manhã?
Como recuperar uma execução interrompida?
Como garantir que nenhuma transação seja perdida?
Como auditar cada alteração?
Como processar bilhões de registros mantendo integridade?
Como manter compatibilidade com programas escritos há décadas?
Essas perguntas definem um engenheiro de software para sistemas críticos.
A maior mudança de mentalidade
No universo Rust, muitas vezes o foco está em construir algo novo.
No universo IBM Z, o foco é evoluir algo que já funciona, sem interromper um serviço essencial.
É uma disciplina diferente. Você aprende a respeitar contratos, compatibilidade, governança e continuidade operacional. Descobre que inovação também significa modernizar com segurança, integrar APIs, automatizar deploys, usar Git, DevOps e observabilidade, sem colocar em risco aplicações que movimentam bilhões de reais todos os dias.
A recompensa
Depois de alguns meses, você perceberá algo curioso.
COBOL deixará de parecer uma linguagem antiga.
Você começará a enxergar padrões de engenharia extremamente maduros.
Verá programas que processam volumes gigantescos há décadas, passando por inúmeras evoluções sem perder estabilidade. Entenderá por que bancos, seguradoras, companhias aéreas e governos continuam confiando no IBM Z para suas operações mais críticas.
E, nesse momento, você descobrirá que aprender Mainframe nunca foi apenas aprender COBOL.
Foi aprender uma maneira diferente de construir software: uma maneira em que disponibilidade, integridade, desempenho, segurança e continuidade têm prioridade absoluta.
Rust continuará sendo uma excelente linguagem para escrever software moderno, rápido e seguro.
COBOL continuará sendo uma excelente linguagem para expressar regras de negócio de forma clara e confiável.
O IBM Z continuará sendo uma das plataformas mais sofisticadas já criadas para executar essas regras em escala global.
Você não está trocando um mundo pelo outro.
Está unindo dois dos maiores exemplos de engenharia de software já produzidos.
E quando um desenvolvedor Rust aprende a pensar como um engenheiro de Mainframe, ele não se torna apenas um programador mais versátil.
Ele passa a compreender como a tecnologia que mantém o mundo funcionando foi construída — e por que continua relevante, décadas depois.
Esse é o verdadeiro objetivo da jornada.
