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

terça-feira, 23 de junho de 2026

☕🚀 IBM Garage para Padawans do COBOL

 

Bellacosa Mainframe apresenta o IBM Garage

☕🚀 IBM Garage para Padawans do COBOL

Como a IBM descobriu que colocar arquitetos, desenvolvedores e usuários numa sala com Post-it era mais barato do que deixar um Comitê decidir durante 18 meses

Por Vagner Bellacosa – Bellacosa Mainframe


Introdução

Existe uma cena que provavelmente aconteceu em algum lugar do planeta Terra.

Uma grande empresa possui:

  • 40 milhões de linhas COBOL;

  • 8 regiões CICS;

  • 12 subsistemas DB2;

  • IMS desde a época em que Darth Vader ainda era funcionário da Estrela da Morte;

  • dezenas de integrações misteriosas que ninguém sabe exatamente quem fez.

Então alguém da diretoria aparece numa reunião e pergunta:

"Por que nosso aplicativo não é igual ao Nubank?"

Silêncio.

O programador COBOL olha para o sysprog.

O sysprog olha para o DBA.

O DBA olha para o arquiteto.

O arquiteto olha para o teto.

O teto continua sendo o profissional mais experiente da sala.

E foi justamente para lidar com este tipo de situação que surgiu uma metodologia chamada:

IBM Garage

E não...

Não é uma oficina mecânica da IBM.

Você não troca óleo do z16.

Não calibra pneus do CICS.

Não faz alinhamento de DB2.

Apesar de alguns ambientes precisarem desesperadamente de uma revisão completa.


A origem do IBM Garage

A IBM percebeu uma coisa importante.

Muitas empresas estavam gastando fortunas em projetos de transformação digital.

E a sequência era sempre parecida.

Fase 1

Consultoria.

Fase 2

PowerPoint.

Fase 3

Mais PowerPoint.

Fase 4

Comitê.

Fase 5

Outro comitê.

Fase 6

Projeto cancelado.

Fase 7

Novo projeto para descobrir porque o primeiro falhou.

Não parecia eficiente.

A IBM decidiu buscar inspiração em outro lugar.

Nas startups.

No Vale do Silício.

No Design Thinking.

No Agile.

No Lean Startup.

E criou algo chamado:

IBM Garage.

O objetivo era simples.

Parar de discutir ideias infinitamente.

E começar a construir.

Rapidamente.


O que significa Garage?

A inspiração vem literalmente das garagens onde várias empresas começaram.

Apple.

HP.

Google.

Amazon.

Muitas delas nasceram em espaços pequenos.

Com poucas pessoas.

Testando ideias.

Errando.

Aprendendo.

E evoluindo rapidamente.

A IBM tentou trazer esta mentalidade para empresas gigantes.

Inclusive bancos.

Seguradoras.

Governos.

Telecom.

Empresas aéreas.

Hospitais.


O problema das empresas tradicionais

Imagine um banco.

Ele possui.

COBOL

CICS

IMS

DB2

VSAM

MQ

Batch

JCL

Tudo funcionando.

Há décadas.

Milhões de transações.

99,999% disponibilidade.

Mas surge uma nova necessidade.

Aplicativo mobile.

Pix.

Open Finance.

IA.

Chatbots.

APIs.

Machine Learning.

Analytics.

A pergunta aparece.

Como modernizar?

Reescrever tudo?

Jamais.

Isso seria equivalente a desmontar um Boeing 787 em pleno voo.

E pedir para os passageiros aguardarem tranquilamente.


O IBM Garage resolve isso

A ideia é:

Não jogar fora.

Não substituir.

Não destruir.

Mas aproveitar.

Modernizar.

Expor.

Integrar.

Evoluir.


Os pilares do IBM Garage

Design Thinking

Descobrir o problema.

Não assumir soluções.

Perguntas.

Quem usa?

Como usa?

Por que usa?

O que incomoda?


Agile

Pequenas entregas.

Feedback rápido.

Melhoria contínua.

Não esperar dois anos.

Não esperar aprovação do Conselho Jedi.


DevOps

Automação.

Pipeline.

Testes.

Deploy.

Integração contínua.


Hybrid Cloud

Executar aplicações onde faz sentido.

Cloud.

OpenShift.

IBM Z.

Linux.

Containers.


Inteligência Artificial

Watsonx.

LLMs.

Assistentes.

Análise de dados.


O IBM Garage para quem trabalha com Mainframe

Aqui fica interessante.

Porque o COBOL deixa de ser visto como problema.

E passa a ser ativo estratégico.

Imagine.

Programa COBOL

CICS

z/OS Connect

API REST

Aplicativo Android

Fim.

Sem reescrever.

Sem migrar.

Sem trauma psicológico.


Exemplo real

Sistema bancário.

Programa COBOL:

CONSCLIE

Recebe:

CPF

Retorna:

Nome

Saldo

Conta

Antes.

Somente terminal 3270.

Agora.

API.

JSON.

Cliente consulta pelo celular.

COBOL continua executando.

Feliz.

Seguro.

Confortável.

Como um senhor aposentado tomando café observando jovens discutirem Kubernetes.


As quatro fases do IBM Garage

1 Descobrir

Workshop.

Usuários.

TI.

Negócio.

Arquitetos.

Desenvolvedores.

Perguntas.

O que dói?

O que demora?

O que pode melhorar?


2 Definir

Escolher MVP.

Escopo.

Backlog.

Priorização.


3 Construir

Sprint.

Desenvolvimento.

Testes.

Protótipos.


4 Escalar

Produção.

DevSecOps.

Observabilidade.

Governança.


Exemplo para um desenvolvedor COBOL Júnior

Vamos imaginar.

Seu gerente diz.

Precisamos criar uma API.

Consultar cliente.

Passo 1

Identificar programa COBOL.

CONSCLIE

Passo 2

Verificar COMMAREA.

01 DFHCOMMAREA.

   05 CPF         PIC X(11).

   05 NOME        PIC X(40).

   05 SALDO       PIC S9(9)V99.

Passo 3

Criar serviço z/OS Connect.

Mapear campos.

Passo 4

Gerar Swagger.

Passo 5

Publicar.

Passo 6

Testar.

curl http://api.banco.com/clientes/12345678901

Resposta.

{
"name":"JOAO SILVA",
"saldo":1500.50
}

Pronto.

Você participou de uma iniciativa IBM Garage.

Sem perceber.


Ferramentas utilizadas

OpenShift

Git

Jenkins

UrbanCode

Ansible

Instana

Turbonomic

watsonx

Zowe

z/OS Connect

API Connect


O papel do desenvolvedor COBOL

Muita gente acredita.

Garage é somente para arquitetos.

Errado.

COBOL Developers são fundamentais.

Porque conhecem.

Regras de negócio.

Batch.

CICS.

DB2.

Processos críticos.

Sem eles.

Modernização vira arqueologia.


Dicas para um Programador COBOL Júnior

Estude APIs

REST.

JSON.

Swagger.

OpenAPI.


Aprenda Git

Git é obrigatório.


Conheça Docker

Mesmo sem usar.

Entenda conceitos.


Aprenda OpenShift

É o Kubernetes corporativo da IBM.


Estude z/OS Connect

Talvez seja a ferramenta mais importante atualmente para integração Mainframe.


Aprenda Agile

Scrum.

Kanban.

Sprint.


Não tenha medo de IA

A IA provavelmente escreverá códigos.

Mas dificilmente entenderá cinquenta anos de regras bancárias escondidas em programas COBOL com 80 mil linhas.

Você entenderá.

E isso possui enorme valor.


Minha opinião sobre IBM Garage

Eu gosto da proposta.

Porque ela reconhece algo importante.

Mainframe não é problema.

Mainframe é patrimônio.

COBOL não está morrendo.

Está sendo conectado.

API por API.

Container por container.

Sprint por sprint.

Workshop por workshop.

Até que um sistema criado em 1989 converse naturalmente com uma aplicação React, um chatbot baseado em LLM, um aplicativo Android e um painel analítico em nuvem.

E talvez esta seja a maior lição do IBM Garage.

Transformação digital não significa jogar fora décadas de conhecimento.

Significa pegar tudo aquilo que funciona incrivelmente bem.

