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

quarta-feira, 29 de julho de 2026

O Portal Stargate do IBM Z : Descobre que Git, DevOps e CI/CD Não São Tecnologias Alienígenas.

 

Bellacosa Mainframe e o portal stargata para adentrar no novo mundo do desenvolvimento mainframe

☕ Um Café no Bellacosa Mainframe

O Portal Stargate do IBM Z

Quando um Programador COBOL Descobre que Git, DevOps e CI/CD Não São Tecnologias Alienígenas... São os Endereços para Viajar Entre Galáxias de Software

"Há milhares de anos, os Antigos construíram uma rede capaz de conectar mundos instantaneamente. No século XXI, engenheiros criaram outra rede capaz de conectar milhares de aplicações corporativas espalhadas pelo planeta. Seu nome não é Stargate... é Pipeline DevOps."



Prólogo — O Chevron Número Sete

O relógio marcava 03:27 da madrugada.

No Centro de Processamento de Dados, apenas o z16 permanecia acordado.

Milhões de transações cruzavam seus canais FICON.

Cartões eram autorizados.

PIX eram liquidados.

Voos eram confirmados.

Hospitais consultavam prontuários.

Bolsa de valores processava ordens.

E, em algum lugar daquele universo invisível, um jovem programador COBOL fazia sua primeira alteração em um COPYBOOK.

Ele acreditava que bastava alterar o código.

Mas o veterano apenas sorriu.

— Você ainda acha que um programa vive sozinho...

Naquele instante, uma enorme estrutura metálica começou a girar.

Não era um Stargate.

Era uma Pipeline.

Os chevrons começaram a travar.

Git...

DBB...

GitLab...

Jenkins...

ZUnit...

Deployment...

Produção.

O portal foi ativado.

E a verdadeira aventura começou.



Episódio 1 — O IBM Z é um Planeta

Em Stargate SG-1, cada planeta possui sua própria civilização.

No mundo IBM Z acontece exatamente o mesmo.

Cada ambiente é praticamente um planeta independente.

Desenvolvimento

↓

Integração

↓

Homologação

↓

Pré-Produção

↓

Produção

Cada um possui:

  • regras

  • segurança

  • bases de dados

  • usuários

  • aplicações

  • auditoria

  • monitoramento

Mover software entre esses mundos nunca foi simples.

Durante décadas isso era feito manualmente.

Hoje quem controla os portais é o DevOps.



Episódio 2 — O DHD Chama-se Git

Em Stargate existe um equipamento chamado DHD (Dial Home Device).

Ele controla o portal.

Sem ele, ninguém viaja.

No desenvolvimento moderno existe um equivalente.

Seu nome é Git.

Muitos iniciantes pensam que Git serve apenas para "guardar arquivos".

Isso seria como dizer que o DHD serve apenas para acender luzes.

Git controla praticamente toda a história da aplicação.

Ele registra:

  • quem alterou

  • quando alterou

  • por que alterou

  • quem aprovou

  • qual versão entrou em produção

  • qual versão voltou (rollback)

Cada commit representa um novo endereço gravado na memória do portal.


Curiosidade Bellacosa ☕

Em projetos antigos, a "verdade absoluta" era um PDS ou um Endevor.

Hoje, em arquiteturas modernas, a verdade oficial normalmente reside no repositório Git. Os datasets do z/OS continuam essenciais para compilação e execução, mas o histórico e a colaboração passam a ser organizados pelo controle de versão.


Episódio 3 — A Linguagem dos Antigos

Existe um problema que todo iniciante descobre cedo ou tarde.

Mainframe fala EBCDIC.

O restante do planeta fala ASCII ou UTF-8.

Imagine Daniel Jackson tentando traduzir uma inscrição dos Antigos.

Se errar um símbolo...

Toda a tradução muda.

O mesmo acontece durante uma migração para Git.

Sem conversão correta podemos encontrar situações como:

Antes

AÇÃO

Depois

AÇÃO

Parece pequeno.

Na prática pode causar:

  • conflitos de merge

  • comentários ilegíveis

  • documentação perdida

  • comparações falsas

  • arquivos inutilizados

Por isso existe toda uma estratégia de conversão de code pages.

É um dos assuntos mais importantes do curso.


Episódio 4 — O SGC Chama-se GitLab

No universo Stargate existe o Stargate Command.

É dali que todas as missões são coordenadas.

No DevOps existe um equivalente.

GitLab.

Ele não é apenas um servidor Git.

Ele funciona como uma base operacional.

Ali encontramos:

  • Issues

  • Merge Requests

  • Pipelines

  • Releases

  • Segurança

  • Artefatos

  • Auditoria

Quando um desenvolvedor envia um commit...

É como uma equipe SG retornando de uma missão.

Tudo será analisado.


Episódio 5 — O Iris é a Pipeline

No Stargate existe um Iris.

Ele impede que qualquer coisa atravesse o portal sem autorização.

No DevOps existe um Iris muito parecido.

A Pipeline.

Ela verifica automaticamente:

✔ O código compila?

✔ Os testes passaram?

✔ Existe vulnerabilidade?

✔ O padrão foi respeitado?

✔ Há aprovação?

Se alguma resposta for negativa...

O portal permanece fechado.

Nenhum software chega à produção.


Episódio 6 — Os Asgard Chamam-se DBB

Os Asgard eram extremamente inteligentes.

Criavam tecnologia capaz de resolver problemas gigantescos.

O DBB (Dependency Based Build) faz algo semelhante.

Imagine um banco com:

  • 18.000 programas COBOL

  • 6.000 COPYBOOKS

  • centenas de mapas BMS

  • milhares de JCLs

Você altera apenas um COPYBOOK.

A pergunta é inevitável.

Quem precisa ser recompilado?

Todos?

Claro que não.

O DBB investiga as dependências.

Ele descobre:

Programa A

↓

COPY X

↓

Programa B

↓

Programa C

↓

Programa D

Somente quem realmente depende daquela alteração será recompilado.

Isso economiza:

  • CPU

  • MIPS

  • tempo

  • dinheiro


Easter Egg ☕

Assim como os Asgard dominavam conhecimento acumulado durante milênios, o DBB concentra décadas de experiência em engenharia de build para IBM Z. O verdadeiro "superpoder" não é compilar mais rápido, mas evitar compilar o que não mudou.


Episódio 7 — Thor Apresenta o zAppBuild

O DBB precisa de alguém dizendo como construir a aplicação.

Esse papel pertence ao zAppBuild.

Ele funciona como um roteiro.

Compile

↓

Link

↓

Bind Db2

↓

Package

↓

Deploy

Sem improviso.

Sem dezenas de JCL diferentes.

Tudo padronizado.


Episódio 8 — O Antigo Conhecimento Perdido

Imagine encontrar um programa COBOL criado em 1987.

Ninguém sabe:

  • quem chama

  • quem utiliza

  • quais tabelas acessa

  • quais COPYBOOKS dependem dele

É exatamente aí que entra o ADDI.

Application Discovery and Delivery Intelligence.

Ele funciona como Daniel Jackson.

Escava.

Relaciona.

Traduz.

Reconstrói.

Mostra mapas gigantescos das dependências.

Você finalmente entende uma aplicação criada há quarenta anos.


Episódio 9 — A Equipe SG-1 Chama-se Jenkins