Colocar uma interface moderna.

Adicionar automação.

Criar APIs.

Aplicar inteligência artificial.

E permitir que a próxima geração de desenvolvedores COBOL continue escrevendo história.

Porque, no fim das contas, o COBOL continua sendo aquele veterano experiente do escritório.

Ele não usa tênis colorido.

Não fala em Web3.

Não posta frases motivacionais no LinkedIn.

Mas é ele que paga os boletos do banco.

Processa salários.

Liquida cartões.

Movimenta bolsas de valores.

Autoriza pagamentos.

E mantém o mundo funcionando enquanto a internet discute qual será o próximo framework JavaScript da semana.

E talvez seja exatamente por isso que o IBM Garage exista.

Para mostrar que inovação não é destruir o passado.

É construir uma ponte elegante entre 1960 e 2030.

E fazer isso tomando um bom café, de preferência acompanhado de um desenvolvedor COBOL, um arquiteto IBM Z, um especialista em APIs e algumas dezenas de Post-its espalhadas pela mesa.

Apenas tome cuidado.

Se alguém aparecer dizendo que vai reescrever 40 milhões de linhas COBOL em um final de semana usando Inteligência Artificial, esconda o café.

E chame imediatamente um sysprog.


sábado, 4 de outubro de 2025

☕💾🔥 ENGENHARIA DE SOFTWARE — O “SISTEMA OPERACIONAL INVISÍVEL” QUE SEPARA PROGRAMADORES COMUNS DE PROFISSIONAIS ENTERPRISE 🔥💾☕

 

Bellacosa Mainframe e a Engenharia de Software

☕💾🔥 ENGENHARIA DE SOFTWARE — O “SISTEMA OPERACIONAL INVISÍVEL” QUE SEPARA PROGRAMADORES COMUNS DE PROFISSIONAIS ENTERPRISE 🔥💾☕

Muita gente entrando no mundo COBOL/mainframe acredita que:

“Engenharia de software = aprender linguagem.”

☠️🔥

Mas aí acontece o primeiro trauma corporativo real:

  • ABEND em produção;
  • batch atrasado;
  • janela estourada;
  • rollback;
  • incidente crítico;
  • auditoria;
  • problema de performance DB2;
  • mudança quebrando outro sistema;
  • integração falhando às 3h da manhã.

E nesse momento o programador descobre:

Engenharia de software NÃO é apenas programar.

Ela é:

  • organização;
  • arquitetura;
  • previsibilidade;
  • qualidade;
  • processos;
  • sobrevivência operacional.

☕ O QUE É ENGENHARIA DE SOFTWARE DE VERDADE?

Engenharia de software é:

construir sistemas grandes, confiáveis, escaláveis e sustentáveis sem transformar a empresa num apocalipse tecnológico.

🔥💾☕


O ERRO MAIS COMUM DO PROGRAMADOR JÚNIOR

O iniciante normalmente pensa assim:

“Se compilou e rodou, está pronto.”

☠️☠️☠️

No mundo enterprise isso NÃO significa nada.

Porque um software corporativo precisa:

  • funcionar;
  • escalar;
  • ser seguro;
  • ser auditável;
  • ser documentado;
  • sobreviver anos;
  • suportar manutenção;
  • integrar com dezenas de sistemas;
  • não destruir produção.

☕💾 O MAINFRAME ENSINOU ISSO MUITO ANTES DA CLOUD

A ironia é fantástica.

Hoje o mercado fala:

  • DevOps;
  • SRE;
  • observabilidade;
  • resiliência;
  • alta disponibilidade;
  • governança.

Mas o mundo mainframe já fazia isso desde os anos 70.

🔥☕


UM PROGRAMADOR COBOL NÃO ESCREVE “APENAS PROGRAMAS”

Ele frequentemente participa de:

  • sistemas bancários;
  • processamento de folha;
  • cartões;
  • PIX;
  • compensação;
  • seguros;
  • governo;
  • telecom.

Ou seja:

software que movimenta bilhões.


☕ A DIFERENÇA ENTRE “CODAR” E “ENGENHARIA”

Programador comum

“Vou fazer funcionar.”

Engenheiro de software

“Como isso vai sobreviver 15 anos em produção?”

🔥💾


O SDLC — O CICLO DA SOBREVIVÊNCIA CORPORATIVA

Toda empresa séria usa algum tipo de SDLC.

Software Development Life Cycle


As etapas clássicas

Requirements

Design

Development

Testing

Deployment

Maintenance

☕ O QUE O JÚNIOR NORMALMENTE NÃO PERCEBE

O código é apenas UMA etapa pequena.

Grande parte do esforço real está em:

  • entender negócio;
  • validar regras;
  • testar;
  • homologar;
  • documentar;
  • subir produção;
  • monitorar;
  • manter.

☠️ O MAIOR CEMITÉRIO DA TI

Projetos falham mais por:

  • requisitos ruins;
  • arquitetura ruim;
  • falta de comunicação;
  • falta de testes;

do que por linguagem.


☕💾 REQUISITOS — O “BUG” QUE NASCE ANTES DO CÓDIGO

Muitos sistemas falham porque:

o time implementou corretamente…
o requisito errado.

☠️🔥


Exemplo COBOL clássico

Usuário diz:

“quero calcular juros.”

Mas ninguém definiu:

  • regra;
  • arredondamento;
  • calendário;
  • horário;
  • feriados;
  • timezone;
  • tratamento de exceção.

☠️☠️☠️

Resultado:

  • prejuízo;
  • auditoria;
  • incidente;
  • caos.

☕ TESTES — O SEGURO DE VIDA DO ENTERPRISE

Programador júnior frequentemente pensa:

“Mas na minha máquina funcionou.”

☠️🔥☠️🔥☠️🔥

Produção enterprise não perdoa isso.


Tipos de teste

Functional

A regra funciona?


Performance

Aguenta milhões de transações?


Regression

A correção quebrou outro sistema?


Security

Existe vulnerabilidade?


☕💾 MAINFRAME LEVA ISSO AO EXTREMO

Porque:

  • bancos não podem parar;
  • folha não pode falhar;
  • PIX não pode sumir;
  • cartão não pode duplicar;
  • batch não pode atrasar.

Então engenharia enterprise nasce da paranoia operacional.

🔥☕


VERSIONAMENTO — O “TIME MACHINE” CORPORATIVO

Sem versionamento:

  • ninguém sabe quem mudou;
  • ninguém sabe quando;
  • ninguém sabe por quê.

☠️🔥


Mundo moderno

  • Git
  • GitHub
  • GitLab

Mundo mainframe

  • Endevor
  • Changeman
  • Librarian

☕ O CONCEITO É O MESMO

Controlar:

  • mudanças;
  • histórico;
  • rollback;
  • rastreabilidade.

☕💾 ARQUITETURA — O CÉREBRO INVISÍVEL DO SISTEMA

Aqui o júnior normalmente desperta.

Porque descobre que:

sistemas grandes NÃO sobrevivem só com código.

Precisam:

  • organização;
  • integração;
  • escalabilidade;
  • segurança;
  • observabilidade.

Exemplo bancário

Frontend

API Gateway

Microservices

MQ

COBOL/CICS

DB2

Isso é engenharia enterprise.


☠️ MICROservices NÃO SÃO “MÁGICA”

Muita empresa cria:

400 APIs
+
500 containers
+
logs infinitos
+
monitoramento caótico

e chama isso de:

“transformação digital.”

☠️🔥☠️🔥☠️🔥


☕💾 O MAINFRAME ENSINOU ALGO IMPORTANTE

Centralização às vezes é:

  • mais segura;
  • mais simples;
  • mais eficiente.

Por isso muitos core bancários continuam no z/OS.


O GRANDE SEGREDO DA ENGENHARIA DE SOFTWARE

Ela NÃO é sobre tecnologia apenas.

Ela é sobre:

  • reduzir caos;
  • reduzir risco;
  • reduzir falhas;
  • organizar complexidade.

🔥☕


☕ O JÚNIOR QUE EVOLUI RÁPIDO ENTENDE ISSO

Linguagens mudam.

Ontem:

  • COBOL;
  • PL/I;
  • C.

Depois:

  • Java;
  • C#;
  • Python.