Em Stargate cada missão possui uma equipe.

No DevOps quem coordena diversas missões pode ser o Jenkins.

Ele recebe a ordem.

Executa.

Compila.

Chama scripts.

Executa testes.

Publica resultados.

Tudo automaticamente.

Em muitos ambientes ele trabalha lado a lado com GitLab, Azure DevOps ou outras plataformas de automação.



Episódio 10 — Outros Mundos: Azure e Wazi

O IBM Z já não vive isolado.

Hoje conversa naturalmente com:

  • Azure

  • OpenShift

  • Kubernetes

  • GitHub

  • GitLab

  • APIs REST

  • microsserviços

O Wazi as a Service demonstra exatamente isso.

Você pode desenvolver aplicações IBM Z utilizando ferramentas modernas hospedadas em nuvem.

É como atravessar o Stargate para outro planeta...

Sem abandonar seu idioma.


Episódio 11 — O Campo de Treinamento Tok'ra

Uma civilização não evolui sem treinamento.

Durante muito tempo acreditava-se que COBOL não fazia testes unitários.

Isso mudou.

Com o ZUnit podemos automatizar testes de programas COBOL.

Imagine uma alteração aparentemente simples.

Antes:

Alterar

↓

Compilar

↓

Mandar para homologação

Hoje:

Commit

↓

Build

↓

ZUnit

↓

Resultado

↓

Deploy

Se algum teste falhar...

A missão é cancelada.


Dica do Coronel O'Neill

"Confiar apenas porque compilou é como atravessar um Stargate sem verificar o planeta de destino."

Teste sempre.


Episódio 12 — O Conselho dos Antigos

Chega o momento do Deployment.

Aqui muitos iniciantes imaginam que basta copiar datasets.

Não.

Deployment moderno envolve:

  • empacotamento

  • aprovação

  • auditoria

  • versionamento

  • rollback

  • rastreabilidade

Cada release recebe identidade própria.

Nada entra em produção sem deixar um rastro.


Episódio 13 — As Coordenadas Galácticas (Branches)

Em Stargate cada planeta possui um endereço formado por chevrons.

No Git acontece algo parecido.

Cada branch representa um caminho de desenvolvimento.

main

├── develop

├── release

├── feature

└── hotfix

Cada uma possui finalidade específica.

Misturar tudo seria como discar símbolos aleatórios no Stargate.

Você provavelmente chegaria ao planeta errado.


Episódio 14 — A Cidade Perdida dos Antigos

Muitas empresas possuem aplicações criadas nos anos 1970.

Décadas de evolução.

Milhões de linhas COBOL.

Esses sistemas lembram Atlantis.

Imensos.

Poderosos.

Pouco compreendidos.

Ferramentas como o ADDI ajudam a revelar sua arquitetura, permitindo que equipes modernas façam mudanças com muito mais segurança.


Episódio 15 — O Oráculo da Performance

No fim da jornada surge outro personagem importante.

O APA (Application Performance Analyzer).

Compilar não basta.

Executar também não.

É preciso executar bem.

O APA mostra:

  • consumo de CPU

  • hotspots

  • chamadas excessivas

  • gargalos

  • desperdícios

É como um sensor Asgard analisando cada detalhe de uma nave antes da decolagem.



A Grande Missão DevOps

Quando unimos todas as tecnologias do curso, obtemos uma cadeia contínua de entrega de software:

Programador COBOL
        │
        ▼
 VS Code / IDz
        │
        ▼
      Git
        │
        ▼
 Merge Request
        │
        ▼
 GitLab / Jenkins
        │
        ▼
 DBB + zAppBuild
        │
        ▼
     Build
        │
        ▼
     ZUnit
        │
        ▼
      ADDI
        │
        ▼
  Empacotamento
        │
        ▼
 Deploy Automatizado
        │
        ▼
   CICS • Batch • Db2 • IMS
        │
        ▼
 APA • Monitoramento

Observe como praticamente tudo ocorre de maneira automática. O desenvolvedor continua sendo indispensável, mas passa a dedicar mais tempo ao desenho da solução e menos às tarefas repetitivas.


Passo a Passo para o Iniciante

Se você está começando agora no mundo IBM Z, esta é uma sequência de estudos que faz muito sentido:

  1. Aprenda bem COBOL, JCL, TSO/ISPF e os fundamentos do z/OS.

  2. Entenda VSAM, Db2, CICS e como uma aplicação corporativa é estruturada.

  3. Estude Git profundamente: commits, branches, merge, rebase e revisão de código.

  4. Aprenda conceitos de CI/CD antes de decorar ferramentas específicas.

  5. Conheça DBB e zAppBuild para compreender como builds modernos funcionam.

  6. Estude ZUnit e incorpore testes automatizados desde cedo.

  7. Explore o ADDI para entender impacto de mudanças em aplicações legadas.

  8. Aprenda uma plataforma de orquestração, como GitLab ou Jenkins.

  9. Entenda estratégias de deployment, rollback e versionamento.

  10. Finalmente, aprofunde-se em performance, observabilidade e engenharia de plataformas.

Essa sequência faz com que cada etapa tenha um propósito claro e evita a sensação de aprender tecnologias desconectadas.


Curiosidades que Pouca Gente Conhece

  • O maior desafio de uma pipeline IBM Z normalmente não é compilar COBOL, mas entender corretamente as dependências entre milhares de componentes.

  • Muitos bancos executam centenas ou milhares de pipelines diariamente sem que clientes percebam que há mudanças em produção.

  • Um único COPYBOOK compartilhado pode impactar centenas de programas diferentes.

  • Ferramentas de descoberta de aplicações, como o ADDI, ajudam equipes que nunca participaram do desenvolvimento original a compreender sistemas com décadas de evolução.

  • O movimento Open Mainframe Project acelerou a integração entre tecnologias abertas e o ecossistema IBM Z, aproximando práticas modernas de engenharia de software do ambiente corporativo tradicional.


Conclusão — O Oitavo Chevron

No último episódio de muitas temporadas de Stargate, descobrimos que o verdadeiro objetivo nunca foi apenas atravessar portais.

Era compreender uma rede inteira de civilizações.

O mesmo acontece com o IBM Z.

O programador iniciante costuma acreditar que aprender COBOL é suficiente.

Depois percebe que existe Db2.

Em seguida descobre CICS.

Depois VSAM.

Mais tarde encontra Git.

Pipeline.

DBB.

GitLab.

Jenkins.

ZUnit.

ADDI.

Deployment.

Performance.

Observabilidade.

Cada tecnologia parece um novo planeta.

Mas, pouco a pouco, surge uma revelação: todas fazem parte de uma única galáxia.

O verdadeiro arquiteto não conhece apenas uma linguagem de programação. Ele entende como cada componente conversa com os demais, como uma alteração percorre toda a cadeia de entrega e como manter sistemas que processam bilhões de transações com segurança e previsibilidade.

No fim, o maior portal nunca foi o Stargate.

Foi a mudança de mentalidade.

Quando você deixa de enxergar um simples programa COBOL e passa a visualizar todo o ecossistema que o cerca, o oitavo chevron finalmente trava... e uma nova galáxia de oportunidades se abre diante de você.

Easter Egg Bellacosa: se um dia você ouvir um veterano dizer "o programa compilou, mas a pipeline não deixou passar", lembre-se do Iris do Stargate. O código pode estar pronto para atravessar o portal, mas somente aplicações que sobreviverem a todas as verificações chegam ao destino final: a produção do IBM Z.

quinta-feira, 11 de junho de 2026

☕💣🚀 PADAWAN, TESTAR COBOL NÃO É DESCONFIAR DO PROGRAMA. É DESCONFIAR DE SI MESMO!

Bellacosa Mainframe e tecnicas e ferramentas de teste automatizado em ibm mainframe

☕💣🚀 PADAWAN, TESTAR COBOL NÃO É DESCONFIAR DO PROGRAMA. É DESCONFIAR DE SI MESMO!

A Arte Esquecida dos Testes no IBM Mainframe

Existe uma crença antiga nos corredores dos CPDs:

"Se compilou sem erro e rodou em produção, então está certo."

Foi exatamente esse tipo de pensamento que produziu alguns dos maiores incidentes da história da computação corporativa.

No mundo Mainframe, um erro não afeta apenas um usuário.

Pode afetar:

  • milhões de contas bancárias

  • faturamento de operadoras

  • pagamento de aposentadorias

  • processamento de cartões

  • sistemas governamentais

Por isso, testar COBOL nunca foi opcional.

Sempre foi sobrevivência.

O curioso é que durante décadas o programador COBOL executava testes praticamente de forma artesanal:

  1. Criava um arquivo de teste

  2. Submetia um JOB

  3. Esperava terminar

  4. Analisava SYSOUT

  5. Corrigia

  6. Repetia

Hoje o cenário mudou radicalmente.

Temos frameworks modernos, automação, DevOps, CI/CD e até testes unitários para COBOL.

Sim.

Você leu corretamente.

Testes unitários para COBOL.


Como Pensar em Testes COBOL

Antes das ferramentas, precisamos entender os níveis de teste.

1. Teste Unitário

Valida apenas uma rotina.

Exemplo:

Programa calcula juros.

Entrada:

VALOR = 1000
TAXA  = 10

Saída esperada:

1100

Nada de arquivos.

Nada de DB2.

Nada de CICS.

Somente lógica.


2. Teste de Integração

Valida interação entre componentes.

Exemplo:

COBOL
 ↓
DB2
 ↓
MQ
 ↓
Outro Sistema

Aqui os problemas aparecem.

A lógica funciona.

A integração não.


3. Teste de Sistema

Avalia o fluxo completo.

Exemplo:

Tela CICS
 ↓
COBOL
 ↓
DB2
 ↓
IMS
 ↓
MQ

Tudo junto.

Como acontece na produção.


4. Teste de Regressão

O mais importante.

Você altera uma linha.

Precisa garantir que não destruiu outras 500 funcionalidades.

É aqui que a automação brilha.


Ferramenta 1 — IBM ZUnit

A joia da coroa da IBM.

ZUnit é o framework oficial de testes unitários para COBOL.

Foi criado para trazer ao Mainframe conceitos comuns em Java e .NET.

Zunit - https://eljefemidnightlunch.blogspot.com/2021/05/padawan-o-zunit-e-o-momento-em-que-o.html 

Vantagens

✔ Teste automatizado

✔ Integrado ao IDz

✔ Repetível

✔ Excelente para DevOps

✔ Integração com pipelines


Desvantagens

✘ Curva de aprendizado

✘ Dependência do ecossistema IBM

✘ Nem sempre simples para programas antigos


Exemplo Prático com ZUnit

Suponha o programa:

IDENTIFICATION DIVISION.
PROGRAM-ID. CALCJURO.

COMPUTE VALOR-FINAL =
        VALOR + (VALOR * TAXA / 100).

Passo 1

Abrir IDz.


Passo 2

Criar projeto ZUnit.

File
  New
    ZUnit Test Case

Passo 3

Selecionar programa COBOL.

CALCJURO

Passo 4

Definir entrada.

VALOR = 1000
TAXA  = 10

Passo 5

Definir saída esperada.

1100

Passo 6

Executar.

Run As
   ZUnit Test

Resultado:

PASS

ou

FAIL

Ferramenta 2 — IBM COBOL Check: Encontrando Defeitos Antes da Execução

Antes de executar qualquer teste, existe uma etapa ainda mais inteligente.

A análise estática.

É aqui que entra o IBM COBOL Check.

IBM Cobol Check - https://eljefemidnightlunch.blogspot.com/2026/06/ibm-cobol-check-ferramenta-que-trouxe.html

O Que É?

O COBOL Check examina o código-fonte procurando defeitos potenciais sem executar uma única instrução.

Ele atua como um inspetor de qualidade automatizado.

Enquanto o ZUnit pergunta:

"O programa funciona?"

O COBOL Check pergunta:

"Existe algo suspeito neste código?"


Problemas Detectados

Variáveis Não Inicializadas

01 WS-TOTAL PIC 9(05).

ADD 100 TO WS-TOTAL.

O campo recebeu valor antes?

Talvez não.


Índices Fora da Faixa

MOVE 150 TO WS-INDICE.

MOVE 'ABC' TO WS-DADO(WS-INDICE).

Tabela com apenas 100 ocorrências.

Possível S0C4.


Código Morto

STOP RUN.

DISPLAY 'NUNCA EXECUTA'

Trecho inalcançável.


Condições Impossíveis

IF VALOR > 100
AND VALOR < 50

Nunca será verdadeiro.


Possíveis S0C7

MOVE 'ABCDE' TO CAMPO-NUMERICO.

ADD 1 TO CAMPO-NUMERICO.

Compila.

Mas pode explodir em produção.


Vantagens do COBOL Check

✔ Não precisa executar o programa

✔ Automatizável

✔ Excelente para DevOps

✔ Descobre defeitos cedo

✔ Padronização corporativa


Desvantagens

✘ Não substitui testes

✘ Pode gerar falsos positivos

✘ Requer parametrização adequada


Ferramenta 3 — IBM Debug Tool

Muita gente acha que Debug Tool serve apenas para depuração.

Errado.

Ele também é excelente para validação de comportamento.

Vantagens

✔ Sem alterar código

✔ Breakpoints

✔ Análise em tempo real

✔ Visualização de variáveis


Desvantagens

✘ Não substitui testes automatizados

✘ Processo mais manual


Exemplo

Interceptar:

COMPUTE TOTAL = A + B

Durante execução:

AT LINE 125
DISPLAY TOTAL

Verificando se:

10 + 15 = 25

Ferramenta 4 — File-AID

Uma das ferramentas mais usadas para testes.

Principalmente em ambientes bancários.

O que faz?

Criação de massa de testes.

Manipulação de arquivos.

Comparação de resultados.


Exemplo

Criar arquivo VSAM contendo:

CLIENTE 001
CLIENTE 002
CLIENTE 003

Executar programa.

Comparar resultado.


Vantagens

✔ Rápido

✔ Simples

✔ Excelente para testes batch


Desvantagens

✘ Não executa lógica unitária

✘ Foco em dados


Ferramenta 5 — Xpediter

O lendário depurador da Compuware/BMC.

Praticamente um microscópio para COBOL.

Permite

  • Breakpoints

  • Alteração dinâmica

  • Rastreamento

  • Simulação


Vantagens