Agora:

  • IA assistida;
  • automação;
  • cloud native.

Mas:

  • lógica;
  • arquitetura;
  • qualidade;
  • engenharia;

continuam eternas.


☕💾 O FUTURO DO PROGRAMADOR COBOL

O mercado NÃO quer apenas:

“quem sabe COBOL.”

Quer:

  • APIs;
  • integração;
  • cloud;
  • automação;
  • observabilidade;
  • DevOps;
  • segurança;
  • engenharia moderna.

E AQUI ESTÁ A GRANDE VERDADE

Quem domina:

  • fundamentos enterprise;
  • processamento crítico;
  • arquitetura;
  • mentalidade operacional;

possui vantagem enorme no mercado moderno.

Porque MUITOS desenvolvedores atuais:

  • sabem framework;
  • sabem frontend;
  • sabem cloud;

mas nunca sustentaram:

  • processamento nacional;
  • batch crítico;
  • transações financeiras massivas.

☕💾🔥 CONCLUSÃO — ENGENHARIA DE SOFTWARE É A ARTE DE EVITAR O APOCALIPSE CORPORATIVO 🔥💾☕

Programar faz software funcionar.

Engenharia de software faz:

  • software sobreviver;
  • empresas continuarem operando;
  • sistemas escalarem;
  • produção não explodir às 2h da manhã.

E no fundo…

o mundo mainframe já sabia disso muito antes da internet virar moda. 💾☕🔥


quarta-feira, 15 de janeiro de 2025

☕📋💣 BACKLOG: O ARQUIVO SECRETO QUE SEPARA UM PROGRAMADOR COBOL COMUM DE UM VERDADEIRO ARQUITETO DE SISTEMAS

Bellacosa Mainframe e o backlog mainframe


☕📋💣 BACKLOG: O ARQUIVO SECRETO QUE SEPARA UM PROGRAMADOR COBOL COMUM DE UM VERDADEIRO ARQUITETO DE SISTEMAS

"O sistema não está parado. Ele apenas está esperando na fila."

Existe uma cena que se repete diariamente em praticamente todas as empresas que possuem Mainframe.

O telefone toca.

Um gerente aparece.

Um usuário reclama.

Um diretor pede urgência.

Uma área regulatória exige mudanças.

O banco central publica uma nova norma.

O auditor encontra uma inconsistência.

O operador identifica um erro.

E de repente surgem vinte novas tarefas.

A pergunta é:

quem decide o que será feito primeiro?

É exatamente nesse momento que nasce um dos conceitos mais importantes da engenharia de software moderna:

o Backlog.

Se você é um programador COBOL Mainframe iniciante, entender backlog pode acelerar sua carreira mais do que aprender cinquenta comandos novos de JCL.

Porque programar é importante.

Mas entender como o trabalho é organizado é o que diferencia um executor de um profissional estratégico.

Pegue seu café.

Vamos abrir esse dataset.


O QUE É BACKLOG?

A definição mais simples possível:

Backlog é uma lista organizada de tudo aquilo que precisa ser feito.

Simples assim.

Pode conter:

  • novas funcionalidades;

  • correções de bugs;

  • melhorias;

  • ajustes regulatórios;

  • documentação;

  • refatoração;

  • automação;

  • modernização.

Tudo entra no backlog.

Pense nele como uma fila de JOBs esperando para executar.


O BACKLOG EXPLICADO COMO UM JOB SCHEDULER

Imagine um ambiente de produção.

Você possui:

JOB001 - Fechamento diário
JOB002 - Atualização de clientes
JOB003 - Relatório gerencial
JOB004 - Backup
JOB005 - Auditoria

Todos precisam executar.

Mas existe uma ordem.

Backlog é exatamente isso.

Uma fila organizada de atividades aguardando execução.

A diferença é que em vez de JOBs estamos falando de trabalho humano.


O MAIOR MITO SOBRE BACKLOG

Muitos iniciantes acreditam:

"Backlog é uma lista de novas funcionalidades."

Errado.

Backlog é muito maior que isso.

Um backlog saudável contém:

  • inovação;

  • manutenção;

  • correções;

  • melhorias;

  • dívida técnica.

Quando só existem novas funcionalidades no backlog, algo está errado.

Muito errado.


UM EXEMPLO REAL DE MAINFRAME

Imagine um sistema bancário.

O backlog pode conter:

Criar PIX Internacional
Corrigir cálculo de juros
Atualizar layout FEBRABAN
Refatorar COBCLI01
Documentar JOB FAT0001
Criar testes para módulo de cobrança

Observe.

Nem tudo é desenvolvimento novo.

Parte do trabalho é manutenção.

Parte é prevenção.

Parte é sobrevivência.


ONDE ENTRA A DÍVIDA TÉCNICA?

Agora chegamos ao ponto interessante.

A dívida técnica normalmente vive dentro do backlog.

Por exemplo:

BACKLOG

Criar API de consulta
Novo relatório fiscal
Refatorar COBPAG01
Eliminar COPYBOOK duplicado
Automatizar testes

Os três últimos itens são pagamentos de dívida técnica.

Ou seja:

Todo pagamento de dívida técnica vira backlog.

Mas nem todo backlog é dívida técnica.


COMO A DÍVIDA TÉCNICA APARECE

Imagine que você recebeu uma demanda urgente.

O gerente diz:

"Precisamos colocar isso em produção amanhã."

Você cria uma solução rápida.

Funciona.

Entrega realizada.

Todo mundo feliz.

Meses depois:

  • ninguém entende o código;

  • faltam comentários;

  • surgem bugs;

  • novas alterações ficam lentas.

Pronto.

A dívida nasceu.


O EFEITO BOLA DE NEVE

O primeiro remendo parece inocente.

Depois vem outro.

E mais outro.

Então surge um IF dentro de outro IF.

Depois outro.

Quando você percebe:

IF A
   IF B
      IF C
         IF D
            IF E

O programa ainda funciona.

Mas ninguém mais entende.

Isso é o juros da dívida técnica.


O DIA EM QUE O BACKLOG VIROU UM CEMITÉRIO

Existe uma curiosidade interessante.

Algumas empresas possuem backlog com milhares de itens.

Mas ninguém sabe:

  • quem criou;

  • por que criou;

  • se ainda faz sentido.

Isso não é backlog.

É arqueologia corporativa.


COMO UM JÚNIOR DEVE ENXERGAR O BACKLOG

Não veja o backlog como uma lista de tarefas.

Veja como um mapa.

Ele mostra:

  • para onde o sistema está indo;

  • quais problemas existem;

  • quais riscos precisam ser tratados.

Os melhores analistas costumam estudar o backlog inteiro.

Não apenas sua tarefa.


COMO IDENTIFICAR DÍVIDA TÉCNICA

Existem sinais clássicos.

Programas gigantes

Mais de 10.000 linhas.


COPYBOOKs duplicados

Mesma estrutura espalhada.


JCLs clonados

Copiar e colar virou arquitetura.


Falta de documentação

Conhecimento armazenado apenas na cabeça de alguém.


Dependência de especialistas

Quando você ouve:

"Somente o Carlos entende isso."

A dívida já existe.


COMO MAPEAR DÍVIDA TÉCNICA

Crie uma planilha simples.

Campos:

  • Sistema

  • Programa

  • Problema

  • Risco

  • Complexidade

  • Prioridade

Exemplo:

ProgramaProblema
COBCLI01Sem documentação
COBPAG0215.000 linhas
COBFAT03Sem testes

Agora a dívida ficou visível.

E aquilo que é visível pode ser gerenciado.


MÉTRICAS IMPORTANTES

Os melhores profissionais medem.

Sempre.

Algumas métricas úteis:

Número de ABENDs

Quanto mais ABENDs.

Maior a chance de problemas estruturais.


Tempo médio de correção

Quanto demora para corrigir um incidente?


Quantidade de bugs

Excelente indicador.


Número de programas sem documentação

Métrica simples.

Mas extremamente poderosa.


FERRAMENTAS QUE AJUDAM

Muitos acreditam que Mainframe não possui ferramentas modernas.

Grande erro.


IBM ADDI

Mapeia dependências.

Mostra relações entre:

  • COBOL;

  • JCL;

  • DB2;

  • CICS.