✔ Muito poderoso

✔ Excelente para programas complexos

✔ Integração com CICS


Desvantagens

✘ Licenciamento

✘ Excesso de recursos para iniciantes


Ferramenta 6 — Abend-AID

Não é exatamente uma ferramenta de testes.

Mas salva vidas.

Quando ocorre:

S0C7

ou

S0C4

Ela mostra:

  • linha exata

  • variável envolvida

  • conteúdo dos campos


Vantagens

✔ Diagnóstico rápido

✔ Redução de MTTR

✔ Histórico de falhas


Desvantagens

✘ Atua após o erro

✘ Não evita defeitos


Técnica Clássica: Golden File

Uma das técnicas mais usadas em Mainframe.

Executa-se um programa conhecido.

Resultado esperado:

ARQ-OK

Depois da alteração:

ARQ-NOVO

Comparação:

SUPERC

ou

File-AID Compare

Se forem idênticos:

TESTE APROVADO

Técnica Moderna: Mocking

Muito usada com ZUnit.

Imagine:

SELECT CLIENTE
       ASSIGN TO VSAMCLI.

Em vez de acessar VSAM real:

VSAM MOCK

Resultado:

  • teste rápido

  • sem riscos

  • repetível


Técnica de Cobertura

Pergunta simples:

Quanto do programa foi realmente executado?

Muitos acreditam:

Teste passou

Logo:

Programa está correto

Não necessariamente.

Você pode ter testado apenas 20% dos caminhos.

Ferramentas modernas ajudam a medir cobertura.


Curiosidades Históricas

COBOL já tinha testes antes da moda

Décadas antes de JUnit existir:

Programadores Mainframe já criavam:

ARQTEST1
ARQTEST2
ARQTEST3

Executando cenários controlados.

Na prática, eram testes unitários artesanais.


O custo do erro

Um defeito descoberto:

  • Durante codificação → custo 1x

  • Durante homologação → custo 10x

  • Em produção → custo 100x

Essa regra continua válida.


Grandes bancos executam milhões de testes

Em ambientes modernos de DevOps Mainframe, pipelines podem disparar milhares de testes automáticos a cada alteração de código COBOL.

O objetivo é simples:

Quebrar no laboratório para não quebrar na produção.


Dicas do Bellacosa

☕ Dica 1

Nunca teste apenas o cenário feliz.

Teste:

  • zeros

  • negativos

  • máximos

  • mínimos

  • espaços

  • nulos


☕ Dica 2

Todo S0C7 que chega em produção é um teste que faltou.


☕ Dica 3

Crie bibliotecas permanentes de massa de testes.

Economiza centenas de horas.


☕ Dica 4

Automatize tudo o que puder.

O programador esquece.

O script não.


☕ Dica 5

Sempre mantenha testes de regressão após correções.

O defeito corrigido hoje costuma reaparecer daqui seis meses.


Exemplo de Pipeline DevOps Mainframe

Git
 ↓
Commit
 ↓
Build COBOL
 ↓
ZUnit
 ↓
Análise de Qualidade
 ↓
Deploy Homologação
 ↓
Testes Integração
 ↓
Produção

Cada etapa reduz riscos.

Cada teste reduz surpresas.


Resumo Executivo

Testar COBOL em ambiente IBM Mainframe deixou de ser uma atividade manual e passou a ser parte fundamental da engenharia moderna de software. Ferramentas como IBM ZUnit, Debug Tool, File-AID, Xpediter e Abend-AID permitem validar lógica, criar massas de teste, depurar falhas e automatizar regressões. O segredo não está apenas na ferramenta, mas na disciplina de criar cenários abrangentes, automatizar execuções e manter uma suíte de testes confiável. No fim das contas, o verdadeiro profissional Mainframe não é aquele que nunca gera defeitos. É aquele que constrói mecanismos para encontrá-los antes que o cliente encontre primeiro.

☕💣🚀 PADAWAN, O TESTE NÃO EXISTE PARA PROVAR QUE SEU COBOL ESTÁ CERTO. ELE EXISTE PARA PROVAR QUANTAS MANEIRAS ELE AINDA TEM DE DAR ERRADO ANTES DA PRODUÇÃO DESCOBRIR!


domingo, 2 de maio de 2021

☕💣🚀 PADAWAN, O ZUNIT É O MOMENTO EM QUE O MAINFRAME APRENDEU A DESCONFIAR DOS PROGRAMADORES!

 

Bellacosa Mainframe e o zunit testes unitarios em ibm mainframe 

☕💣🚀 PADAWAN, O ZUNIT É O MOMENTO EM QUE O MAINFRAME APRENDEU A DESCONFIAR DOS PROGRAMADORES!

Durante décadas, o desenvolvedor COBOL vivia numa realidade curiosa.

Ele alterava um programa de 30.000 linhas.

Compilava.

Executava.

Rezava.

Se nada explodisse em produção, considerava um sucesso.

Foi assim em milhares de empresas durante mais de 50 anos.

Então surgiu uma pergunta perigosa:

"E se o COBOL pudesse ser testado automaticamente antes de chegar à produção?"

Foi dessa necessidade que nasceu o IBM ZUnit.

Uma das tecnologias mais subestimadas do ecossistema z/OS moderno.


O QUE É O ZUNIT?

O IBM ZUnit é um framework de testes unitários para aplicações desenvolvidas no ambiente IBM Z.

Seu objetivo é simples:

  • testar programas COBOL

  • testar programas PL/I

  • validar regras de negócio

  • automatizar regressões

  • integrar testes ao DevOps

Antes do ZUnit:

Alteração
↓
Compilação
↓
Execução Manual
↓
Análise de Resultado
↓
Torcer para funcionar

Com ZUnit:

Alteração
↓
Compilação
↓
Execução Automática
↓
Validação Automática
↓
Relatório
↓
Deploy

É a filosofia do:

"Confiar é bom. Testar é melhor."


HISTÓRIA

Até meados dos anos 2000, o conceito de testes automatizados era dominado pelo mundo Java.

Existiam:

  • JUnit

  • NUnit

  • xUnit

Enquanto isso, no mainframe:

TESTE = EXECUTAR O JOB

A IBM percebeu que isso não era sustentável.

O crescimento de:

  • DevOps

  • Agile

  • CI/CD

exigia automação.

Então nasceu o projeto que mais tarde se tornaria:

IBM ZUnit Test Framework

integrado ao ambiente de desenvolvimento IBM.


DATA DE LANÇAMENTO

O ZUnit apareceu inicialmente integrado ao:

IBM Rational Developer for System z (RDz)

por volta de:

2014–2015

Posteriormente evoluiu para:

IBM Developer for z/OS (IDz)

onde continua sendo desenvolvido.

Atualmente faz parte do ecossistema:

  • IBM Developer for z/OS

  • IBM Dependency Based Build

  • IBM Wazi

  • IBM DevOps for Z


A GRANDE IDEIA

Imagine um programa COBOL:

CALCULA-DESCONTO.

Entrada:

VALOR = 1000

Saída esperada:

DESCONTO = 100

O ZUnit permite registrar:

Entrada
↓
Execução
↓
Saída Esperada

e repetir esse teste automaticamente milhares de vezes.


FILOSOFIA DO TESTE UNITÁRIO

Padawan...

O teste unitário não verifica o sistema inteiro.

Ele verifica uma unidade.

Normalmente:

Programa COBOL
ou
Subprograma COBOL

Exemplo:

CALCJUROS

Recebe:

VALOR
TAXA
PRAZO

Retorna:

JUROS

O ZUnit verifica apenas essa lógica.


COMO FUNCIONA

O framework captura:

INPUT

Parâmetros
Arquivos
Áreas de memória

PROCESSAMENTO

Executa o programa.

OUTPUT

Compara com resultado esperado.


ARQUITETURA

IDz
 │
 │
 ▼
 Test Case
 │
 ▼
 Test Runner
 │
 ▼
 Programa COBOL
 │
 ▼
 Resultado
 │
 ▼
 Relatório

COMPONENTES PRINCIPAIS

Test Case

Define:

Dados de Entrada

Test Scenario

Conjunto de testes.

Exemplo:

Cliente VIP
Cliente Normal
Cliente Inadimplente

Test Runner

Executa automaticamente.


Assertions

Comparam resultados.

Exemplo:

Esperado = 100
Obtido = 100

PASSOU.


INSTALAÇÃO

Normalmente o ZUnit não é instalado isoladamente.

Ele vem integrado ao:

IBM Developer for z/OS

IBM Developer for z/OS

Componentes comuns:

z/OS
IDz
JES
ISPF
COBOL Compiler
ZUnit Runtime

PRÉ-REQUISITOS

Geralmente:

  • Enterprise COBOL

  • z/OS

  • IDz

  • USS configurado

  • JES ativo

Em ambientes corporativos:

LPAR DEV
LPAR QA

normalmente já possuem tudo configurado.


EXEMPLO PRÁTICO

Programa

IDENTIFICATION DIVISION.
PROGRAM-ID. SOMA.

WORKING-STORAGE SECTION.

01 NUM1 PIC 9(4).
01 NUM2 PIC 9(4).
01 RESULTADO PIC 9(5).

PROCEDURE DIVISION.

ADD NUM1 TO NUM2
GIVING RESULTADO.

GOBACK.

CRIANDO O TESTE

No IDz:

File
 ↓
 New
 ↓
 ZUnit Test Case

Selecionar:

Programa SOMA

Definir:

NUM1 = 10
NUM2 = 20

Resultado esperado:

30

EXECUÇÃO

Runner executa:

SOMA

Obtém:

30

Compara:

Esperado = 30
Obtido = 30

Resultado:

PASS

EXEMPLO DE FALHA

Esperado:

30

Obtido:

31

Relatório:

FAIL

com indicação do campo divergente.


TESTANDO CENTENAS DE CENÁRIOS

Padawan...

Aqui está o verdadeiro poder.

Você cria:

0 + 0
10 + 20
9999 + 1
5000 + 5000

Tudo executado automaticamente.

Em segundos.


TESTANDO PROGRAMAS CICS

O ZUnit consegue testar componentes que normalmente seriam executados sob CICS.

Exemplo:

EXEC CICS LINK

Através de stubs e ambientes controlados.

Isso reduz enormemente o tempo de validação.


TESTANDO DB2

Também é possível criar cenários envolvendo:

SELECT
INSERT
UPDATE
DELETE

utilizando ambientes isolados.


MOCKS E STUBS

Conceito muito usado no mundo distribuído.

Exemplo:

Programa chama:

CONSULTA-CLIENTE

Mas o programa real não existe no ambiente.

Criamos um:

Stub

que responde:

CLIENTE VÁLIDO

Assim o teste continua funcionando.


INTEGRAÇÃO COM DEVOPS

O ZUnit tornou-se peça importante do pipeline moderno.

Fluxo:

Git
 ↓
Build
 ↓
Compilação COBOL
 ↓
ZUnit
 ↓
Deploy

Se um teste falhar:

Deploy Bloqueado

BENEFÍCIOS REAIS

Menos regressões

Alterou um cálculo?

Execute 500 testes.


Mais confiança

Mudanças menores tornam-se seguras.


Documentação viva

Os testes mostram como o programa deveria funcionar.


Onboarding

Novo desenvolvedor entende rapidamente a lógica.


CURIOSIDADES

Curiosidade 1

Muitos sistemas COBOL possuem mais de:

20 milhões de linhas

Sem testes automatizados.


Curiosidade 2

Alguns bancos executam milhares de testes ZUnit por dia.

Antes mesmo do primeiro usuário acessar o sistema.


Curiosidade 3

Em muitos projetos, o maior esforço não é criar o teste.

É descobrir qual deveria ser o resultado correto.


Curiosidade 4

A adoção do ZUnit foi impulsionada pelo movimento:

Shift Left Testing

Testar mais cedo.

Corrigir mais barato.


DICAS DE MESTRE JEDI MAINFRAME

Não teste programas gigantes primeiro

Comece pelos módulos menores.


Teste regras de negócio

Prioridade:

Cálculos
Tarifas
Juros
Impostos
Limites

Automatize regressões

Todo defeito corrigido deve virar um teste.


Integre com Git

Cada commit deve executar testes.


Pense como um auditor

Pergunta:

"Como provo que este cálculo continua correto após a alteração?"

Se o ZUnit responde essa pergunta, você está usando a ferramenta corretamente.


O VERDADEIRO SIGNIFICADO DO ZUNIT

Padawan...

O ZUnit não foi criado para testar COBOL.

Ele foi criado para proteger conhecimento corporativo acumulado durante décadas.

Quando um banco possui um programa escrito em 1987, alterado por 200 pessoas diferentes ao longo de 40 anos, o risco não está na compilação.

O risco está em quebrar silenciosamente uma regra de negócio que movimenta milhões de reais por dia.

O ZUnit é a resposta moderna para um problema antigo:

"Como mudar um sistema legado sem destruir aquilo que o tornou valioso?"

E é justamente por isso que muitos arquitetos consideram o ZUnit uma das tecnologias mais importantes da modernização do IBM Z: não porque ele substitui o COBOL, mas porque permite evoluí-lo com segurança. ☕💣🚀


sexta-feira, 7 de junho de 2019

🎩 CARLITOS EM TEMPOS MODERNOS — QUANDO O COBOL ENTROU NA ESTEIRA DO DEVOPS

 

Bellacosa Mainframe introducao ao DevOps

☕ Um Café no Bellacosa Mainframe

🎩 CARLITOS EM TEMPOS MODERNOS — QUANDO O COBOL ENTROU NA ESTEIRA DO DEVOPS

COBOL, Git, Jenkins, DBB, zAppBuild, testes, CI/CD, DevSecOps, observabilidade, rollback, IA e o dia em que Carlitos descobriu que apertar parafusos mais rápido não significa necessariamente produzir software melhor.



🎬 PRÓLOGO — CARLITOS CONSEGUIU SEU PRIMEIRO EMPREGO NO MAINFRAME

Imagine nosso jovem programador COBOL entrando pela primeira vez em um grande Data Center.

Ele olha para aquelas máquinas, terminais, aplicações, filas, bancos de dados, milhares de jobs e milhões de transações e pensa:

— Finalmente! Aprendi COBOL. Estou preparado!

Do outro lado da sala, sentado diante de um terminal 3270, está Carlitos.

Chapéu-coco.

Bigodinho.