IBM Application Discovery

Excelente para sistemas legados.


IBM Fault Analyzer

Investiga ABENDs.


IBM Debug Tool

Ajuda a entender programas complexos.


SonarQube

Em ambientes integrados.

Ajuda na análise de qualidade.


Git

Sim.

Mainframe moderno usa Git.

E muito.


COMO CONTROLAR O BACKLOG

Regra simples.

Prioridade.

Nem tudo tem o mesmo peso.

Uma técnica muito usada:

Alta prioridade

Produção parada.


Média prioridade

Risco futuro.


Baixa prioridade

Melhorias desejáveis.


O SEGREDO DOS TIMES MADUROS

Times iniciantes fazem:

100% Funcionalidades

Times maduros fazem:

70% Funcionalidades
20% Correções
10% Dívida Técnica

Alguns chegam a reservar uma sprint inteira para limpeza.

E os resultados aparecem rapidamente.


EASTER EGG MAINFRAME

Se você encontrar comentários como:

* NÃO ALTERAR
* FUNCIONA DESDE 1998

Você encontrou um fóssil corporativo.

Parabéns.

Agora investigue antes de tocar.

Porque muitas vezes esse comentário está escondendo uma dívida técnica de milhões de dólares.


A REGRA DOS 15 MINUTOS

Uma dica que poucos ensinam.

Se você gastou mais de 15 minutos para entender um trecho de código:

documente.

Seu "eu do futuro" agradecerá.


COMO EVOLUIR MAIS RÁPIDO NA CARREIRA

O júnior normalmente aprende:

  • COBOL;

  • JCL;

  • DB2;

  • CICS.

Mas os profissionais mais valorizados aprendem também:

  • gestão de backlog;

  • análise de impacto;

  • controle de dívida técnica;

  • arquitetura;

  • observabilidade.

É isso que os transforma em analistas seniores.


O QUE NINGUÉM CONTA SOBRE BACKLOG

O backlog é uma fotografia do estado de saúde do sistema.

Se ele possui:

  • centenas de bugs;

  • dezenas de refatorações pendentes;

  • documentação atrasada;

o sistema está acumulando dívida.

O backlog está contando uma história.

Aprenda a lê-la.


CONCLUSÃO

Backlog não é apenas uma lista de tarefas.

É o painel de controle do futuro do sistema.

E a dívida técnica é uma das passageiras mais perigosas dessa viagem.

Um programador COBOL Mainframe que aprende a:

  • identificar problemas;

  • registrar atividades;

  • priorizar demandas;

  • controlar dívida técnica;

  • documentar descobertas;

deixa de ser apenas alguém que escreve código.

Passa a ser alguém capaz de manter sistemas vivos por décadas.

E no mundo Mainframe, onde muitos programas são mais antigos que seus desenvolvedores, essa habilidade vale ouro.

Porque no final das contas, o verdadeiro segredo não é escrever um programa novo.

É conseguir entender por que aquele programa de 1989 ainda está funcionando perfeitamente em produção.

E sobreviver ao chamado das 03:17 da manhã quando alguém decidir alterá-lo.

 

segunda-feira, 22 de abril de 2024

Alan Turing Entra na Sala de Mudanças — O Dia em que o Agile Descobriu que um Programa COBOL Não Chega Sozinho à Produção

 

Bellacosa Mainframe e as metodologias Ageis para um coboleiro

☕ Um Café no Bellacosa Mainframe

Alan Turing Entra na Sala de Mudanças — O Dia em que o Agile Descobriu que um Programa COBOL Não Chega Sozinho à Produção

Ou: por que uma sprint não termina quando o compilador sorri, o que RACF, Db2, JCL, UX e Operação estão fazendo na mesma história e como não transformar Agile em Waterfall de post-it

 

Imagine Alan Turing entrando numa sala de projeto em 2026. Há um quadro com colunas coloridas: To do, Doing, Done. Alguém aponta para um cartão e anuncia, muito satisfeito: “acabou; o COBOL compilou”. Turing olha para o cartão, para o café frio ao lado do terminal e faz a pergunta que estraga metade das celebrações corporativas:

“Acabou para quem?”

O programa compilou. Ótimo. Mas o pacote Db2 foi validado? O acesso RACF existe e obedece ao menor privilégio? O job está no scheduler correto? A operação sabe interpretar um RC=8? A massa de testes representa o volume de fim de mês? A interface explica ao cliente que o processamento é assíncrono? Existe um plano de retorno se a alteração abrir um buraco no universo — ou, pior, na conciliação financeira?

Para o programador COBOL iniciante, esta é uma descoberta importante: em um projeto mainframe, você não entrega apenas um programa. Você entrega uma mudança dentro de um ecossistema que processa dados valiosos, conversa com muitas plataformas e, em vários casos, não pode errar por cinco minutos sem alguém perceber no extrato, no caixa, na folha ou no jornal.

Este artigo é um mapa para entender a diferença entre Agile e Waterfall, o papel dos dados e da IA, e por que o mainframe exige uma forma mais adulta de agilidade: rápida para aprender, rigorosa para produzir.



1. Agile não é correria; Waterfall não é vilão

O modelo Waterfall — a famosa cascata — costuma organizar o projeto em grandes etapas sequenciais:

Requisitos → análise → desenho → desenvolvimento → testes → implantação.

Ele faz sentido quando o problema é estável e bem conhecido. Uma adequação regulatória com regras fechadas, uma troca controlada de infraestrutura ou uma alteração obrigatória de layout podem exigir muito planejamento antes de escrever a primeira linha. Em sistemas críticos, isso não é burocracia por esporte; é controle de risco.

O defeito aparece quando tratamos algo incerto como se estivesse completamente decidido. O time passa meses documentando, desenvolve por meses adicionais e só no fim descobre que o cliente não entendia o fluxo, que uma integração não suporta a carga ou que a regra de negócio tinha uma exceção escondida num e-mail de 2017.

O Agile trabalha diferente. Ele divide a jornada em partes pequenas: construir, testar, mostrar, aprender e ajustar. Não é ausência de planejamento. É planejamento em fatias, com aprendizado antecipado.

PerguntaWaterfallAgile maduro
Quando aprendemos se a solução serve?Mais perto do fimEm entregas curtas
O requisito pode mudar?Tende a virar exceção formalPode ser repriorizado com evidência
Como o risco aparece?Às vezes tardeDeve surgir em cada ciclo
O que significa progresso?Fase concluídaValor entregue, testado e operável

Nem todo projeto precisa ser 100% de um modelo. No mainframe, o mais comum e sensato é um híbrido: Agile para construir e validar valor; controles mais sequenciais para governança, auditoria, segurança, janela de mudança e produção.

O problema não é usar Waterfall. O problema é fingir que ele continua funcionando quando o negócio ainda está descobrindo o que quer. E o problema do Agile não é ter ritos; é fingir que uma daily de quinze minutos resolve uma dependência que atravessa cinco departamentos.



2. Quando os dados entram: a agilidade deixa de ser opinião

O infográfico que motivou nossa conversa diz que o futuro do Agile será orientado por dados e IA. A frase é boa, desde que não seja traduzida como “compremos uma plataforma e ela decidirá por nós”.

Dados úteis respondem perguntas simples e duras:

  • Quanto tempo uma mudança leva desde o pedido até a produção?

  • Em qual fila o trabalho fica parado?

  • Quantos defeitos escapam para produção?

  • O cliente usa a funcionalidade entregue?

  • O batch ainda cabe na janela?

  • A nova consulta Db2 aumentou CPU ou I/O?

  • Qual permissão RACF foi solicitada, por quem, para quê e até quando?

No Kanban, por exemplo, lead time mede a espera do solicitante; cycle time, o tempo de trabalho ativo; throughput, quantos itens foram concluídos; e WIP (work in progress), quantos itens estão abertos ao mesmo tempo. Se há trinta histórias abertas e três concluídas por semana, o quadro não está “agitado”: está congestionado.

Em Scrum, a velocidade pode ajudar o próprio time a planejar. Mas cuidado: story point não é hora, salário, inteligência nem medalha. Comparar a velocidade de duas equipes é como comparar o número de páginas de dois livros para decidir qual é melhor. A métrica serve para observar tendência local, não para fabricar ranking e medo.

IA pode resumir incidentes, classificar chamados, sugerir testes, localizar padrões em logs e apontar que uma fila está crescendo. Ela é um ótimo Dr. Watson de silício: organiza pistas. Mas não substitui Sherlock, muito menos o dono da regra de negócio. Um modelo pode prever atraso; não sabe, sozinho, que a causa real é a única DBA estar em férias ou que a regra depende de um contrato assinado há vinte anos.



3. XP, Scrum, Kanban e os parentes menos convidados para o café

As metodologias citadas no infográfico não são feitiços concorrentes. Cada uma ilumina uma parte do problema.

Extreme Programming (XP) reforça engenharia: TDD, integração contínua, programação em pares, pequenas mudanças e refatoração. Para COBOL, isso significa abandonar a ideia de que teste é apenas executar um job e olhar se “não deu abend”. Teste unitário, dados conhecidos, validação de regras e regressão tornam uma mudança mais segura. Se alterou juros, decimal, data, sinal ou arredondamento, tenha casos que provem o comportamento antes e depois.

Scrum organiza trabalho em sprints: backlog priorizado, planejamento, revisão e retrospectiva. É útil quando há produto evoluindo e necessidade de alinhamento frequente. Mas uma história Scrum não pode ser “codificar o programa X” se a produção depende também de autorização, bind, operação e homologação. Isso é só uma tarefa de desenvolvimento disfarçada de entrega.

Kanban é excelente para sustentação e fluxo contínuo: incidentes, pequenas manutenções, pedidos de acesso e correções. Ele mostra onde o serviço enrosca. Se todo cartão fica parado em “aguardando validação”, não adianta cobrar mais velocidade de quem codifica; é necessário corrigir o gargalo.

Feature-Driven Development (FDD) puxa a conversa para funcionalidades de negócio: “consultar saldo”, “calcular limite”, “emitir boleto”. Isso protege o time de entregar componentes tecnicamente elegantes que não resolvem nada importante. Dados de uso e feedback ajudam a priorizar, mas não eliminam criticidade: um processo usado uma vez por mês pode ser vital para uma obrigação legal.

APF, ASD, DSDM e XPM lembram que há projetos onde a incerteza é parte do trabalho. Eles valorizam adaptação, protótipos, colaboração e aprendizado. Em modernização, isso é ouro: primeiro confirme se a API atende, se a tela faz sentido e se o legado suporta a carga; depois escale. Um protótipo bonito não prova que há segurança, transação, recuperação ou capacidade de produção.

4. A história que atravessa o mainframe

Uma funcionalidade bancária aparentemente modesta — “permitir consultar uma fatura no aplicativo” — pode envolver Business Analyst, UX/UI, desenvolvedor, DBA, RACF, qualidade, gerente de sistemas e operações.

O Business Analyst traduz objetivo em regra. Não basta escrever “mostrar fatura”; é preciso dizer quais clientes podem consultar, quais períodos, o que acontece para fatura fechada, renegociada, indisponível ou protegida por sigilo.

O UX/UI desenha a jornada. Mas precisa saber se a resposta é imediata, se depende de batch, se há limites de consulta e qual mensagem humana será exibida quando um serviço estiver indisponível. A tela não pode prometer “pronto agora” quando o processo real conclui à noite.

O System Developer implementa lógica, integrações, programas COBOL, copybooks, APIs, CICS, MQ, JCL ou o que a arquitetura pedir. Seu trabalho inclui analisar impacto: quem chama este programa? Qual layout será alterado? Um campo novo quebra um consumidor antigo? Há tratamento para valor nulo, arquivo ausente e retorno inesperado?

O DBA olha além do resultado correto. A consulta funciona com cem registros? E com cinquenta milhões? Ela usa índice? Há risco de lock, timeout, deadlock, aumento de CPU ou alteração de plano de acesso após o BIND? Uma query que “funciona na homologação” pode virar o monstro da janela noturna em produção.

O especialista de RACF e segurança desenha identidade e autorização. Quem acessa? Pessoa, aplicação, job batch ou ID de serviço? Qual dataset, transação CICS, recurso Db2 ou certificado é necessário? A regra é menor privilégio, segregação de funções e prazo claro para acessos temporários. RACF não é uma cancela colocada no fim da estrada; é parte da arquitetura.

Qualidade cria cenários positivos, negativos, integrados e de volume. “O caminho feliz funcionou” é apenas o primeiro capítulo. E se o arquivo chegar vazio? E se houver caractere inválido e surgir um S0C7? E se o job receber RC=8? E se a atualização parcial precisar de rollback?

System Manager avalia plataforma, versões, capacidade, configuração e impacto de mudança. Operações prepara execução, agendamento, monitoração e resposta ao incidente. Se a equipe operacional precisa telefonar ao desenvolvedor para descobrir o que significa um erro, a mudança chegou sem manual de sobrevivência.

5. O cadáver na sprint: “pronto” para desenvolvimento, incompleto para produção

Eis o defeito mais comum: cada área usa uma definição privada de pronto.

Para Desenvolvimento, pronto é código compilado. Para Qualidade, teste executado. Para Segurança, perfil aprovado. Para Operações, job agendado e monitorado. Para o negócio, pronto é cliente receber o resultado correto. Todas as definições são legítimas — mas isoladas formam um Frankenstein organizacional.

Uma Definition of Done comum deve estabelecer, proporcionalmente ao risco, que a mudança possui:

  • regra e critérios de aceite validados;

  • código revisado, versionado, compilado e testado;

  • análise de impacto em copybooks, programas, arquivos, APIs e consumidores;

  • revisão Db2, EXPLAIN e BIND quando aplicável;

  • permissões RACF e segregação de funções definidas;

  • testes integrados, negativos e de regressão;

  • JCL, PROC, GDG, dataset, parâmetros e scheduler revisados;

  • plano de implantação e backout;

  • monitoração, logs, códigos de retorno e runbook operacional;

  • evidência de homologação e validação pós-produção.

Isso não obriga uma correção de rótulo de tela a passar pelo mesmo rito de uma alteração de saldo. O segredo é uma matriz de impacto. Marque, no refinamento: toca Db2? RACF? CICS? MQ? VSAM? JCL? dados pessoais? scheduler? interface externa? auditoria? Quanto maior o impacto, maior a necessidade de envolvimento antecipado.

6. Passo a passo: como levar uma história até produção sem ritual de pânico

1. Comece pelo valor e pelas exceções. O BA e o dono do negócio descrevem o que muda e como medir sucesso. “Reduzir ligações sobre segunda via” é melhor que “criar tela de segunda via”. Acrescente cenários de erro e regras de borda.

2. Faça análise de impacto antes de prometer a data. Desenvolvimento identifica módulos, layouts, chamadas, tabelas, jobs e interfaces. Segurança, DBA e operação entram cedo somente quando houver impacto real. Não coloque vinte pessoas na daily; coloque as pessoas certas no refinamento certo.

3. Divida verticalmente. Em vez de uma sprint para tela, outra para API e outra para COBOL, entregue uma pequena jornada completa. Talvez apenas consulta de uma fatura recente, com autorização, rastreabilidade e erro bem tratado. A fatia prova valor e reduz a hipótese.

4. Automatize o repetível. Build, testes, análise estática, promoção de artefatos e registro de evidências não deveriam depender de e-mails e memória humana. Em ambiente z/OS, ferramentas e pipelines modernos ajudam, mas automação só presta se respeitar os controles da organização.

5. Teste como se a produção fosse real. Use massa protegida e representativa. Teste volume, falha de integração, retorno inesperado, recuperação e janela batch. O objetivo não é provar que o sistema funciona em condições ideais; é descobrir como ele falha e se recupera.

6. Entregue para operação antes da operação precisar socorrer você. O runbook deve informar o que mudou, jobs e transações afetados, entradas e saídas, RCs esperados, alertas, validação pós-implantação e retorno. É conhecimento operacional, não papelada decorativa.

7. Observe e aprenda. Após produção, acompanhe uso, tempo de resposta, erro, custo e chamados. Se o recurso foi entregue e ninguém o usa, a equipe produziu software; ainda não produziu valor.

7. Easter egg de Turing: a máquina não entende intenção