Bengala encostada na mesa.

Ele olha silenciosamente para o jovem programador e aponta para uma enorme esteira imaginária.

Sobre ela passam:

REQUISITO
   ↓
COBOL
   ↓
COPYBOOK
   ↓
JCL
   ↓
BUILD
   ↓
TESTE
   ↓
DEPLOY
   ↓
PRODUÇÃO

O jovem pergunta:

— Isso tudo é programação?

Carlitos balança negativamente a cabeça.

Aponta novamente para a esteira.

Agora aparecem mais peças:

Git
Pull Request
Code Review
DBB
zAppBuild
ZUnit
Quality Gate
Security Scan
SIT
UAT
Deploy
Rollback
Logs
Metrics
Traces

O jovem arregala os olhos.

Bem-vindo aos Tempos Modernos do Mainframe.

Porque conhecer COBOL continua sendo extremamente importante.

Mas COBOL é apenas uma das engrenagens.

O profissional mainframe moderno precisa começar a compreender a fábrica inteira.



⚙️ CAPÍTULO 1 — A FÁBRICA DE SOFTWARE

Em Tempos Modernos, Carlitos trabalha em uma linha de produção.

Sua tarefa parece simples:

apertar parafusos.

Dois parafusos chegam.

Carlitos aperta.

Outros dois.

Aperta novamente.

Mais dois.

Mais dois.

Mais dois.

Até que o homem começa a funcionar como se fosse parte da máquina.

Essa é uma excelente metáfora para um problema que também encontramos no desenvolvimento tradicional.

Durante muito tempo ensinamos programação como uma sequência relativamente isolada:

Receba especificação
        ↓
Altere programa
        ↓
Compile
        ↓
Teste
        ↓
Entregue

Parece perfeitamente razoável.

Mas surge uma pergunta.

Entregue para quem?

Quem controla a versão?

Quem sabe exatamente o que mudou?

Quem verifica as dependências?

Quem recompila?

Quem executa os testes?

Quem gera as evidências?

Quem promove para outro ambiente?

Quem autoriza produção?

Quem observa o sistema depois do deploy?

Quem volta a versão caso algo dê errado?

É nesse momento que entramos no universo do DevOps Mainframe.

DevOps não significa simplesmente instalar Jenkins.

Também não significa substituir ISPF por uma IDE moderna.

Muito menos significa pegar tudo que funciona no mainframe e colocar dentro de containers.

DevOps é fundamentalmente uma abordagem para melhorar o fluxo de entrega de software, aproximando desenvolvimento, testes, segurança e operações através de processos repetíveis, colaboração e automação.

Nossa fábrica começa a ficar interessante.



🏭 CAPÍTULO 2 — O COBOL NÃO SAI SOZINHO DA FÁBRICA

Considere um programa chamado:

PGMPAG01

Ele processa pagamentos.

O programador recebe:

REQ-38271 — Adicionar código identificador da origem da transação.

Parece fácil.

Ele abre o programa:

01 WS-TRANSACAO.
   05 WS-VALOR          PIC 9(09)V99.
   05 WS-CONTA          PIC X(12).
   05 WS-ORIGEM         PIC X(03).

Pronto?

Não.

Talvez WS-ORIGEM tenha vindo de um copybook.

Talvez o programa grave Db2.

Talvez outro programa utilize a mesma estrutura.

Talvez uma transação CICS chame esse programa.

Talvez um batch noturno leia os registros posteriormente.

Talvez exista uma API expondo aquela informação.

Talvez MQ transporte a mensagem para outro sistema.

A pequena alteração tornou-se:

                 COPYBOOK
                    │
          ┌─────────┼─────────┐
          ▼         ▼         ▼
       COBOL-A    COBOL-B    COBOL-C
          │         │
          ▼         ▼
         CICS      BATCH
          │         │
          └────┬────┘
               ▼
              Db2
               │
               ▼
              MQ
               │
               ▼
             API

Aqui aparece uma das primeiras lições importantes do DevOps:

O tamanho da alteração não determina necessariamente o tamanho do impacto.

Uma linha pode afetar dezenas de componentes.



🌳 CAPÍTULO 3 — CARLITOS CONHECE O GIT

Carlitos encontra outra máquina na fábrica.

Nela existe uma placa:

GIT

O jovem programador pergunta:

— É onde guardamos os fontes?

Sim.

Mas essa resposta é incompleta.

Ensinar Git apenas como repositório é como ensinar CICS dizendo:

“É aquele negócio que executa COBOL.”

Tecnicamente há alguma verdade.

Pedagogicamente é quase inútil.

Git introduz um modelo importante de gerenciamento de mudanças.

Imagine:

main
 │
 ├──── feature/REQ-38271
 │
 │       ├── alteração COBOL
 │       ├── alteração COPYBOOK
 │       └── alteração teste
 │
 └──── fix/INC-9281

O desenvolvedor trabalha em sua alteração.

Depois:

commit
   ↓
push
   ↓
Pull Request
   ↓
Code Review
   ↓
Merge

Isso cria algo precioso:

rastreabilidade.

Podemos relacionar:

REQUISITO
    ↓
COMMIT
    ↓
BUILD
    ↓
TESTE
    ↓
ARTEFATO
    ↓
DEPLOY

Agora conseguimos responder:

Quem alterou?

Quando?

Por quê?

Qual requisito originou a alteração?

Qual versão foi compilada?

Quais testes passaram?

Qual artefato foi enviado para produção?

Esse tipo de informação é extremamente importante em grandes organizações, especialmente em ambientes sujeitos a controles internos, auditorias e regulamentação.



🧬 CAPÍTULO 4 — UMA COPYBOOK PARA A ESTEIRA

Carlitos está trabalhando tranquilamente quando alguém altera:

COPYB

Na fábrica existem:

PGMA → COPYA
     → COPYB

PGMB → COPYB
     → COPYC

PGMC → COPYD

Pergunta:

Quem precisa ser recompilado?

PGMA utiliza COPYB.

PGMB utiliza COPYB.

PGMC não utiliza COPYB.

Logo:

             COPYB
            /     \
           ▼       ▼
         PGMA     PGMB

Esse exemplo aparentemente simples apresenta ao iniciante um conceito extremamente importante:

dependências.

Em sistemas grandes, recompilar absolutamente tudo após qualquer mudança pode ser caro, demorado e desnecessário.

É aí que conceitos como dependency-based build tornam-se interessantes.

Ferramentas e frameworks de build podem ajudar a determinar quais componentes foram impactados pela mudança e quais precisam ser reconstruídos.

Aqui entram tecnologias como DBB e zAppBuild em determinados ecossistemas de desenvolvimento IBM Z.

Não devemos decorar apenas seus nomes.

Precisamos entender o problema que tentam resolver.


🔨 CAPÍTULO 5 — JENKINS NÃO É O OPERÁRIO

Outra máquina aparece.

Na placa está escrito:

JENKINS

O jovem pergunta:

— Jenkins compila COBOL?

Carlitos olha para ele.

Silêncio.

Jenkins é melhor compreendido como um orquestrador.

Imagine um mestre de cerimônias dizendo:

Pegue código
     ↓
Execute build
     ↓
Execute testes
     ↓
Faça análise
     ↓
Verifique qualidade
     ↓
Gere artefato
     ↓