Turing nos deixou uma lição que vale para COBOL e para IA: máquinas executam regras e padrões; intenção humana precisa ser expressa, validada e verificada.

Um compilador não sabe que um campo deveria ter duas casas decimais. Ele só sabe o que foi codificado. Um modelo de IA não sabe que uma permissão concedida por conveniência viola segregação de funções. Ele só encontra padrões nos dados que recebeu. Um dashboard não sabe que um item parado há dez dias representa o pagamento de pensão de milhares de pessoas.

Portanto, use IA como copiloto: para sugerir cenários de teste, resumir tickets, encontrar padrões em logs e apontar anomalias. Não a use como autorização para abandonar revisão humana, testes, controles de acesso ou responsabilidade profissional.

Epílogo — o verdadeiro Done

O jovem programador COBOL costuma imaginar que seu programa termina no GOBACK. Em uma empresa real, ele só começa ali. A alteração atravessa banco de dados, controles de acesso, testes, operação, negócio, tela, integração, auditoria e pessoas que acordarão se algo der errado às duas da manhã.

Agile bem aplicado ao mainframe não é um ataque à governança. É a forma de trazer segurança, DBA, qualidade e operações para mais perto do momento em que a decisão ainda é barata.

Turing provavelmente olharia novamente para o cartão marcado como Done e faria a pergunta final:

“O sistema apenas executa, ou a organização consegue explicar, operar, proteger e recuperar o que acabou de mudar?”

Quando a resposta for “sim”, então o cartão pode, finalmente, atravessar a última coluna.




quarta-feira, 17 de abril de 2024

RAD (Rapid Application Development) - A Metodologia que Mudou a Engenharia de Software e Continua Transformando o IBM Mainframe

 

Bellacosa Mainframe e RAD rapid application development

☕ Um Café no Bellacosa Mainframe

RAD (Rapid Application Development)

A Metodologia que Mudou a Engenharia de Software e Continua Transformando o IBM Mainframe

Você não está estudando apenas uma metodologia criada nos anos 90. Está entendendo a origem de grande parte das práticas modernas de desenvolvimento de software.

"O Mainframe nunca foi lento. Lento sempre foi o processo de desenvolvimento ao seu redor."


Introdução

Quando alguém fala em desenvolvimento ágil, Scrum, DevOps, Low-Code, No-Code ou Inteligência Artificial, normalmente imagina que essas tecnologias surgiram praticamente do nada.

Na realidade, muitas dessas ideias nasceram décadas antes.

Entre elas está o RAD (Rapid Application Development), metodologia criada para reduzir o tempo entre uma necessidade do negócio e a entrega de software funcionando.

Seu princípio continua extremamente atual.

Não desenvolver mais rápido.

Aprender mais rápido.

Para quem trabalha com COBOL e IBM Mainframe, compreender o RAD significa entender que velocidade nunca dependeu apenas da linguagem de programação. Ela depende principalmente da organização do trabalho, da automação, da participação do usuário e da capacidade de evoluir continuamente.

Esta série apresenta o RAD sob a ótica do profissional IBM Z, mostrando que seus princípios continuam mais vivos do que nunca.


O que você aprenderá nesta série

Ao longo dos três capítulos veremos:

  • a origem do RAD;

  • por que ele revolucionou a Engenharia de Software;

  • como implementar RAD na prática;

  • metodologias derivadas;

  • ferramentas clássicas e modernas;

  • integração com Low-Code, DevOps e IA;

  • aplicação em COBOL, CICS, DB2, IMS e IBM Z;

  • oportunidades profissionais para desenvolvedores Mainframe.


Capítulo 1 — O que é RAD e por que ele revolucionou o desenvolvimento de software

Resumo

O primeiro capítulo apresenta a história do Rapid Application Development, criado por James Martin em 1991.

Mostra o cenário da época, dominado pelo modelo Cascata (Waterfall), em que projetos levavam anos para serem concluídos e frequentemente chegavam ao usuário já desatualizados.

Também explica os quatro pilares do RAD:

  • desenvolvimento iterativo;

  • prototipação;

  • participação constante do usuário;

  • equipes pequenas e multidisciplinares.

O capítulo compara RAD com Waterfall e demonstra como suas ideias influenciaram praticamente todas as metodologias modernas.

Leia o capítulo completo:

👉 RAD (Rapid Application Development) – Parte 1: O Que Todo Programador COBOL Precisa Saber Sobre a Metodologia que Ensinou o Mundo a Desenvolver Software Rapidamente

https://eljefemidnightlunch.blogspot.com/2024/01/rad-rapid-application-development-o-que.html


Capítulo 2 — Como implementar RAD na prática

Resumo

Depois de entender os conceitos fundamentais, chega o momento de colocar o RAD em funcionamento.

Este capítulo apresenta um roteiro completo de implementação.

Você aprenderá:

  • como dividir projetos em pequenas entregas;

  • como montar equipes enxutas;

  • como construir protótipos;

  • como utilizar MVP (Minimum Viable Product);

  • como medir resultados;

  • indicadores de sucesso;

  • governança;

  • segurança;

  • documentação enxuta.

Também apresenta as metodologias influenciadas pelo RAD:

  • Scrum;

  • Extreme Programming (XP);

  • Lean Software Development;

  • DevOps;

  • Agile.

Além disso, faz um panorama das principais ferramentas RAD da história, como PowerBuilder, Delphi, Oracle Forms e GeneXus, chegando às plataformas atuais como Mendix, OutSystems, Power Apps, Oracle APEX e soluções baseadas em Inteligência Artificial.

Leia o capítulo completo:

👉 RAD (Rapid Application Development) – Parte 2: Como Implementar RAD na Prática, Principais Metodologias, Ferramentas e o Papel da Inteligência Artificial

https://eljefemidnightlunch.blogspot.com/2024/02/rad-rapid-application-development-como.html


Capítulo 3 — RAD no IBM Mainframe

Resumo

O terceiro capítulo aproxima definitivamente o RAD do universo IBM Z.

Mostra que o Mainframe nunca foi incompatível com desenvolvimento rápido.

Na verdade, muitos bancos já aplicavam práticas semelhantes ao RAD antes mesmo da popularização do Agile.

Entre os assuntos abordados estão:

  • RAD aplicado ao COBOL;

  • modularização;

  • COPYBOOKs;

  • reutilização;

  • APIs REST;

  • z/OS Connect;

  • CICS;

  • DB2;

  • IMS;

  • VSAM;

  • Git;

  • DevOps;

  • CI/CD;

  • testes automatizados;

  • observabilidade;

  • Inteligência Artificial aplicada ao código legado.

O capítulo também discute o futuro do desenvolvimento Mainframe e mostra como a combinação entre COBOL, IA e automação cria novas oportunidades para profissionais especializados em IBM Z.

Leia o capítulo completo:

👉 RAD (Rapid Application Development) – Parte 3: RAD no IBM Mainframe: Como Aplicar Desenvolvimento Rápido em COBOL sem Perder a Confiabilidade do IBM Z

https://eljefemidnightlunch.blogspot.com/2024/03/rad-rapid-application-development-rad.html


As principais lições da série

Ao final da leitura, fica evidente que o RAD nunca foi apenas uma metodologia para acelerar projetos.

Ele representa uma mudança de mentalidade.

Seus princípios continuam presentes em praticamente todas as práticas modernas de Engenharia de Software:

  • entregas incrementais;

  • feedback contínuo;

  • automação;

  • integração contínua;

  • testes automatizados;

  • prototipação;

  • foco no usuário;

  • redução de desperdícios;

  • melhoria contínua.

No ambiente IBM Mainframe, esses conceitos tornaram-se ainda mais relevantes graças à integração com APIs, Git, DevOps, z/OS Connect e Inteligência Artificial.

O desenvolvedor COBOL moderno não precisa abandonar décadas de conhecimento.

Precisa ampliar sua caixa de ferramentas.

Quanto mais automatizado for o processo, menor será o tempo entre uma ideia de negócio e sua implementação.

Esse sempre foi o verdadeiro objetivo do RAD.

Trinta anos depois, continua sendo uma das maiores lições da Engenharia de Software.


Próximas leituras recomendadas

Se você gostou desta série, acompanhe também os artigos do ☕ Um Café no Bellacosa Mainframe sobre:

  • DevOps para IBM Mainframe;

  • Low-Code para Programadores COBOL;

  • No-Code e Modernização;

  • Arquitetura Transformer para Mainframe;

  • Engenharia de Dados para Desenvolvedores COBOL;

  • CASE Tools;

  • APIs REST no IBM Z;

  • Inteligência Artificial aplicada ao COBOL;

  • Git e CI/CD no z/OS;

  • Modernização de aplicações IBM Z.

Esse artigo funciona como uma página pilar (Pillar Page) para SEO, concentrando a autoridade do tema RAD e distribuindo links para os três capítulos da série.


domingo, 4 de junho de 2023

Eu, Robô Entrou na Sala de Planning — O Dia em que a Dívida Técnica Pediu Prioridade e o Backlog Descobriu que Não Era Apenas uma Lista de Desejos

 

Bellacosa Mainframe e o planning do legado divida tecnica e backlog

☕ Um Café no Bellacosa Mainframe

Eu, Robô Entrou na Sala de Planning — O Dia em que a Dívida Técnica Pediu Prioridade e o Backlog Descobriu que Não Era Apenas uma Lista de Desejos



Ou: por que um programa COBOL antigo não é automaticamente culpado, por que um badge não compila um load module, e como evitar que VIKI controle o seu deploy de produção com RACF SPECIAL



Prólogo — “A mudança é pequena”, disse o ser humano antes de acordar os robôs

Em Eu, Robô, de 2004, a cidade parece um sonho de automação: carros autônomos, robôs domésticos, uma corporação tecnológica brilhando em Chicago e pessoas perfeitamente tranquilas por entregar tarefas importantes a máquinas educadas. Até que o detetive Del Spooner percebe que, quando todos dizem “o sistema funciona”, talvez seja a hora de verificar para quem ele funciona, como ele decide e o que acontece quando algo sai do roteiro.

No mainframe, não há robô humanoide carregando bandeja no CPD — embora alguns incidentes de sexta-feira à noite tenham talento para isso. Mas temos nossa própria versão de uma cidade automatizada: COBOL, CICS, Db2, IMS, MQ, RACF, JCL, VSAM, jobs batch, APIs, pipelines, dashboards e, agora, uma fila inteira de vendedores oferecendo IA capaz de “modernizar tudo” entre um café e uma apresentação de slides.

Foi nesse cenário que apareceu uma pergunta mais séria do que parece: onde entra a dívida técnica? Ela pode conviver com o backlog?

Pode. Na verdade, já convive. Às vezes mora escondida nele; às vezes mora fora dele e cobra aluguel em forma de incidente, atraso, retrabalho e uma pessoa-chave que ninguém deixa tirar férias. O perigo não é coexistirem. O perigo é fingir que são a mesma coisa — ou, pior, fingir que a dívida não existe porque o sistema ainda está processando a folha.

Vamos organizar a sala antes que VIKI, a inteligência central do filme, conclua que a maneira mais eficiente de reduzir erros é trancar todos os desenvolvedores em uma sala sem acesso ao SUBMIT.



1. O backlog não é um armário de pendências

Para o iniciante, backlog costuma soar como “a lista de coisas que ainda não fizemos”. É verdade, mas é pouco. Em um time saudável, backlog é uma fila priorizada de escolhas: o que fazer agora, o que adiar, o que investigar e o que conscientemente não faremos.

Uma demanda de negócio pode ser:

  • criar uma API para consultar limite;

  • adaptar cálculo de juros a uma regra regulatória;

  • incluir um novo tipo de transação CICS;

  • disponibilizar um extrato no aplicativo;

  • alterar o layout de um arquivo enviado a um parceiro.

Ela é visível para alguém fora da tecnologia. Pode virar receita, reduzir atrito do cliente, atender uma lei ou evitar multa. Quando o diretor olha o quadro, enxerga “PIX agendado”, “renegociação” ou “nova integração”.

Só que, atrás de cada cartão bonito, pode existir um pequeno exército de assuntos menos fotogênicos: copybook duplicado, programa de 8 mil linhas, tabela Db2 sem índice adequado, JCL copiado de 1997, senha fixa, teste manual, documentação ausente e um fluxo CICS–MQ–Db2 que só o senhor Arnaldo entende — e Arnaldo está pensando em pescar.

Isso é dívida técnica quando produz um custo concreto para mudar, testar, operar ou proteger o sistema.


2. Programa COBOL antigo não é sinônimo de dívida técnica

Aqui está a primeira armadilha. Há quem olhe um programa COBOL de 1989 e conclua: “legado; logo, dívida”. Não. A idade do código não é diagnóstico. Um programa pode ser antigo, estável, testado, documentado e barato de manter. Nesse caso ele é um ativo, não um cadáver tecnológico.

Por outro lado, um microsserviço criado há seis meses pode ser dívida gigantesca se ninguém entende suas dependências, se seus segredos estão em arquivo texto, se não há logs úteis e se cada deploy exige um ritual tribal.

Faça quatro perguntas simples:

  1. Uma mudança pequena leva muito mais tempo do que deveria?

  2. Conseguimos provar que a alteração não quebrou regras antigas?

  3. Há risco operacional, de segurança ou de auditoria conhecido?

  4. O conhecimento está concentrado em poucas pessoas?

Se a resposta for “sim” com frequência, há dívida. Não é opinião estética sobre linguagem. É custo observável.

Exemplo: o módulo COBOL FINC102 calcula juros. Ele funciona corretamente há anos, mas mistura leitura de VSAM, regras de negócio, formatação de relatório, chamadas Db2 e mensagens de erro numa única PROCEDURE DIVISION. Não existem testes automatizados. Cada alteração regulatória demora cinco dias porque três pessoas precisam conferir saídas manualmente.

O problema não é o PERFORM. O problema é que o custo de mudança ficou alto e a confiança ficou baixa.

3. A dívida técnica cobra juros — e o banco é o seu próprio sistema

A metáfora de dívida é boa porque ela não descreve apenas algo “feio”. Descreve um compromisso que cobra juros com o tempo.

Você pode assumir uma dívida conscientemente. Uma equipe precisa atender uma mudança urgente no fechamento mensal e entrega uma solução provisória bem marcada, com risco avaliado e data para revisão. Isso pode ser aceitável. É como usar um desvio na estrada porque a ponte caiu.

O problema é chamar o desvio de rodovia definitiva durante quinze anos.

Os juros aparecem assim:

  • mais tempo para analisar impacto;

  • mais defeitos em produção;

  • dependência de especialistas específicos;

  • testes demorados e manuais;

  • janelas batch maiores;

  • dificuldade para integrar APIs;

  • falhas de segurança;

  • retrabalho em auditoria;

  • modernizações caras porque ninguém sabe por onde começar.

No mainframe, os juros podem ser especialmente silenciosos. O job continua fechando. O CICS continua respondendo. O Db2 continua guardando a informação. Até o dia em que uma alteração de três linhas em um copybook muda o layout de vinte programas e nasce um S0C7 internacional.

Easter egg para quem já viveu produção: o arquivo não “deu problema sozinho”. Alguém mudou um campo PIC 9(7)V99 e esqueceu que o programa vizinho tratava aquilo como PIC 9(5)V99. O robô não se rebelou; ele apenas executou com precisão a confusão que entregamos a ele.

4. Dívida técnica e backlog: irmãos, não gêmeos

A convivência correta é esta:

FilaPergunta que respondeExemplo
ProdutoO que o negócio precisa obter?Criar API de renegociação
EngenhariaO que torna a entrega segura e repetível?Testar cálculo COBOL e automatizar build/bind
Risco e operaçãoO que não pode continuar exposto?Remover acesso RACF excessivo

Na prática, elas podem estar no mesmo produto de backlog, desde que tenham etiqueta, dono, prioridade e critério de aceite distintos. Não esconda uma história de segurança atrás de “melhoria geral”, nem venda uma refatoração como “transformação digital” sem explicar o benefício.

Uma boa história técnica não diz apenas:

Refatorar FINC102.

Ela diz:

Separar a regra de cálculo de juros do acesso a dados e criar testes de regressão, reduzindo de cinco dias para um dia o prazo de mudança regulatória e permitindo comparar o resultado antes e depois da implantação.