Promova

Jenkins não precisa executar pessoalmente cada tarefa.

Ele coordena ferramentas, agentes, scripts e etapas.

Essa distinção é importantíssima.

O pipeline pode dizer:

STAGE 1 — CHECKOUT
STAGE 2 — BUILD
STAGE 3 — UNIT TEST
STAGE 4 — STATIC ANALYSIS
STAGE 5 — SECURITY
STAGE 6 — PACKAGE
STAGE 7 — DEPLOY DEV
STAGE 8 — INTEGRATION TEST
STAGE 9 — APPROVAL
STAGE 10 — PROD

De repente nossa fábrica ganhou uma linha de montagem automatizada.

Mas existe um perigo.

Automatizar um processo ruim apenas produz resultados ruins mais rapidamente.


🚧 CAPÍTULO 6 — CARLITOS PUXA A ALAVANCA VERMELHA

Imagine:

BUILD
  │
  ▼
TEST
  │
  ▼
SECURITY
  │
  ▼
DEPLOY

Agora imagine que os testes falharam.

O pipeline continua?

Não deveria.

Precisamos de portões:

SOURCE
  │
  ▼
COMPILE ───── ERROR ─────► STOP
  │
  ▼
TEST ──────── ERROR ─────► STOP
  │
  ▼
SECURITY ──── ERROR ─────► STOP
  │
  ▼
QUALITY ───── ERROR ─────► STOP
  │
  ▼
DEPLOY

São os famosos quality gates.

Aqui está uma ideia que todo iniciante deveria guardar:

Pipeline não existe simplesmente para colocar software em produção mais rapidamente. Pipeline também existe para impedir que software inadequado chegue rapidamente à produção.

A automação é simultaneamente acelerador e freio.


🧪 CAPÍTULO 7 — TESTAR NÃO É EXECUTAR E TORCER

Carlitos aperta um botão.

Luz verde.

O jovem comemora:

— Funcionou!

Carlitos entrega outro conjunto de dados.

Luz vermelha.

Esse é outro salto de maturidade.

Testar software não significa executar o cenário que sabemos que funciona.

Precisamos pensar em:

UNIT TEST
     │
INTEGRATION TEST
     │
SYSTEM TEST
     │
REGRESSION TEST
     │
ACCEPTANCE TEST

No mainframe isso pode envolver diferentes componentes.

Por exemplo:

COBOL
  │
  ├── lógica isolada
  │
  ├── Db2
  │
  ├── VSAM
  │
  ├── CICS
  │
  └── MQ

Testar um cálculo isolado é diferente de testar uma transação completa envolvendo banco, mensageria e outros sistemas.

Ferramentas de unit testing como ZUnit podem participar dessa estratégia.

Mas novamente:

ferramenta não é estratégia.

A ferramenta executa o teste.

O engenheiro precisa saber o que deve ser testado.


🛡️ CAPÍTULO 8 — DEVOPS ENCONTRA SEGURANÇA

Em algum momento alguém pergunta:

— E segurança?

Carlitos aponta para uma porta que deveria estar desde o começo da fábrica.

Esse é o espírito do DevSecOps.

Em vez de pensar:

DESENVOLVE
    ↓
TESTA
    ↓
ENTREGA
    ↓
SEGURANÇA OLHA

tentamos aproximar segurança de todo o ciclo:

PLAN
 ↓
CODE ← SECURITY
 ↓
BUILD ← SECURITY
 ↓
TEST ← SECURITY
 ↓
DEPLOY ← SECURITY
 ↓
OPERATE ← SECURITY

Podemos verificar código, dependências, configurações, credenciais, permissões e vulnerabilidades durante diferentes etapas.

No mainframe isso conversa muito bem com conceitos tradicionais de controle de acesso, segregação de funções, auditoria e RACF.

DevSecOps não deveria destruir os controles do mainframe.

Deveria ajudar a torná-los mais consistentes, verificáveis e automatizados.


🚚 CAPÍTULO 9 — DEV, SIT, UAT, PRE-PROD E PROD

Agora nossa peça precisa atravessar a fábrica.

DEV
 ↓
SIT
 ↓
UAT
 ↓
PRE-PROD
 ↓
PROD

Cada ambiente possui uma finalidade.

DEV permite desenvolvimento e testes iniciais.

SIT concentra testes de integração.

UAT permite validação de aceitação conforme o processo da organização.

PRE-PROD tenta aproximar determinadas características da produção.

Finalmente:

PROD.

Mas promover uma aplicação não significa simplesmente copiar um load module.

Pode haver:

LOADLIB
DBRM
PACKAGE
COPYBOOK
JCL
PROC
DB2 CHANGE
CICS RESOURCE
CONFIG
API

É por isso que deployment de aplicações corporativas precisa ser tratado seriamente.


💥 CAPÍTULO 10 — 03:17

Às 03:17, toca o telefone.

Eis nosso pequeno easter egg.

Produção apresentou problema.

Carlitos acorda.

O deploy realizado anteriormente parece estar relacionado.

Alguém grita:

— ROLLBACK!

Parece simples.

Volte a versão.

Mas espere.

A aplicação atualizou 480 mil registros Db2.

Publicou mensagens MQ.

Outro sistema consumiu algumas delas.

Um batch posterior processou parte dos dados.

Agora entendemos algo fundamental:

Rollback não é necessariamente Ctrl+Z.

Existem mudanças reversíveis facilmente.

Outras exigem planejamento.

Podemos ter:

APPLICATION ROLLBACK
DATABASE ROLLBACK
CONFIGURATION ROLLBACK
MESSAGE COMPENSATION
BUSINESS COMPENSATION

Esse conhecimento aproxima o aluno da realidade.


👀 CAPÍTULO 11 — PRODUÇÃO NÃO É O FINAL

A aplicação voltou.

Tudo verde.

Fim?

Não.

Começa outra etapa:

observabilidade.

Precisamos saber o que está acontecendo.

Três conceitos aparecem frequentemente:

METRICS
LOGS
TRACES

Podemos acrescentar eventos e alertas.

O mainframe já possui uma enorme tradição de telemetria e dados operacionais.

O aluno pode encontrar conceitos relacionados a:

SMF
RMF
JES
SDSF
CICS statistics
Db2 statistics
MQ metrics
application logs

e relacioná-los a ecossistemas modernos envolvendo dashboards, APM, Prometheus, Grafana e OpenTelemetry, dependendo da arquitetura adotada.

A grande pergunta deixa de ser:

O programa está rodando?

E passa a ser:

O sistema está se comportando corretamente?


📊 CAPÍTULO 12 — O PROGRAMA ESTÁ VERDE, MAS O CLIENTE ESTÁ VERMELHO

Imagine:

CPU ........ OK
MEMORY ..... OK
CICS ....... OK
DB2 ........ OK
MQ ......... OK

Tudo verde.

Mas pagamentos estão levando 18 segundos.

Tecnicamente diversos componentes podem estar disponíveis.

Do ponto de vista do cliente, porém, existe problema.

Observabilidade precisa aproximar infraestrutura e experiência do negócio.

Podemos acompanhar:

latência
throughput
taxa de erro
tempo de resposta
fila
CPU
I/O
locks
timeouts
transações

e, quando possível, indicadores de negócio.

Esse é um salto enorme para o programador iniciante.

Ele deixa de pensar exclusivamente no programa e começa a pensar no serviço.


🤖 CAPÍTULO 13 — CARLITOS ENCONTRA UM ROBÔ COM IA

Finalmente chega 2026.

A fábrica recebe uma nova máquina:

GENERATIVE AI

O gerente anuncia:

— Agora ela fará tudo!

Carlitos olha desconfiado.

Com razão.

IA pode auxiliar bastante no ciclo de desenvolvimento.

Pode ajudar a:

explicar código legado
documentar programas
sugerir testes
analisar código
resumir mudanças
investigar logs
produzir documentação
auxiliar code review

Imagine um COBOL antigo com milhares de linhas.

Uma ferramenta assistida por IA pode ajudar o desenvolvedor a compreender estruturas e fluxos.

Excelente.

Mas existe uma regra:

AI OUTPUT
    ↓
HUMAN REVIEW
    ↓
BUILD
    ↓
STATIC ANALYSIS
    ↓
TESTS
    ↓
SECURITY
    ↓
APPROVAL

Quanto mais fácil se torna produzir código, maior pode se tornar a necessidade de mecanismos confiáveis para verificar o código produzido.

Portanto existe uma ironia maravilhosa.

IA não elimina DevOps.

Ela pode tornar DevOps ainda mais importante.


🎓 CAPÍTULO 14 — DEVOPS NÃO DEVERIA SER UMA ILHA NA FORMAÇÃO

Aqui chegamos ao ponto central.

Imagine uma pós-graduação organizada assim:

COBOL
JCL
VSAM
DB2
CICS
IMS
MQ
DEVOPS

Parece razoável.

Mas existe um problema pedagógico.

O aluno pode interpretar DevOps como mais uma caixinha.

Eu faria diferente.

DevOps deveria atravessar várias disciplinas.

Aprendeu COBOL?

COBOL + Git + Test

Aprendeu Db2?

Db2 + migration + test + rollback

Aprendeu CICS?

CICS + deploy + observability

Aprendeu MQ?

MQ + integration test + monitoring

Aprendeu API?

API + OpenAPI + pipeline + security

Assim o aluno percebe que DevOps não está no final da estrada.

DevOps é parte da estrada.


🧑‍🏭 CAPÍTULO 15 — O CODING TANK DE CARLITOS

Eu terminaria essa formação com uma aplicação integradora.

Uma pequena aplicação financeira contendo:

CUSTOMER
ACCOUNT
TRANSACTION
PAYMENT

Tecnologias:

COBOL
JCL
CICS
DB2
VSAM
MQ
API

Então entregaria uma mudança:

Adicionar a origem da transação e disponibilizar a informação para um consumidor externo.

Primeiro o aluno pensa:

— Vou alterar um campo.

Depois descobre:

REQUISITO
     ↓
ANÁLISE DE IMPACTO
     ↓
COPYBOOK
     ↓
COBOL
     ↓
DB2
     ↓
CICS
     ↓
API
     ↓
GIT
     ↓
PULL REQUEST
     ↓
BUILD
     ↓
UNIT TEST
     ↓
INTEGRATION TEST
     ↓
QUALITY GATE
     ↓
SIT
     ↓
UAT
     ↓
APPROVAL
     ↓
PROD
     ↓
OBSERVABILITY

Agora COBOL deixou de ser uma disciplina.

Virou parte de um sistema.


🧠 CAPÍTULO 16 — A GRANDE DIFERENÇA ENTRE PROGRAMADOR E ENGENHEIRO

O objetivo não deveria ser abandonar a figura do programador COBOL.

Muito pelo contrário.

Precisamos valorizar profundamente esse conhecimento.

Mas podemos expandi-lo.

O profissional começa sabendo:

MOVE
IF
EVALUATE
PERFORM
CALL
READ
WRITE

Depois compreende:

JCL
VSAM
Db2
CICS
IMS
MQ

E finalmente enxerga:

              BUSINESS
                  │
                  ▼
             APPLICATION
                  │
      ┌───────────┼───────────┐
      ▼           ▼           ▼
    BATCH       ONLINE       API
      │           │           │
      └───────────┼───────────┘
                  ▼
                 Git
                  │
                  ▼
                CI/CD
                  │
                  ▼
               TESTING
                  │
                  ▼
               SECURITY
                  │
                  ▼
                PROD
                  │
                  ▼
           OBSERVABILITY

Esse profissional começa a se aproximar da ideia de um Mainframe Application Engineer.

Ele não precisa ser especialista em absolutamente tudo.

Isso seria impossível.

Mas precisa entender como as peças conversam.


🎩 EPÍLOGO — CARLITOS SAI DA ESTEIRA

No final de Tempos Modernos, Carlitos percebe que existe algo além daquela fábrica gigantesca.

Nossa metáfora termina de maneira semelhante.

O jovem programador entrou pensando:

Meu trabalho é escrever COBOL.

Depois descobriu:

Meu trabalho é alterar uma aplicação.

Mais tarde percebeu:

Meu trabalho é entregar uma mudança segura.

Finalmente compreendeu:

Meu trabalho faz parte da entrega contínua de um serviço de negócio.

Essa evolução muda completamente a maneira como ensinamos mainframe.

COBOL continua essencial.

JCL continua essencial.

CICS, IMS, Db2, VSAM e MQ continuam essenciais.

Mas precisamos construir as pontes:

LEGADO
   │
   ▼
Git
   │
   ▼
AUTOMAÇÃO
   │
   ▼
TESTES
   │
   ▼
SEGURANÇA
   │
   ▼
CI/CD
   │
   ▼
PRODUÇÃO
   │
   ▼
OBSERVABILIDADE

É por isso que DevOps precisa ganhar muito mais espaço na formação mainframe em 2026.

Não porque Git seja moderno.

Não porque Jenkins seja moderno.

Não porque pipeline seja moderno.

Mas porque o próprio trabalho mudou.

A empresa não precisa apenas de alguém capaz de apertar perfeitamente o parafuso que passa diante dele na esteira.

Ela precisa de profissionais capazes de olhar para as engrenagens e perguntar:

De onde veio esta peça?

Quem a modificou?

Como sabemos que funciona?

Como sabemos que é segura?

Quem autorizou sua passagem?

Como sabemos exatamente o que entrou em produção?

Como descobriremos que existe um problema?

E como voltaremos com segurança se algo der errado?

Carlitos pega sua bengala.

Olha uma última vez para a fábrica.

Em algum lugar, um pipeline fica vermelho.

O relógio marca discretamente:

03:17.

O jovem programador olha desesperado para ele:

— Carlitos! O que fazemos agora?

Ele aponta para o dashboard.

Depois para os logs.

Depois para o último commit.

Depois para o pipeline.

Finalmente aponta para o rollback documentado.

E sorri.

Porque finalmente o jovem entendeu.

Mainframe DevOps não é fazer o COBOL correr mais rápido pela esteira.

É construir uma esteira na qual saibamos o que entrou, quem colocou, por que entrou, como foi testado, como chegou até ali, como está funcionando e como retirá-lo caso alguma engrenagem comece a triturar Carlitos outra vez.

☕ Um Café no Bellacosa Mainframe

Porque até em Tempos Modernos alguém precisa descobrir quem fez deploy direto em produção.

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