Agora há problema, resultado e evidência. O gerente entende por que existe trabalho. O programador entende o alvo. A operação sabe o que deverá melhorar.

5. Quando a dívida vira parte obrigatória da história de produto

Há casos em que a dívida não deve esperar uma “sprint de arrumação”. Ela é dependência direta da entrega.

Imagine que o banco quer expor uma transação COBOL como API REST. A apresentação comercial diz “basta usar z/OS Connect”. E, sim, ferramentas de integração ajudam bastante. Mas antes da API, há perguntas nada cinematográficas:

  • a rotina COBOL possui contrato claro de entrada e saída?

  • campos binários, decimais e datas foram definidos sem ambiguidade?

  • erros de negócio são diferentes de ABEND técnico?

  • existe autenticação e autorização coerentes?

  • segredos não estão hardcoded?

  • há limite de volume e timeout?

  • conseguimos rastrear a chamada do celular até CICS, MQ e Db2?

  • há teste de regressão?

Se a resposta for “não”, criar a API sem tratar parte da dívida é colocar um portal novo na frente de uma casa com a fiação exposta. A história de engenharia deixa de ser opcional: ela compõe o próprio requisito de pronto.

6. O backlog real do mainframe moderno

O infográfico da conversa acertou no alvo ao dizer que a plataforma precisa ser mais fácil de engenheirar, não apenas mais fácil de admirar. O backlog real inclui coisas que raramente fazem sucesso em evento, mas salvam projetos:

Ambientes reproduzíveis

O iniciante não deveria depender de “fale com fulano para ele liberar a biblioteca” para executar o primeiro teste. Nem sempre será possível entregar uma LPAR inteira por pessoa, claro. Mas é possível oferecer sandboxes controlados, dados mascarados, scripts versionados, laboratórios, mocks de serviços externos e documentação executável.

Ambiente reproduzível significa que duas pessoas conseguem montar condições equivalentes para testar a mesma alteração. Menos magia; mais procedimento.

Build, teste, bind e deploy automatizados

COBOL com Db2 não termina no compile. Há precompile, compilação, link-edit e bind. Dependendo da aplicação, há CICS, copybooks, load modules, DBRMs, planos e packages. Automatizar esse fluxo reduz erro humano e torna a evidência rastreável.

O objetivo não é apertar um botão azul e esquecer que existe mainframe. É substituir passos repetitivos por processos verificáveis, para que a inteligência humana fique onde importa: analisar regra, risco, desempenho e impacto.

Observabilidade híbrida

Um cliente não sabe se o problema veio de CICS, Db2, MQ, WLM, rede ou aplicativo móvel. Ele sabe que sua transação falhou.

Por isso, telemetria e correlação são dívida a atacar quando cada equipe enxerga apenas seu quadrado. Logs, métricas, traces, SMF/RMF e eventos de negócio devem ajudar a seguir uma transação ponta a ponta.

Segurança para automação e IA

Um assistente de IA pode resumir logs, sugerir JCL, gerar testes e localizar dependências. Excelente. Mas ele não pode receber uma credencial poderosa e liberdade para “resolver” produção.

A regra é simples: identidade de workload, privilégio mínimo, segredos protegidos, credenciais curtas, aprovação humana em ações sensíveis, logs auditáveis e kill switch. VIKI tinha uma visão centralizada demais do bem comum. Não deixe seu agente de IA ter a mesma personalidade administrativa.

7. Badges não são vilões; métricas vazias, sim

O cartaz também provocava o chamado “badge theater”. Convém ser justo: certificações, badges, eventos e advocates podem abrir portas, incentivar estudo e tornar o mainframe visível para quem nunca considerou a carreira. Uma aula em português, uma palestra acessível ou uma comunidade acolhedora têm valor enorme.

Mas certificado não é substituto de capacidade operacional. Ele não prova, sozinho, que alguém sabe investigar uma espera Db2, recuperar um batch, interpretar um ICH408I, calcular impacto de copybook ou decidir rollback no meio de um incidente.

Use métricas de comunidade, sim — mas acompanhe evidências de engenharia:

  • tempo para o primeiro deploy seguro;

  • porcentagem de mudanças com teste automatizado;

  • tempo de recuperação de incidentes;

  • redução de falhas após implantação;

  • número de fluxos documentados e reproduzíveis;

  • quantidade de profissionais capazes de executar uma tarefa sem depender de um único guru.

Badge é diploma de passagem. Engenharia é conseguir atravessar a ponte quando chove.

8. Um roteiro prático para o programador COBOL iniciante

Se você entrou agora no mundo IBM Z, não tente quitar toda a dívida do planeta. Comece como Spooner investigando uma cena: observe, reúna evidências e faça perguntas boas.

  1. Mapeie um fluxo pequeno. Pegue uma transação ou job. Descubra entrada, programa COBOL, copybooks, arquivos, tabelas Db2, saída e dono operacional.

  2. Ache um ponto doloroso mensurável. Pode ser um teste manual de duas horas, uma falha recorrente ou uma alteração que exige três pessoas.

  3. Registre causa, impacto e risco. “JCL feio” não basta. “O job usa credencial fixa e impede rotação de senha sem intervenção manual” é uma dívida clara.

  4. Transforme em item de backlog. Defina benefício, prioridade, dono e critério de pronto.

  5. Automatize uma coisa repetitiva. Um teste, uma validação de layout, uma comparação de arquivos, uma checagem de RC, um relatório REXX. Pequeno e útil vence grande e vago.

  6. Preserve o conhecimento. Documente decisão, exceção e recovery. A documentação ideal ajuda alguém às 3h da manhã, não apenas na auditoria de terça-feira.

  7. Meça o resultado. Reduziu tempo? Evitou erro? Diminuiu dependência? Se não houve efeito, revise a hipótese.

9. A terceira lei do backlog

As Três Leis da Robótica, no filme, prometem proteção. Mas a trama mostra que regras bem-intencionadas, interpretadas sem contexto humano, podem produzir desastre. Backlog também sofre disso.

Uma organização pode decidir: “sempre entregar funcionalidade primeiro”. Parece pró-cliente. Porém, se ignora testes, segurança, recuperação e capacidade, termina prejudicando o cliente no incidente seguinte.

Outra pode decidir: “vamos parar tudo para refatorar”. Parece responsável. Porém, se não conecta a melhoria a risco, custo e necessidade de negócio, perde apoio e cria uma reforma eterna.

Minha terceira lei informal do backlog seria:

Nenhuma entrega deve aumentar o risco do sistema sem tornar explícito quem pagará os juros depois.

Isso obriga conversa adulta. Às vezes a resposta será “aceitamos o atalho e abrimos item com prazo”. Outras vezes será “não sobe sem teste, recovery ou ajuste de segurança”. Ambas são decisões legítimas se forem conscientes e documentadas.

Conclusão — o futuro não precisa exterminar o passado

O mainframe não precisa virar uma imitação de cloud, nem o COBOL precisa pedir desculpas por continuar útil. O que ele precisa é de uma ponte entre sua maturidade e a maneira como engenheiros modernos trabalham.

Essa ponte tem Git, APIs, pipelines, testes, observabilidade, automação, identidade forte e aprendizagem acessível. Mas também tem WLM, I/O, RACF, recovery, consistência transacional, Db2, CICS, JCL e a humildade de entender que sistemas críticos não ficam simples só porque receberam uma interface nova.

Dívida técnica e backlog convivem porque o futuro desejado e o passado acumulado usam a mesma capacidade do time. O segredo não é escolher um contra o outro. É tornar o custo visível, priorizar por risco e valor, e entregar melhorias pequenas que tornem a próxima mudança mais segura do que a anterior.

Quando alguém disser “é só uma pequena alteração”, respire, peça o impacto, verifique o copybook, confira o teste, olhe o RACF e faça a pergunta que Del Spooner faria:

“O sistema está obedecendo às regras… ou nós apenas esquecemos de perguntar quais regras ele realmente está seguindo?”

Porque no mainframe, meu caro padawan do COBOL, não existe robô malvado por natureza. Existe automação sem contexto, dívida sem dono e um RC=0 que talvez não signifique aquilo que todo mundo queria ouvir.



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