Translate

Mostrar mensagens com a etiqueta Dívida Técnica. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Dívida Técnica. Mostrar todas as mensagens

domingo, 28 de junho de 2026

Backlog: O Dataset Invisível que Pode Salvar ou Destruir um Projeto Mainframe

 

Bellacosa Mainframe e o conceito do backlog na stack mainframe

☕ Um Café no Bellacosa Mainframe

Backlog: O Dataset Invisível que Pode Salvar ou Destruir um Projeto Mainframe

"No mundo IBM Z, um programa COBOL raramente quebra por causa de uma linha de código. Quase sempre ele quebra porque existe um backlog que ninguém quis enxergar."

Existe uma palavra que todo profissional de TI escuta diariamente: Backlog.

Ela aparece em reuniões ágeis, em SCRUM, em Kanban, nos relatórios do gerente, nos dashboards do Jira e até em apresentações do CIO.

Mas curiosamente, poucos programadores COBOL entendem o verdadeiro significado do backlog.

Para um Padawan Mainframe, backlog costuma parecer apenas uma lista enorme de tarefas.

Na realidade, backlog é muito mais parecido com um dataset VSAM KSDS.

Ele armazena tudo que ainda precisa ser processado.

Se ele estiver organizado, o sistema flui.

Se estiver corrompido...

Você acabou de criar o próximo ABEND da equipe.


Imagine um Batch Noturno

Pense em um JOB executando durante a madrugada.

Ele possui:

  • milhares de registros

  • prioridades

  • dependências

  • checkpoints

  • reprocessamentos

Agora substitua os registros por atividades.

Pronto.

Você acabou de entender o backlog.

O backlog é simplesmente o conjunto de trabalho que ainda será executado.

Mas existe uma diferença enorme entre:

muito trabalho

e

backlog saudável.


O Backlog Não É o Problema

O backlog é inevitável.

Todo sistema vivo possui backlog.

Até o z/OS trabalha com filas.

JES2 possui filas.

CICS possui filas.

MQ possui filas.

IMS possui filas.

DB2 possui locks esperando.

Tudo funciona através de filas.

O problema nunca foi possuir backlog.

O problema é possuir um backlog que ninguém entende.


Como Nasce um Backlog

Imagine um sistema bancário.

Hoje o gerente pede:

Criar PIX.

Depois:

alterar TED.

Depois:

corrigir boleto.

Depois:

adequação ao Banco Central.

Depois:

LGPD.

Depois:

Open Finance.

Depois:

PIX Automático.

Depois:

IA.

Depois:

APIs REST.

Cada solicitação entra.

Nem todas saem.

O resultado?

Um backlog crescente.


O Backlog Invisível

O pior backlog é o invisível.

Ele mora em frases como:

"Depois a gente vê."

"Na próxima Sprint."

"Isso fica para outro momento."

"É uma melhoria."

"Não é urgente."

Meses depois...

Existem centenas delas.


Backlog Técnico

Nem todo backlog é funcional.

Existe também:

  • melhoria de performance

  • reorganização de programas

  • limpeza de código

  • documentação

  • atualização de COPYBOOKS

  • reorganização DB2

  • índices

  • compressão VSAM

  • testes

Tudo isso entra no backlog.


Como Identificar um Backlog Doente

Um backlog começa a adoecer quando aparecem sintomas.

Sintoma 1

Todo mundo pergunta:

"O que devemos fazer agora?"

Isso significa ausência de prioridade.


Sintoma 2

Existem tarefas de três anos atrás.

Se ninguém fez em três anos...

Talvez nunca devesse existir.


Sintoma 3

Existem tarefas duplicadas.

Muito comum.

Um analista abre:

"Corrigir cálculo."

Outro abre:

"Ajustar juros."

Outro:

"Problema financeiro."

São o mesmo erro.


Sintoma 4

Ninguém sabe explicar a tarefa.

Descrição:

"Verificar erro."

Qual erro?

Onde?

Quando?

Por quê?


Sintoma 5

Todo item é prioridade máxima.

Quando tudo é urgente...

Nada é urgente.


Como um Programador COBOL Deve Ler um Backlog

Nunca leia apenas o título.

Leia:

  • requisito

  • regra de negócio

  • programas envolvidos

  • COPYBOOKS

  • arquivos

  • tabelas DB2

  • transações CICS

  • JCL

  • impacto

A tarefa começa muito antes do código.


O Erro do Padawan

O Padawan pensa:

"Recebi uma tarefa."

O profissional experiente pensa:

"Recebi um problema de negócio."

Isso muda tudo.


Como Evoluir um Backlog

Existe uma prática chamada:

Backlog Refinement

Ou refinamento.

No Mainframe isso seria parecido com preparar um JOB antes da produção.

Você elimina ambiguidades.


Durante o refinamento fazemos perguntas.

O usuário realmente quer isso?

Existe impacto financeiro?

Existe impacto jurídico?

Existe cálculo?

Existe histórico?

Existe rollback?

Existe auditoria?

Existe logging?

Existe batch?

Existe online?

Existe integração?


Quanto mais perguntas...

Menor o risco.


Um Backlog Não Deve Crescer Para Sempre

Imagine um dataset.

Se ninguém fizer housekeeping...

Ele cresce.

Depois cresce.

Depois cresce.

Depois o volume explode.

Depois aparece:

SPACE ABEND

O backlog também.


Como Priorizar

Uma técnica simples.

Divida em quatro grupos.

Incêndio

Sistema parado.


Financeiro

Pode gerar prejuízo.


Cliente

Afeta usuários.


Melhoria

Pode esperar.


A maioria dos times mistura tudo.


Backlog e COBOL

Um programa COBOL raramente possui apenas uma alteração.

Quando você abre um fonte...

Encontra:

Alteração 2003

Alteração 2006

Alteração 2009

Alteração 2014

Alteração 2018

Alteração 2021

Alteração 2025

Cada comentário representa um backlog encerrado.

O código conta a história da empresa.


O Backlog Bom

Possui:

✔ descrição

✔ prioridade

✔ responsável

✔ impacto

✔ dependência

✔ prazo

✔ critério de aceite

✔ documentação


O Backlog Ruim

Descrição:

"Ajustar."

Boa sorte.


A Grande Diferença Entre Backlog e Dívida Técnica

Muita gente mistura.

Mas são conceitos completamente diferentes.

Backlog

É trabalho conhecido.

Sabemos que precisa ser feito.

Está registrado.

Está visível.

Pode ser priorizado.


Dívida Técnica

É trabalho escondido.

Você decidiu fazer algo mais rápido.

Agora pagará juros.


Imagine um empréstimo.

Você compra uma casa.

Ainda deve dinheiro.

A casa existe.

Mas existe dívida.

No software é igual.


Exemplo.

Você precisava entregar uma alteração.

O correto seria:

  • modularizar

  • criar testes

  • atualizar documentação

Mas o prazo era curto.

Você fez um IF gigantesco.

Funcionou.

Pronto.

Nasceu uma dívida técnica.


Backlog Pode Não Ser Dívida

Exemplo.

Nova funcionalidade PIX.

Ela nunca existiu.

Está no backlog.

Não existe dívida.

É apenas trabalho futuro.


Dívida Técnica Pode Não Estar no Backlog

Muito comum.

Todo mundo sabe que existe.

Ninguém registra.

Ninguém fala.

Até o dia em que explode.


Como Identificar Dívida Técnica

Pergunte:

"Se eu tivesse mais tempo...

faria diferente?"

Se a resposta for SIM...

Existe dívida técnica.


Os Juros da Dívida Técnica

Assim como um banco cobra juros...

O software também.

Cada alteração demora mais.

Cada teste demora mais.

Cada deploy gera medo.

Cada manutenção aumenta.


Dívida Técnica no Mainframe

Exemplos.

Programa COBOL com:

12000 linhas.

Sem PERFORM.

GO TO para todos os lados.

COPYBOOK repetido.

Campos duplicados.

Comentários de 1998.

Variáveis mortas.

Parágrafos nunca chamados.

SQL repetido.

MOVE desnecessário.

PERFORM THROUGH gigantesco.

Tudo isso gera dívida.


Como Corrigir

Nunca tente pagar toda a dívida de uma vez.

Faça igual um financiamento.

Pague parcelas.

Sempre que alterar um programa:

melhore um pouco.

Renomeie variáveis.

Remova código morto.

Atualize comentários.

Crie testes.

Melhore SQL.

Refatore pequenos blocos.


A Regra do Escoteiro

Robert C. Martin criou uma regra famosa.

Deixe o código melhor do que encontrou.

No Mainframe ela é perfeita.


Backlog Funcional

Pedido do negócio.


Backlog Técnico

Pedido da TI.


Backlog Arquitetural

Mudanças estruturais.

Exemplos.

Migrar VSAM.

Migrar CICS.

Atualizar COBOL.

Atualizar compilador.

Migrar DB2.

Atualizar RACF.


O Backlog Nunca Acaba

Isso assusta iniciantes.

Mas é normal.

Software vivo nunca termina.

Ele evolui.


Curiosidade Mainframe nº 1

Nos anos 70 ninguém dizia "Backlog".

Chamavam de:

Pending Requests

Programming Queue

Change Queue

Maintenance Queue

A palavra backlog ficou popular muito depois com métodos ágeis.


Curiosidade nº 2

Em muitos bancos brasileiros ainda existem planilhas Excel paralelas ao Jira.

Sim.

O backlog oficial nem sempre é o verdadeiro.


Curiosidade nº 3

Algumas empresas possuem backlog maior que o código.

Há milhares de demandas abertas.

Mas apenas algumas centenas realmente serão desenvolvidas.


Curiosidade nº 4

O maior inimigo do backlog não é a falta de programadores.

É a falta de decisão.


Curiosidade nº 5

Muitos ABENDs históricos aconteceram porque uma melhoria pequena ficou anos esquecida.

Quando finalmente foi feita...

Ninguém mais entendia o motivo original.


Easter Egg IBM Z

Você já percebeu?

O JES2 organiza trabalhos.

O MQ organiza mensagens.

O CICS organiza transações.

O DB2 organiza dados.

O RACF organiza permissões.

O backlog organiza pessoas.

No fundo...

Todo o ecossistema IBM Z é baseado em gerenciamento de filas.


Easter Egg COBOL

O comando:

NEXT SENTENCE

parece simples.

Mas ele simboliza exatamente muitos backlogs.

Você pula para frente sem realmente resolver o problema.

Funciona.

Até deixar de funcionar.


Easter Egg DB2

Um índice mal planejado gera consultas lentas.

Um backlog mal priorizado gera equipes lentas.

Os dois possuem exatamente o mesmo problema:

falta de organização.


Easter Egg CICS

Em CICS existe o conceito de resposta rápida.

O usuário não pode esperar.

No backlog também.

Quanto mais tempo uma tarefa fica parada...

Maior a chance de perder contexto.


Easter Egg JCL

Imagine um JOB.

STEP010

STEP020

STEP030

STEP040

Existe ordem.

Existe dependência.

Existe fluxo.

Um backlog deveria funcionar exatamente assim.


Easter Egg VSAM

Um KSDS desorganizado sofre mais splits.

Uma equipe desorganizada sofre mais interrupções.


Easter Egg RACF

No RACF, tudo segue o princípio do menor privilégio.

No backlog, vale um princípio parecido:

o menor item possível.

Histórias pequenas fluem melhor do que demandas gigantescas.


O Conselho Final para Todo Padawan COBOL

Quando você entrar em um projeto Mainframe, não olhe apenas para o código-fonte. Observe a saúde do backlog. Um programa de 30 anos pode ser surpreendentemente fácil de manter se houver um backlog bem organizado, prioridades claras e comunicação constante entre negócio e tecnologia. Por outro lado, um sistema moderno pode se tornar um pesadelo quando acumula tarefas mal descritas, prioridades conflitantes e dívida técnica ignorada.

Aprenda a fazer perguntas antes de programar. Entenda a regra de negócio antes de abrir o editor COBOL. Documente suas descobertas, refine as histórias, questione requisitos ambíguos e aproveite cada manutenção para deixar o código um pouco melhor do que estava. Essa disciplina, repetida diariamente, transforma um Padawan em um verdadeiro Mestre Mainframe.

No universo IBM Z, backlog é o mapa da jornada, enquanto a dívida técnica é o peso que você carrega na mochila. O mapa pode crescer à medida que novos caminhos surgem, mas o peso só aumenta quando atalhos mal planejados são tomados. Os melhores profissionais aprendem a equilibrar os dois: mantêm um backlog claro, vivo e priorizado, enquanto pagam pequenas parcelas da dívida técnica a cada entrega.

No fim das contas, a maior lição é simples: software não é apenas código; é uma fila contínua de decisões. Assim como o JES2 coordena jobs, o CICS gerencia transações e o DB2 organiza dados, um bom desenvolvedor organiza seu trabalho, seu conhecimento e sua evolução. É essa capacidade de transformar caos em ordem que diferencia um programador que apenas entrega tarefas de um engenheiro que constrói sistemas capazes de sobreviver por décadas — exatamente como os grandes ambientes IBM Z que continuam sustentando bancos, seguradoras, governos e empresas em todo o mundo.


quarta-feira, 3 de junho de 2026

☕💣📋 HOW TO PAY BACK TECHNICAL DEBT — O DIA EM QUE O PROGRAMADOR COBOL DESCOBRIU QUE ESTAVA PAGANDO JUROS POR UMA DECISÃO TOMADA EM 1998

 

Bellacosa Mainframe como pagar dividas tecnicas em mainframe



☕💣📋 HOW TO PAY BACK TECHNICAL DEBT — O DIA EM QUE O PROGRAMADOR COBOL DESCOBRIU QUE ESTAVA PAGANDO JUROS POR UMA DECISÃO TOMADA EM 1998

Existe uma frase muito conhecida no mercado de tecnologia:

"Toda empresa tem dívida técnica. Algumas apenas ainda não receberam a cobrança."

Para um programador COBOL Mainframe júnior, a expressão "dívida técnica" parece algo moderno, criado por arquitetos ágeis, consultores de transformação digital ou gurus do DevOps.

Mas a verdade é muito mais divertida.

Muito antes de alguém inventar Scrum, Kanban, DevOps, GitHub ou Microservices, os programadores COBOL já acumulavam dívida técnica sem saber.

Toda vez que alguém dizia:

"Depois a gente arruma."

Nascia uma nova parcela.

E em muitos ambientes z/OS, ainda estamos pagando prestações de decisões tomadas há 20 ou 30 anos.

Pegue seu café porque hoje vamos entender como identificar, medir, controlar e pagar dívida técnica sem derrubar a produção.


O QUE É DÍVIDA TÉCNICA?

A definição mais simples é:

Dívida técnica é o custo futuro criado por uma decisão técnica tomada para resolver um problema rapidamente hoje.

Imagine um programa COBOL.

Você precisa entregar uma alteração urgente.

O correto seria:

  • Revisar arquitetura

  • Atualizar documentação

  • Criar testes

  • Refatorar módulos

Mas o prazo é amanhã.

Então alguém faz:

IF CLIENTE = '999999'
    GO TO TRATAMENTO-ESPECIAL.

Entrega.

Produção funciona.

Cliente feliz.

Projeto encerrado.

Mas daqui a dois anos ninguém lembra por que aquele IF existe.

A dívida nasceu.


O MAIOR MITO DO MAINFRAME

Muita gente acredita que:

"Código antigo é dívida técnica."

Errado.

Código antigo pode ser excelente.

Existem programas COBOL escritos nos anos 80 que ainda hoje são exemplos de engenharia.

Por outro lado, existem programas escritos há seis meses que já nasceram endividados.

A idade do código não importa.

O que importa é:

  • Complexidade

  • Manutenibilidade

  • Clareza

  • Testabilidade

  • Documentação


COMO IDENTIFICAR DÍVIDA TÉCNICA

O primeiro passo é aprender a enxergá-la.

Alguns sintomas clássicos:

Programa que ninguém quer alterar

Quando uma demanda chega e todos falam:

"Tomara que não seja naquele programa..."

Existe dívida.


Alteração simples demora dias

Mudança:

Trocar 20 para 25.

Tempo gasto:

3 dias

Existe dívida.


Muitos abends

Se o mesmo módulo gera incidentes frequentemente:

  • S0C7

  • S0C4

  • SQLCODE negativos

  • Arquivos inconsistentes

Existe dívida.


Dependência de especialistas

Quando apenas uma pessoa entende o sistema.

Isso é uma dívida técnica humana.

Extremamente perigosa.


A METÁFORA DO CARTÃO DE CRÉDITO

A IBM utiliza uma analogia excelente.

Imagine um cartão.

Você compra algo hoje.

O benefício é imediato.

O pagamento fica para depois.

Dívida técnica funciona igual.

Benefício imediato:

Entreguei no prazo

Pagamento futuro:

Mais manutenção
Mais defeitos
Mais testes
Mais retrabalho

O problema não é usar o cartão.

O problema é esquecer da fatura.


COMO MAPEAR A DÍVIDA TÉCNICA

A primeira atividade prática é criar um inventário.

Monte uma planilha contendo:

SistemaProblemaImpactoPrioridade
CadastroGO TO excessivoMédioMédia
CobrançaSem documentaçãoAltoAlta
FaturamentoAlta complexidadeAltoAlta

Você não consegue corrigir aquilo que não consegue enxergar.


MÉTRICA 1 – COMPLEXIDADE CICLOMÁTICA

Uma das métricas mais famosas.

Ela mede quantos caminhos lógicos existem em um programa.

Exemplo:

IF A
   ...
ELSE
   ...
END-IF

Pouca complexidade.

Agora imagine:

IF A
 IF B
  IF C
   IF D

A complexidade explode.

Quanto maior a complexidade:

  • Mais difícil testar

  • Mais difícil manter

  • Maior risco de erro

Regra prática:

ValorSituação
1 a 10Boa
11 a 20Atenção
Acima de 20Risco

MÉTRICA 2 – TEMPO DE MANUTENÇÃO

Métrica simples.

Quanto tempo leva para implementar uma mudança?

Exemplo:

Alteração simples:

4 horas

Virou:

3 dias

A dívida está cobrando juros.


MÉTRICA 3 – QUANTIDADE DE INCIDENTES

Monitore:

  • Chamados

  • Tickets

  • Problemas recorrentes

Se determinado programa gera:

20% dos incidentes

Ele deve entrar imediatamente no backlog técnico.


MÉTRICA 4 – COBERTURA DE TESTES

Quanto do sistema possui testes?

Exemplo:

10%

Muito arriscado.

80%

Muito saudável.

No mundo COBOL isso pode envolver:

  • Unit Test

  • Testes automatizados

  • Batch Validation


MÉTRICA 5 – TEMPO MÉDIO DE RECUPERAÇÃO

MTTR

Mean Time To Recovery.

Quanto tempo leva para resolver um problema?

Exemplo:

10 minutos

Excelente.

8 horas

Existe forte dívida técnica.


A REGRA DOS 20%

Uma prática muito utilizada é reservar:

80% desenvolvimento
20% redução de dívida técnica

Isso impede que a dívida cresça infinitamente.


TÉCNICA 1 – REFATORAÇÃO CONTÍNUA

Refatorar significa melhorar sem alterar comportamento.

Exemplo:

Antes:

GO TO ERRO.
GO TO ERRO.
GO TO ERRO.

Depois:

PERFORM TRATA-ERRO.

Mesmo resultado.

Código mais limpo.


TÉCNICA 2 – MODULARIZAÇÃO

Programas gigantes são fábricas de dívida.

Já encontrei programas com:

80.000 linhas

Divida responsabilidades.

Crie módulos menores.

Mais simples de entender.

Mais simples de testar.


TÉCNICA 3 – DOCUMENTAÇÃO VIVA

Documentação morta é inútil.

Documentação viva é atualizada junto com o sistema.

Documente:

  • Fluxos

  • Arquivos

  • Tabelas

  • Regras de negócio


TÉCNICA 4 – ELIMINAÇÃO DE CÓDIGO MORTO

Existe um cemitério escondido em todo sistema.

Trechos como:

IF FLAG = 'X'

Que nunca mais executam.

Remover código morto reduz:

  • Complexidade

  • Risco

  • Tempo de manutenção


TÉCNICA 5 – BACKLOG TÉCNICO

Crie um backlog específico.

Exemplo:

Remover GO TO
Documentar módulo
Automatizar teste
Eliminar código morto

A dívida precisa aparecer oficialmente.

Caso contrário ela nunca será priorizada.


FERRAMENTAS ÚTEIS NO MUNDO MAINFRAME

IBM Application Discovery

Mapeia dependências.

Mostra:

  • Programas

  • Arquivos

  • CICS

  • DB2

Excelente para arqueologia de sistemas.


IBM ADDI

Application Discovery and Delivery Intelligence.

Permite visualizar relacionamentos invisíveis.

Muito útil para sistemas legados.


SonarQube

Mesmo para COBOL.

Detecta:

  • Complexidade

  • Duplicação

  • Código suspeito


IBM Developer for z/OS

Auxilia:

  • Navegação

  • Análise

  • Refatoração


Jira

Controle de backlog técnico.

Muitas empresas utilizam para registrar dívida técnica.


EASTER EGG MAINFRAME

Quer descobrir rapidamente onde existe dívida?

Procure:

GO TO
ALTER
NEXT SENTENCE

Ou:

STEP099
STEP100
STEP101

Sem documentação.

Você provavelmente encontrou um sítio arqueológico corporativo.


O ERRO MAIS COMUM DOS JUNIORES

Pensar:

"Vou reescrever tudo."

Não.

Esse é o caminho para o desastre.

A melhor estratégia quase sempre é:

Pequenas melhorias contínuas.

Todo dia.

Toda sprint.

Todo projeto.

Toda manutenção.


COMO EVOLUIR COMO PROFISSIONAL

Programadores experientes não são aqueles que escrevem mais código.

São aqueles que reduzem complexidade.

Quando você consegue olhar para um sistema e dizer:

"Esse trecho vai gerar problema daqui a dois anos."

Você começou a pensar como arquiteto.


O SEGREDO DOS MELHORES ANALISTAS DE SISTEMAS

Eles não combatem apenas bugs.

Eles combatem as causas dos bugs.

Essa é a diferença entre apagar incêndios e construir sistemas duradouros.


CONCLUSÃO

Dívida técnica não é um defeito.

Ela é uma ferramenta.

Em alguns momentos vale a pena assumir a dívida para entregar rapidamente.

O problema surge quando ninguém controla o saldo.

O programador COBOL júnior que aprender a:

  • Identificar dívida

  • Medir dívida

  • Priorizar dívida

  • Reduzir dívida

  • Monitorar dívida

Terá uma visão muito mais próxima de um arquiteto de sistemas do que de um simples codificador.

Porque no fim das contas, o maior segredo do Mainframe não é fazer programas funcionarem.

É garantir que eles continuem funcionando daqui a 30 anos sem que alguém precise vender a alma para entender por quê.



terça-feira, 2 de junho de 2026

☕💣📋 DÍVIDA TÉCNICA NO MAINFRAME — O EMPRÉSTIMO QUE VOCÊ FEZ EM 1998 E AINDA ESTÁ PAGANDO COM JUROS EM 2026

 

Bellacosa Mainframe divida tecnica decisões erradas que pagamos até hoje


☕💣📋 DÍVIDA TÉCNICA NO MAINFRAME — O EMPRÉSTIMO QUE VOCÊ FEZ EM 1998 E AINDA ESTÁ PAGANDO COM JUROS EM 2026

Existe uma lenda antiga nos CPDs.

Ela diz que, em algum lugar do ambiente de produção, existe um programa COBOL que ninguém entende.

Ninguém sabe quem escreveu.

Ninguém sabe por que funciona.

Ninguém sabe o que acontece se ele parar.

Mas todos sabem de uma coisa:

ninguém tem coragem de mexer nele.

Se você trabalha em Mainframe há algum tempo, provavelmente já encontrou um desses.

Talvez ele tenha 30 mil linhas.

Talvez possua 700 GO TO.

Talvez utilize arquivos VSAM que nem aparecem mais na documentação.

Talvez tenha comentários escritos por alguém que já se aposentou há vinte anos.

E talvez ele continue processando milhões de reais por dia.

Parabéns.

Você acabou de encontrar um dos sintomas mais clássicos da dívida técnica.


O QUE É DÍVIDA TÉCNICA?

O termo foi criado por Ward Cunningham.

A ideia é simples.

Você faz uma escolha rápida hoje para ganhar velocidade.

Em troca, aceita que precisará corrigir aquilo futuramente.

É exatamente igual a um empréstimo bancário.

Você recebe um benefício imediato.

Mas depois paga juros.

No software, os juros aparecem na forma de:

  • retrabalho;

  • manutenção mais lenta;

  • defeitos;

  • incidentes;

  • dificuldade de evolução;

  • dependência de especialistas.

O problema é que muitas empresas pegam esse empréstimo todos os dias.

E quase nunca pagam.


O DIA EM QUE O SISTEMA COMEÇA A COBRAR JUROS

Imagine um programador COBOL júnior.

Recebe uma demanda urgente.

Precisa incluir um novo código de operação.

O correto seria:

  • revisar regras;

  • criar módulo reutilizável;

  • atualizar documentação;

  • executar testes.

Mas o prazo está apertado.

Então ele faz:

IF COD-OPER = '99'
   MOVE 'S' TO FLAG-ESPECIAL
END-IF.

Entrega.

Funciona.

Todos ficam felizes.

Seis meses depois surge:

Operação 98.

Depois 97.

Depois 96.

Quando alguém percebe, existe:

IF COD-OPER = '99'
OR COD-OPER = '98'
OR COD-OPER = '97'
OR COD-OPER = '96'

O programa continua funcionando.

Mas ficou pior.

Essa diferença entre funcionar e ser saudável é onde mora a dívida técnica.


COMO IDENTIFICAR DÍVIDA TÉCNICA

Os sinais são sempre parecidos.

1. Programas gigantes

Quando um COBOL possui:

  • 10 mil linhas;

  • 20 mil linhas;

  • 50 mil linhas;

ninguém consegue compreender tudo.

Complexidade gera risco.


2. Dependência de uma única pessoa

Quando você ouve:

"Somente o João conhece esse sistema."

Acenda o alerta vermelho.

O João pode tirar férias.

O João pode mudar de empresa.

O João pode se aposentar.

O sistema precisa sobreviver sem heróis.


3. Medo de alterar

Se toda mudança gera receio:

"Vamos torcer para não derrubar produção."

Existe dívida técnica.


4. Muitas correções

Quando a equipe passa mais tempo corrigindo do que evoluindo.

O sistema está pagando juros elevados.


AS PRINCIPAIS MÉTRICAS

Métricas transformam sensação em informação.

Sem métricas ninguém sabe se está melhorando.


1. LEAD TIME

Tempo entre solicitação e entrega.

Exemplo:

Pedido feito em:

01/06

Produção:

10/06

Lead Time = 9 dias

Quanto menor melhor.


2. CYCLE TIME

Tempo efetivamente gasto desenvolvendo.

Exemplo:

Demanda recebida.

Ficou parada cinco dias.

Desenvolvimento levou dois dias.

Cycle Time = 2 dias.


3. CHANGE FAILURE RATE

Percentual de mudanças que causam problemas.

Exemplo:

100 implantações.

10 causaram incidentes.

Taxa:

10%

Quanto menor melhor.


4. MTTR

Mean Time To Recovery.

Tempo médio para recuperar produção.

Exemplo:

ABEND às 10h.

Sistema normal às 11h.

MTTR = 1 hora.


5. REWORK

Retrabalho.

Mede quanto esforço foi gasto corrigindo erros.

Imagine:

100 horas trabalhadas.

25 horas corrigindo problemas.

Rework:

25%

Muito alto.


6. REFATORAÇÃO

Esforço dedicado a melhorar código existente.

Uma equipe saudável normalmente reserva tempo para:

  • limpeza;

  • reorganização;

  • modularização.


ENTENDENDO O GRÁFICO DA LINEARB

Imagine:

59% Novo Trabalho

17% Refatoração

24% Retrabalho

Significa:

A cada 100 horas:

59 horas criam valor.

17 horas melhoram qualidade.

24 horas apagam incêndios.

Quase um quarto da energia da equipe foi desperdiçada.


COMO REDUZIR DÍVIDA TÉCNICA

Agora chegamos ao ponto mais importante.


PASSO 1 — MAPEAR O PROBLEMA

Não tente resolver tudo.

Primeiro descubra:

  • quais programas mudam mais;

  • quais causam mais incidentes;

  • quais possuem maior complexidade.

Faça uma planilha simples.

ProgramaAlteraçõesIncidentes
FIN00112015
FIN002100
FIN0039512

Comece pelos maiores problemas.


PASSO 2 — CRIAR BACKLOG TÉCNICO

Muitas empresas possuem backlog funcional.

Poucas possuem backlog técnico.

Crie itens como:

  • remover código morto;

  • modularizar rotina;

  • eliminar duplicação;

  • documentar interfaces.

Essas atividades precisam ser visíveis.


PASSO 3 — REFATORAR PEQUENO

Erro clássico:

"Vamos reescrever tudo."

Não faça isso.

Melhore gradualmente.

Hoje:

  • extrair um parágrafo.

Amanhã:

  • eliminar duplicação.

Depois:

  • criar módulo reutilizável.

Pequenas vitórias acumulam grandes resultados.


PASSO 4 — DOCUMENTAR

Documentação não precisa ser um livro.

Basta responder:

  • o que faz;

  • entradas;

  • saídas;

  • dependências.

Já ajuda enormemente.


PASSO 5 — REVISÃO DE CÓDIGO

Mesmo no Mainframe.

Principalmente no Mainframe.

Checklist simples:

✓ Nome adequado

✓ Lógica clara

✓ Tratamento de erro

✓ Performance

✓ Documentação

✓ Testes


PASSO 6 — TESTES

O segredo dos sistemas modernos.

Sem testes:

refatorar é perigoso.

Com testes:

refatorar é seguro.

Mesmo em COBOL.

Ferramentas como:

  • IBM Debug Tool

  • IBM Application Discovery

  • IBM ZUnit

  • Micro Focus Unit Testing

ajudam muito.


PASSO 7 — REDUZIR COMPLEXIDADE

Pergunta mágica:

"Existe uma forma mais simples?"

Sempre existe.

Quanto mais simples:

  • menor risco;

  • menor manutenção;

  • menor custo.


FERRAMENTAS ÚTEIS

IBM Application Discovery

Mapeia dependências.

Mostra:

  • programas;

  • copybooks;

  • arquivos;

  • fluxos.

Excelente para arqueologia de sistemas.


SonarQube

Analisa qualidade.

Detecta:

  • duplicação;

  • complexidade;

  • vulnerabilidades.


Git

Mesmo para Mainframe.

Ajuda a controlar mudanças.


Jira

Controle de backlog técnico.


ServiceNow

Correlação entre incidentes e sistemas.


O SEGREDO QUE NINGUÉM CONTA

A maioria das dívidas técnicas não nasce do código.

Nasce da organização.

Promessas irreais.

Prazos impossíveis.

Mudanças constantes.

Prioridades conflitantes.

O código apenas reflete o ambiente em que foi criado.


EASTER EGG MAINFRAME

Existe um teste simples.

Abra um programa COBOL.

Role até o final.

Se encontrar:

GO TO FIM-PROGRAMA

não se assuste.

Se encontrar:

GO TO INICIO

fique atento.

Se encontrar:

GO TO PARAGRAFO-XYZ

que chama outro GO TO que chama outro GO TO...

Parabéns.

Você encontrou uma relíquia arqueológica do período Jurássico dos sistemas corporativos.


O CAMINHO DE EVOLUÇÃO DO PROGRAMADOR JÚNIOR

Nível 1:

Faz funcionar.

Nível 2:

Faz funcionar corretamente.

Nível 3:

Faz funcionar de forma simples.

Nível 4:

Faz funcionar de forma sustentável.

Nível 5:

Melhora o sistema toda vez que toca nele.

É nesse último estágio que nasce o verdadeiro arquiteto de sistemas.


A GRANDE LIÇÃO

O programador iniciante acredita que seu trabalho é escrever código.

O programador experiente descobre que seu trabalho é reduzir complexidade.

Código novo gera valor.

Mas código limpo preserva valor.

A dívida técnica não explode como um ABEND.

Ela cresce silenciosamente.

Linha após linha.

Workaround após workaround.

Correção após correção.

Até o dia em que uma mudança de cinco minutos passa a exigir três semanas.

Nesse momento os juros finalmente chegaram.

E como qualquer empréstimo antigo, quanto mais tempo você esperar para pagar, mais caro ficará.


domingo, 17 de outubro de 2021

Technical Debt Rules : Quando um Programador COBOL Descobriu que Cada Atalho Criava um Agente Smith Dentro do Sistema

 

Bellacosa Mainframe e as technical debt rules

☕ Um Café no Bellacosa Mainframe

Technical Debt Rules sem Mistérios

Quando um Programador COBOL Descobriu que Cada Atalho Criava um Agente Smith Dentro do Sistema

"Infelizmente, ninguém pode explicar o que é a Dívida Técnica. Você precisa vê-la por si mesmo." — inspirado no universo de Matrix


Bem-vindo à Matrix do Desenvolvimento

Imagine que você acorda em uma sala escura.

Na sua frente existe um monitor verde.

Linhas de caracteres descem como chuva.

Um homem de óculos escuros aproxima-se.

Não é Morpheus.

É o Analista de Sistemas mais antigo da empresa.

Ele coloca duas fitas magnéticas sobre a mesa.

Uma vermelha.

Outra azul.

A azul compila hoje.

A vermelha exige refatoração, testes, documentação e arquitetura.

Você pergunta:

— Qual delas devo escolher?

Ele sorri.

— A azul entrega o projeto este mês.

— A vermelha salva os próximos dez anos.

Naquele instante você entende que toda equipe de desenvolvimento vive diariamente essa escolha.

Esse é o universo da Technical Debt, ou Dívida Técnica, um dos conceitos mais importantes — e mais mal compreendidos — da Engenharia de Software.

Para quem trabalha com COBOL, CICS, Db2, JCL e sistemas legados, entender a Dívida Técnica é quase tão importante quanto saber interpretar um ABEND. Ela explica por que alguns sistemas envelhecem com dignidade enquanto outros se tornam um labirinto impossível de manter.


O que é Technical Debt?

Technical Debt é o custo futuro provocado por decisões técnicas tomadas para ganhar velocidade no presente.

Em outras palavras:

É quando você economiza tempo hoje emprestando tempo do seu próprio futuro.

Assim como um empréstimo bancário, a dívida técnica pode ser útil quando administrada conscientemente.

O problema não é contrair uma dívida.

O problema é esquecer que ela existe.


A origem do termo

O termo Technical Debt foi criado em 1992 por Ward Cunningham, um dos autores do Manifesto Ágil e criador do primeiro Wiki da história.

Ward percebeu que muitos gestores entendiam dinheiro, juros e empréstimos, mas tinham dificuldade para compreender problemas de arquitetura de software.

Então fez uma analogia brilhante.

Ele disse:

"Entregar um software antes de terminar sua arquitetura é como fazer um empréstimo. Pode ser uma boa decisão, desde que você pague rapidamente."

O problema aparece quando os juros começam.

E em software...

...os juros aparecem em forma de:

  • bugs

  • retrabalho

  • lentidão

  • dificuldades para alterar regras

  • aumento do tempo de testes

  • aumento de incidentes


Matrix explica melhor que muitos livros

Imagine que cada linha de código seja parte da Matrix.

Quando tudo é desenvolvido corretamente...

a simulação permanece estável.

Mas sempre existe alguém dizendo:

"Depois a gente arruma."

Esse "depois" nunca chega.

Cada pequeno atalho cria pequenas distorções.

No começo parecem insignificantes.

Depois surgem pequenos defeitos.

Mais tarde aparecem exceções.

Finalmente...

a Matrix inteira começa a produzir Agentes Smith.


Quem são os Agentes Smith?

No mundo do software, os Agentes Smith representam problemas que surgem continuamente.

Cada vez que um desenvolvedor resolve um bug rapidamente sem corrigir sua causa...

nasce um novo Smith.

Cada IF duplicado...

mais um Smith.

Cada variável mal nomeada...

outro Smith.

Cada programa COBOL de cinquenta mil linhas...

centenas deles.

Eles continuam se multiplicando até dominar todo o sistema.


Um exemplo COBOL

Imagine este código:

IF TIPO = "A"
    MOVE 15 TO DESCONTO
END-IF

Alguns meses depois.

Nova regra.

IF TIPO = "A"
    MOVE 20 TO DESCONTO
END-IF

Mais tarde.

Outro programador.

IF CLIENTE-PREMIUM
    MOVE 25 TO DESCONTO
END-IF

Depois.

Outro módulo.

Mesmo código.

Depois outro.

E outro.

Agora existem quinze versões diferentes da mesma regra.

Toda alteração exige procurar manualmente.

Esse é um clássico exemplo de dívida técnica.


O que gera Technical Debt?

Pressão por prazo

"Entrega sexta."

Mesmo sabendo que deveria levar três semanas.


Falta de testes

"Depois escrevemos."

Nunca escrevem.


Documentação inexistente

"Todo mundo entende."

Dois anos depois ninguém entende.


Copiar código

CTRL+C

CTRL+V

CTRL+C

CTRL+V

Assim nasce o caos.


Arquitetura improvisada

Funciona.

Mas ninguém sabe explicar.


Falta de revisão

Sem Code Review...

os problemas entram em produção.


Falta de treinamento

Programadores repetem erros porque nunca aprenderam alternativas melhores.


A dívida nem sempre é ruim

Essa é uma curiosidade interessante.

Nem toda dívida técnica é um erro.

Imagine um banco.

Existe uma exigência legal.

Prazo:

48 horas.

A equipe decide criar uma solução provisória.

Entrega.

Banco evita multas.

Depois reserva tempo para refatorar.

Excelente decisão.

Foi uma dívida consciente.


Dívida consciente x dívida inconsciente

Dívida consciente

"Sabemos que esse código está temporário."

Existe plano.

Existe prazo.

Existe orçamento.


Dívida inconsciente

"Nunca percebemos que fizemos errado."

Muito mais perigosa.


Os juros da dívida

Todo empréstimo possui juros.

Software também.

Os juros aparecem como:

Mais tempo para manutenção

Uma alteração simples leva dias.


Bugs recorrentes

Conserta um.

Quebra outro.


Medo

"Não mexe."

Frase clássica do legado.


Performance

Cada remendo adiciona processamento.

No mainframe isso significa:

  • CPU

  • MIPS

  • consumo

  • custo


Novos profissionais demoram meses

Porque entender ficou difícil.


Como a dívida cresce?

Imagine um cartão de crédito.

Primeiro mês:

100 reais.

Segundo mês:

Terceiro:

Depois:

Depois:

Software faz exatamente isso.

Cada nova funcionalidade construída sobre código ruim aumenta exponencialmente a complexidade.


O Mainframe sofre muito?

Curiosamente...

sim.

E não.

Mainframes normalmente possuem código extremamente robusto.

Mas muitos sistemas existem há quarenta anos.

Durante quatro décadas...

centenas de programadores passaram por eles.

Cada geração deixou pequenas modificações.

O resultado pode ser:

  • GOTO esquecidos

  • IFs duplicados

  • COPYBOOKS redundantes

  • programas gigantescos

  • tabelas obsoletas

  • JCLs nunca revisados


Um exemplo realista

Imagine um programa COBOL chamado:

PGMFIN01

1988

2.300 linhas.

1992

3.800 linhas.

1998

6.500 linhas.

2007

11.000 linhas.

2016

19.000 linhas.

2026

41.000 linhas.

Ninguém teve coragem de dividir.

Cada manutenção ficou mais cara.

A dívida cresceu silenciosamente.


O Oráculo explica

No universo Matrix, o Oráculo nunca entrega respostas prontas.

Ela oferece entendimento.

Na Engenharia de Software acontece igual.

A dívida técnica raramente aparece em relatórios.

Ela aparece nos sintomas.

Equipe cansada.

Prazo aumentando.

Mudanças simples demorando semanas.

Clientes reclamando.

ABENDs aparecendo após pequenas alterações.

Esses são os sinais.


Como reduzir a dívida?

Refatoração

Melhorar código sem alterar comportamento.

É a principal arma.


Testes automatizados

Permitem mudar com segurança.


Revisão de código

Dois olhos veem mais que um.


Arquitetura

Planejamento evita improvisos.


Documentação viva

Nunca deixe conhecimento apenas na memória.


Pair Programming

Conhecimento compartilhado.


Mentoria

Programadores experientes aceleram iniciantes.


Limpeza contínua

Nunca espere uma grande reescrita.

Melhore um pouco todos os dias.


A Regra do Escoteiro

Robert C. Martin popularizou uma ideia simples:

Deixe o código um pouco melhor do que encontrou.

Imagine milhares de desenvolvedores fazendo isso durante anos.

A dívida diminui naturalmente.


Atenção!

Existe um erro muito comum.

Confundir:

Refatoração

com

Reescrita.

São coisas completamente diferentes.

Refatorar melhora.

Reescrever substitui.

Nem sempre reescrever é inteligente.

Muitos projetos falharam tentando "começar do zero".


O perigo da Grande Reescrita

Na Matrix Reloaded, Neo descobre que destruir tudo não resolve.

Em software acontece igual.

Jogar fora um sistema COBOL de quarenta anos pode significar perder décadas de conhecimento de negócio.

O ideal é evoluir gradualmente.


Ferramentas que ajudam

Hoje existem excelentes ferramentas.

  • IBM ADDI

  • IBM Application Discovery

  • SonarQube

  • IBM COBOL Check

  • IBM Z Open Editor

  • IBM Developer for z/OS

  • GitHub Copilot

  • ChatGPT

  • Claude

  • ZUnit

Elas ajudam a identificar:

  • duplicações

  • complexidade

  • dependências

  • código morto

  • riscos


Sinais de alerta

Você deve investigar dívida técnica quando ouvir frases como:

"Não sabemos por que funciona."

"Não mexe nesse módulo."

"Compila assim mesmo."

"Só o João entende."

"Depois documentamos."

"Tem um GOTO aí... mas deixa."

"É gambiarra temporária."

Seis meses depois...

continua igual.


O papel do Programador COBOL Padawan

Um Padawan costuma pensar:

"Meu trabalho é escrever código."

Na verdade, não.

Seu trabalho é entregar soluções sustentáveis.

Sempre pergunte:

  • Isso poderá ser entendido daqui cinco anos?

  • Outro programador conseguirá manter?

  • Existe teste?

  • Existe documentação?

  • Existe duplicação?

  • Essa regra deveria estar em um COPYBOOK?

  • Esse programa precisa mesmo crescer mais mil linhas?

Essas perguntas evitam que você alimente a Matrix com novos Agentes Smith.


Curiosidades sobre a Dívida Técnica

  • Existem empresas que dedicam 20% do tempo de desenvolvimento apenas para pagar dívida técnica.

  • Grandes bancos mantêm backlogs exclusivos de refatoração, separados das novas funcionalidades.

  • Algumas organizações medem a dívida técnica com ferramentas que estimam quantos dias de trabalho seriam necessários para corrigir todos os problemas encontrados.

  • Em projetos críticos, reduzir dívida técnica pode gerar economia significativa em horas de manutenção, consumo de CPU, incidentes e retrabalho.


Outros "parentes" da Dívida Técnica

Ela costuma caminhar ao lado de diversos conceitos conhecidos:

  • Code Smell – sinais de que algo pode estar mal projetado.

  • Big Ball of Mud – sistema sem arquitetura definida.

  • Spaghetti Code – código confuso e altamente acoplado.

  • God Object – um único módulo faz tudo.

  • Bus Factor – conhecimento concentrado em poucas pessoas.

  • Shotgun Surgery – uma pequena alteração exige modificar dezenas de arquivos.

  • Lava Flow – código antigo que ninguém remove por medo.

Todos esses conceitos frequentemente aparecem juntos.


A Grande Escolha: Pílula Azul ou Pílula Vermelha?

No final de Matrix, Neo percebe que conhecer a verdade traz responsabilidade.

Na Engenharia de Software acontece exatamente o mesmo.

Você pode escolher a pílula azul:

  • copiar código;

  • ignorar testes;

  • adiar documentação;

  • aceitar "gambiarras permanentes";

  • acreditar que "funcionando está bom".

Ou pode escolher a pílula vermelha:

  • compreender a arquitetura;

  • investir em refatoração;

  • escrever código legível;

  • compartilhar conhecimento;

  • documentar regras de negócio;

  • pensar no próximo programador que abrirá aquele programa COBOL daqui a dez anos.

A primeira opção parece mais rápida, mas cobra juros crescentes. A segunda exige disciplina, porém constrói sistemas resilientes que atravessam décadas — exatamente como os grandes sistemas IBM Z que sustentam bancos, seguradoras, governos e companhias aéreas ao redor do mundo.

No universo Bellacosa Mainframe, a maior lição é clara: o inimigo não é o legado; é o legado abandonado. Sistemas COBOL envelhecem muito bem quando recebem manutenção consciente, arquitetura sólida e equipes comprometidas em reduzir continuamente a dívida técnica. Assim como Neo precisou aprender a enxergar além do código verde da Matrix, o Programador COBOL Padawan precisa aprender a enxergar além da próxima entrega e pensar no impacto que cada linha escrita hoje terá no futuro da organização.

Porque, no fim, toda dívida será paga. A única dúvida é quem pagará a conta: você hoje ou toda a equipe amanhã?

segunda-feira, 4 de janeiro de 2021

Big Ball of Mud Rules: Quando um Programador COBOL Descobriu que a Matrix Não Era um Sistema... Era uma Enorme Bola de Lama Digital

 

Bellacosa Mainframe e a big ball of mud rules

☕ Um Café no Bellacosa Mainframe

Big Ball of Mud Rules sem Mistérios

Quando um Programador COBOL Descobriu que a Matrix Não Era um Sistema... Era uma Enorme Bola de Lama Digital

"A Matrix não caiu porque era antiga. Ela quase caiu porque ninguém mais conseguia explicar onde começava, onde terminava e por que tudo dependia de tudo."


Prólogo — A Cidade Perdida Dentro da Matrix

Neo recebe sua missão mais difícil.

Não é derrotar o Agente Smith.

Não é salvar Zion.

Não é conversar com o Arquiteto.

Sua missão é muito pior.

Documentar um sistema legado.

Morpheus entrega um HD antigo.

Na etiqueta existe apenas uma inscrição.

COREBANK
1986

Neo pergunta:

— Quantos programas existem?

Morpheus responde:

— Não sabemos.

— Quantos bancos de dados?

— Também não.

— Existe documentação?

Morpheus sorri.

— Existia...

em 1994.

Neo conecta o sistema.

Começa a navegar.

Programa chama programa.

Programa chama JCL.

JCL chama PROC.

PROC chama SORT.

SORT chama outro programa.

CICS chama MQ.

MQ chama outro CICS.

Db2 chama Stored Procedure.

Stored Procedure chama Java.

Java chama REST.

REST chama Python.

Python grava novamente no Db2.

Neo pergunta:

— Onde começa a transação?

Morpheus responde:

— Essa pergunta já destruiu a sanidade de muitos arquitetos.

O Oráculo aproxima-se.

Olha para Neo.

E diz:

"Você não entrou em um sistema. Você entrou em uma Big Ball of Mud."


O que é Big Ball of Mud?

Big Ball of Mud (Grande Bola de Lama) é um antipadrão arquitetural que descreve um sistema gigantesco, complexo e sem uma arquitetura clara.

Ao contrário do Spaghetti Code, que normalmente se refere ao código interno de um programa...

A Big Ball of Mud descreve:

o sistema inteiro.

Ela representa aplicações que cresceram durante anos ou décadas sem planejamento arquitetural consistente.

Tudo funciona.

Mas ninguém sabe exatamente por quê.


A origem do termo

O conceito foi formalizado em 1997 por:

  • Brian Foote

  • Joseph Yoder

No famoso artigo:

Big Ball of Mud

Eles observaram que muitos sistemas corporativos bem-sucedidos não possuíam arquitetura elegante.

Mesmo assim...

continuavam funcionando.

Esses sistemas cresciam organicamente.

Como uma bola de lama rolando morro abaixo.

Cada alteração adicionava mais material.

Sem nunca reorganizar a estrutura.


Matrix explica perfeitamente

Imagine a Matrix.

Milhões de linhas de código.

Milhares de programas.

Centenas de agentes.

Regras antigas.

Novas regras.

Exceções.

Correções.

Remendos.

Durante décadas.

Agora imagine.

Ninguém mais possui o diagrama original.

Essa é exatamente uma Big Ball of Mud.


O nascimento da Bola de Lama

Curiosamente...

ela raramente nasce por incompetência.

Ela nasce por sucesso.

O sistema funciona.

Recebe novas funcionalidades.

Mais clientes.

Mais integrações.

Mais regras.

Mais urgências.

Mais exceções.

Mais mudanças.

Depois de trinta anos.

Virou um universo próprio.


O COBOL conhece bem isso

Muitos sistemas bancários começaram assim.

Programa pequeno.

Novo módulo.

Internet Banking.

Mobile.

APIs.

Cloud.

Open Finance.

IA Generativa.

Tudo conectado.

Sem jamais parar para reorganizar completamente.


Um exemplo simples

Sistema original.

Tela

↓

COBOL

↓

Db2

Quarenta anos depois.

Internet

↓

Portal

↓

Gateway

↓

API

↓

MQ

↓

Java

↓

REST

↓

CICS

↓

COBOL

↓

Db2

↓

ETL

↓

Data Lake

↓

Kafka

↓

Analytics

↓

IA

Nenhuma etapa é necessariamente ruim.

O problema é:

ninguém possui a visão completa.


O Programador COBOL Padawan

Imagine.

Primeiro dia na empresa.

Seu líder diz.

"Você ficará responsável pelo CORE."

Você pergunta.

"Existe documentação?"

Resposta.

"Boa sorte."


Como reconhecer?

Existem sinais muito claros.

Tudo depende de tudo

Alterar um campo quebra cinco sistemas.


Não existe dono

Todos mexem.

Ninguém conhece.


Documentação desatualizada

Fluxos reais são diferentes.


Regras duplicadas

Mesma regra aparece vinte vezes.


Arquitetura desconhecida

Cada desenvolvedor explica de um jeito.


Matrix Reloaded

Neo conversa com o Arquiteto.

O Arquiteto mostra diversas versões anteriores da Matrix.

Cada uma herdou partes da anterior.

Nenhuma foi totalmente reconstruída.

Software corporativo evolui exatamente assim.


O efeito psicológico

Existe um fenômeno interessante.

Quanto maior o sistema...

menor a coragem para reorganizá-lo.

Então cada desenvolvedor pensa:

"Vou alterar só este pedacinho."

Todos fazem isso.

Durante vinte anos.

A lama cresce.


O Agente Smith adora isso

Porque sistemas gigantescos produzem:

medo.

Especialistas tornam-se indispensáveis.

Mudanças ficam lentas.

Arquitetura desaparece.

Smith não precisa atacar.

O próprio sistema torna-se resistente à evolução.


Um exemplo COBOL

Imagine.

Existem.

4.200 programas.

3.800 COPYBOOKs.

1.600 JCLs.

780 PROCs.

320 CICS.

410 tabelas Db2.

Pergunta.

Existe mapa de dependências?

Não.

Bem-vindo.


Como nasce?

Etapa 1.

Sistema simples.

Etapa 2.

Urgências.

Etapa 3.

Novos clientes.

Etapa 4.

Integrações.

Etapa 5.

Exceções.

Etapa 6.

Mais remendos.

Etapa 7.

Ninguém mais entende.


O custo invisível

Nova funcionalidade.

Implementação:

2 dias.

Descobrir impacto:

3 semanas.


O impacto financeiro

Mais testes.

Mais homologação.

Mais reuniões.

Mais especialistas.

Mais CPU.

Mais incidentes.

Tudo fica caro.


Atenção!

Big Ball of Mud não significa:

Sistema ruim.

Muitos dos maiores bancos do mundo operam sistemas extremamente antigos.

Que continuam confiáveis.

O problema não é idade.

É ausência de organização.


Curiosidade

Alguns sistemas COBOL possuem mais de:

50 milhões de linhas de código.

Mesmo assim.

Continuam processando bilhões de dólares diariamente.

Isso mostra que:

idade

não é defeito.


A diferença

Sistema Legado

Pode possuir excelente arquitetura.


Big Ball of Mud

Arquitetura praticamente desapareceu.


Como evitar?

Documentação contínua

Nunca espere o projeto acabar.


Diagramas

Fluxos atualizados.


Refatoração

Pequenas melhorias constantes.


Modularização

Divida responsabilidades.


APIs

Reduza acoplamento.


Testes

Protegem mudanças.


Descoberta arquitetural

Ferramentas ajudam.


Ferramentas modernas

IBM possui soluções excelentes.

  • IBM ADDI

  • Application Discovery

  • IBM Developer for z/OS

  • IBM COBOL Check

  • Z Open Editor

  • Instana

  • OpenTelemetry

Elas conseguem descobrir dependências automaticamente.


O papel da IA

Hoje IA ajuda muito.

Ela pode:

explicar programas.

Criar diagramas.

Resumir módulos.

Encontrar dependências.

Mas existe um limite.

Se o sistema inteiro virou lama...

nem a IA faz milagres.


Matrix e Zion

Imagine Zion construída durante cem anos.

Sem planta.

Sem mapas.

Cada engenheiro criou túneis.

Cada geração abriu novos corredores.

Depois de décadas.

Ninguém sabe onde passam todos os cabos.

É exatamente isso.


Os riscos

Mudanças lentas


Bugs inesperados


Alto acoplamento


Baixa produtividade


Custos elevados


Dependência de especialistas


Dificuldade para integrar IA


Big Ball of Mud e DevOps

DevOps acelera deploy.

Mas não resolve arquitetura ruim.

Aliás.

Pode acelerar problemas.


O papel do Arquiteto

Arquitetos modernos fazem uma pergunta simples.

"Este sistema ainda possui forma?"

Se ninguém conseguir responder.

Talvez a bola de lama já exista.


Um exemplo inspirado na Matrix

Neo pergunta.

"Qual programa calcula o saldo?"

Resposta.

"Depende."

"Depende do quê?"

"Da agência."

"E se for PIX?"

"Outro programa."

"E TED?"

"Outro."

"DOC?"

"Também."

"Open Finance?"

"Mais três."

"Cartão?"

"Depende."

Neo suspira.


Existe cura?

Sim.

Mas ela raramente acontece através de uma grande reescrita.

O caminho normalmente é:

Mapear.

Entender.

Documentar.

Refatorar.

Modularizar.

Modernizar.

Gradualmente.


Erros clássicos

  • Reescrever tudo.

  • Não documentar.

  • Misturar responsabilidades.

  • Criar dependências ocultas.

  • Duplicar regras.

  • Ignorar arquitetura.


Aplicabilidade

Big Ball of Mud aparece em:

  • COBOL

  • Java

  • ERP

  • Sistemas Bancários

  • Telecom

  • Governo

  • Seguradoras

  • Cloud

  • Microsserviços

  • ERPs gigantes


Curiosidades

O artigo original afirma algo curioso.

Muitas Big Balls of Mud foram extremamente lucrativas.

Porque resolviam problemas reais.

O problema aparecia décadas depois.

Quando evoluir passou a ser mais caro que criar.


O ensinamento do Oráculo

O Oráculo entrega uma pequena esfera de barro para Neo.

Ela pergunta.

"O que você vê?"

Neo responde.

"Lama."

Ela amassa.

A esfera cresce.

Depois cresce novamente.

Depois outra vez.

Ela sorri.

"Toda exceção adiciona um pouco mais."


Lições para um Programador COBOL Padawan

Você provavelmente trabalhará em sistemas que nasceram antes mesmo da Internet comercial. Não tenha preconceito com isso. Muitos desses sistemas sustentam operações críticas de bancos, seguradoras e governos com níveis de disponibilidade impressionantes.

Ao mesmo tempo, não aceite a desorganização como algo inevitável. Sempre que possível:

  • documente o que descobrir;

  • desenhe fluxos;

  • elimine duplicações;

  • isole responsabilidades;

  • proponha APIs claras;

  • registre decisões arquiteturais;

  • compartilhe conhecimento com a equipe.

Cada pequena melhoria reduz um pouco da lama acumulada ao longo dos anos e prepara o sistema para as próximas décadas.


Conclusão — A Matrix Não Era um Monólito... Era uma Bola de Lama Viva

No final da saga Matrix, Neo entende que o sistema nunca foi estático. Ele evoluiu continuamente, acumulando regras, exceções e adaptações para sobreviver.

Os grandes sistemas corporativos fazem exatamente o mesmo.

Uma Big Ball of Mud não surge porque alguém decidiu construir um software ruim. Ela surge porque o sistema foi útil durante muito tempo, recebeu centenas de melhorias, integrou novas tecnologias e continuou entregando valor ao negócio sem uma renovação arquitetural proporcional.

Para um Programador COBOL, essa é uma lição fundamental. O legado não deve ser visto como inimigo, mas como um organismo vivo que precisa de cuidados constantes. Modernizar não significa destruir; significa compreender, documentar, simplificar e evoluir.

No universo Bellacosa Mainframe existe uma máxima digna do Arquiteto da Matrix:

"Todo sistema começa como uma ideia elegante. O que determina seu futuro é a disciplina com que ele evolui."

Porque a verdadeira missão do Programador COBOL Padawan não é apenas manter a Matrix funcionando.

É impedir que ela se transforme em uma bola de lama tão grande que ninguém mais consiga encontrar a saída.

sexta-feira, 4 de dezembro de 2020

Lava Flow Rules: Quando um Programador COBOL Descobriu que a Matrix Estava Coberta por Fluxos de Lava Digital que Ninguém Tinha Coragem de Remover

 

Bellacosa Mainframe e a lava flow rules

☕ Um Café no Bellacosa Mainframe

Lava Flow Rules sem Mistérios

Quando um Programador COBOL Descobriu que a Matrix Estava Coberta por Fluxos de Lava Digital que Ninguém Tinha Coragem de Remover

"O maior perigo dos sistemas legados nem sempre é o código que executa. Muitas vezes é o código que ninguém ousa apagar."


Prólogo — A Sala Proibida da Matrix

Depois de inúmeras batalhas contra o Agente Smith, Neo acreditava conhecer praticamente toda a Matrix.

Foi então que o Arquiteto abriu uma porta que nunca havia sido mostrada.

Atrás dela existia um gigantesco datacenter.

Milhares de programas.

Milhões de linhas de código.

No centro da sala havia uma placa metálica.

NÃO MODIFICAR

Neo perguntou:

— O que existe aí?

O Arquiteto respondeu:

— Não sabemos exatamente.

Neo estranhou.

— Como assim?

— Esse código foi escrito antes mesmo da sexta versão da Matrix.

— Ele ainda é usado?

O Arquiteto permaneceu em silêncio.

O Oráculo apareceu.

Olhou para Neo.

Depois para o enorme programa.

Sorriu.

— Talvez sim.

Talvez não.

Neo perguntou:

— Então por que ninguém remove?

O Oráculo respondeu:

"Porque ninguém quer descobrir a resposta em plena produção."

Bem-vindo ao Lava Flow.


O que é Lava Flow?

Lava Flow é um antipadrão de software onde partes antigas do sistema permanecem indefinidamente porque ninguém sabe se ainda são utilizadas.

São blocos de código que:

  • ninguém compreende completamente;

  • aparentemente não possuem função;

  • não aparecem na documentação;

  • mas continuam existindo por medo de removê-los.

Eles se tornam verdadeiros fósseis digitais.


A origem do nome

O termo surgiu no livro clássico AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis, publicado em 1998 por William J. Brown, Raphael Malveau, Hays McCormick III e Thomas Mowbray.

A metáfora é brilhante.

Quando um vulcão entra em erupção, a lava escorre livremente.

Depois de esfriar...

ela endurece.

Com o tempo ninguém consegue mais movê-la.

Mesmo que atrapalhe a construção de estradas ou cidades.

No software acontece exatamente isso.

Uma decisão antiga endurece.

Ninguém mais consegue removê-la.


Matrix explica perfeitamente

Imagine que cada versão da Matrix deixa pequenos trechos de código esquecidos.

Programas antigos.

Rotinas obsoletas.

Protocolos desativados.

Funções nunca mais chamadas.

Mas ninguém ousa apagar.

Porque talvez...

alguma parte escondida ainda dependa delas.


Como nasce um Lava Flow?

Quase sempre começa assim.

Um projeto urgente.

Uma solução temporária.

O desenvolvedor comenta:

"Depois limpamos."

Mas o projeto termina.

A equipe muda.

O conhecimento desaparece.

O código continua.


O COBOL conhece muito bem esse fenômeno

Imagine um programa escrito em 1989.

Em determinado momento existia uma regra para calcular uma antiga taxa bancária.

Essa taxa deixou de existir em 1998.

Mas a rotina continua lá.

Em 2004 alguém perguntou:

— Podemos apagar?

Resposta:

— Melhor não...

Vai que algum lote ainda usa.

Em 2012 outra pessoa perguntou.

Mesma resposta.

Em 2026...

A rotina continua.


Um exemplo clássico

Imagine um trecho como este.

IF WS-TIPO = "X"
    PERFORM CALCULA-TAXA-ESPECIAL
END-IF

Pergunta.

Existe algum cliente com tipo X?

Ninguém sabe.

A consulta nunca foi feita.

Então o código permanece.


Outro exemplo COBOL

Você encontra:

PERFORM ROTINA-LEGADA.

Procura quem chama essa rotina.

Descobre que:

ninguém.

Mas ninguém remove.

Porque talvez exista:

  • um JCL antigo;

  • um programa batch esquecido;

  • uma PROC histórica;

  • um processo anual.


Matrix Reloaded

Lembra dos programas exilados?

Merovíngio abriga programas antigos que deveriam ter sido removidos.

Eles continuam existindo porque encontraram maneiras de sobreviver.

Esses personagens representam perfeitamente o conceito de Lava Flow.

São códigos que perderam sua função original, mas continuam ocupando espaço na Matrix.


O efeito psicológico

Existe uma frase muito conhecida em equipes de manutenção.

"Se está funcionando, não mexa."

Ela protege a estabilidade.

Mas também pode proteger código morto.

O medo da mudança faz com que partes inteiras do sistema permaneçam congeladas por décadas.


O Programador COBOL Padawan

Você abre um programa.

Encontra:

IF WS-FLAG-1987 = "S"

Pergunta ao analista mais experiente.

— O que significa?

Resposta.

— Acho que tem relação com um produto antigo.

"Acho."

Essa palavra deveria acender um alerta.


O Agente Smith adora Lava Flow

Porque código morto aumenta:

  • complexidade;

  • tempo de leitura;

  • dificuldade de testes;

  • risco de manutenção.

Quanto mais difícil compreender o sistema, mais fácil ele se torna de dominar.


Um exemplo inspirado na Matrix

Neo encontra uma porta.

Ela não leva a lugar nenhum.

Pergunta ao Chaveiro.

— Posso removê-la?

O Chaveiro responde.

— Talvez.

Neo insiste.

— Alguém usa?

O Chaveiro sorri.

— Faz muito tempo que ninguém passa por ela...

Mas ninguém quer ser o primeiro a descobrir.


Como reconhecer Lava Flow?

Alguns sinais são clássicos.

Comentários antigos

TEMPORÁRIO
REMOVER DEPOIS

E o comentário tem quinze anos.


Código nunca executado

Cobertura de testes mostra zero chamadas.


Variáveis sem uso

Declaradas.

Nunca lidas.


COPYBOOKs esquecidos

Presentes.

Jamais referenciados.


JCLs históricos

Executados pela última vez em 2014.


O custo invisível

Cada novo desenvolvedor precisa entender:

o código ativo

o código morto.

Mesmo que metade nunca execute.


O impacto no Mainframe

Mainframes corporativos costumam preservar compatibilidade por décadas.

Isso é excelente para o negócio.

Mas também significa que:

  • programas antigos sobrevivem;

  • interfaces antigas permanecem;

  • layouts históricos continuam disponíveis.

Nem tudo pode ser removido imediatamente.


Atenção!

Lava Flow não significa simplesmente "código antigo".

Código antigo pode ser extremamente importante.

O problema é:

código antigo

sem propósito conhecido.


A diferença

Legado

Ainda possui função.


Lava Flow

Ninguém sabe se possui função.


Curiosidade

Diversos sistemas bancários ainda mantêm rotinas para formatos de arquivos que não são utilizados há muitos anos, apenas porque existe a possibilidade de algum cliente institucional ainda depender deles em um processamento específico.


Ferramentas ajudam

Hoje é possível descobrir muito mais do que antigamente.

Ferramentas como:

  • IBM Application Discovery and Delivery Intelligence (ADDI);

  • IBM Developer for z/OS;

  • IBM COBOL Check;

  • SonarQube;

  • Enterprise Analyzer;

permitem identificar:

  • programas sem referências;

  • COPYBOOKs não utilizados;

  • dependências reais;

  • fluxo de chamadas;

  • cobertura de execução.

Elas reduzem significativamente o medo de remover código.


Como evitar?

Descoberta arquitetural

Conheça dependências reais.


Testes automatizados

Eles fornecem confiança.


Monitoramento

Descubra quem realmente utiliza cada componente.


Refatoração contínua

Pequenas limpezas são mais seguras do que grandes reescritas.


Documentação viva

Explique por que algo permanece.


Revisões periódicas

Reserve tempo para eliminar o que perdeu utilidade.


O perigo da limpeza precipitada

O extremo oposto também é perigoso.

Imagine remover uma rotina porque "parece inútil".

Na madrugada do último dia útil do ano...

ela é executada pelo fechamento contábil.

Resultado:

ABEND.

Incidente crítico.

Por isso remover exige evidências.

Nunca intuição.


Matrix e os Programas Exilados

O Merovíngio colecionava programas antigos.

Eles não tinham mais função oficial.

Mesmo assim continuavam vivos.

Esses personagens representam exatamente os componentes esquecidos que permanecem escondidos em sistemas corporativos.

Nem todos causam problemas.

Mas todos aumentam a complexidade.


O papel da IA

Ferramentas baseadas em IA podem:

  • localizar código aparentemente morto;

  • resumir módulos antigos;

  • mapear dependências;

  • identificar duplicações;

  • sugerir candidatos à remoção.

Entretanto, a decisão final continua sendo humana.

Especialmente em ambientes críticos.


Os riscos

Complexidade crescente

Mais código para entender.


Testes maiores

Mais cenários.


Custos

Mais manutenção.


Bugs

Mudanças evitadas por medo.


Segurança

Bibliotecas antigas podem permanecer vulneráveis.


Conhecimento perdido

Ninguém sabe mais o propósito original.


Erros clássicos

  • Nunca revisar código legado.

  • Confundir estabilidade com imobilidade.

  • Manter funcionalidades desativadas indefinidamente.

  • Não registrar decisões arquiteturais.

  • Ignorar ferramentas de análise de dependência.


Boas práticas

  • Mantenha inventário de componentes.

  • Monitore utilização real.

  • Elimine código comprovadamente morto.

  • Escreva testes antes de remover.

  • Documente exceções de negócio.

  • Faça limpezas graduais.


Aplicabilidade

Lava Flow aparece em praticamente qualquer tecnologia:

  • COBOL;

  • PL/I;

  • Java;

  • C#;

  • Python;

  • C++;

  • APIs;

  • microsserviços;

  • aplicações em nuvem;

  • sistemas embarcados.

Quanto maior a vida útil do software, maior a chance desse antipadrão surgir.


O ensinamento do Oráculo

O Oráculo leva Neo até um antigo rio de lava endurecida.

Ela pergunta:

— O que você vê?

Neo responde.

— Pedra.

Ela toca a superfície.

Debaixo dela ainda existe calor.

Então diz:

"No software acontece igual. O código pode parecer morto, mas ainda pode sustentar parte da montanha."

Antes de remover.

Investigue.


Lições para um Programador COBOL Padawan

Ao iniciar sua carreira no universo IBM Z, você encontrará programas com décadas de existência. Alguns conterão comentários escritos por pessoas que já se aposentaram. Outros farão referência a produtos, moedas, legislações e tecnologias que nem existem mais.

Não assuma que tudo isso é lixo.

Também não assuma que tudo é indispensável.

Seu papel é agir como um arqueólogo digital:

  • entender o contexto;

  • mapear dependências;

  • conversar com especialistas;

  • validar com testes;

  • registrar descobertas;

  • remover apenas aquilo cuja inutilidade esteja comprovada.

Essa disciplina preserva a estabilidade do negócio e, ao mesmo tempo, impede que a lama endurecida continue crescendo indefinidamente.


Conclusão — Nem Toda Rocha Deve Permanecer Para Sempre

Na Matrix, programas antigos podiam sobreviver escondidos entre versões sucessivas da simulação. Alguns ainda tinham propósito. Outros apenas ocupavam espaço.

Nos sistemas corporativos acontece exatamente o mesmo.

O Lava Flow representa decisões antigas que endureceram com o tempo. Elas deixaram de ser questionadas porque questioná-las parece perigoso.

Mas engenharia madura não significa apagar tudo.

Significa compreender antes de agir.

Para um Programador COBOL, essa é uma das maiores demonstrações de responsabilidade profissional. Cada remoção deve ser sustentada por evidências, testes, monitoramento e conhecimento do negócio.

No universo Bellacosa Mainframe existe uma máxima que o próprio Oráculo aprovaria:

"O código mais perigoso não é o antigo. É aquele cujo propósito ninguém mais consegue explicar."

Porque, assim como na Matrix, o verdadeiro desafio não é destruir o passado.

É descobrir quais partes dele ainda sustentam o presente e quais já podem, finalmente, descansar.

sexta-feira, 31 de julho de 2020

YAGNI Rules: Quando um Programador COBOL Descobriu que a Matrix Estava Cheia de Recursos Que Ninguém Jamais Usaria

 

Bellacosa Mainframe e a yagni rules

☕ Um Café no Bellacosa Mainframe

YAGNI Rules sem Mistérios

Quando um Programador COBOL Descobriu que a Matrix Estava Cheia de Recursos Que Ninguém Jamais Usaria

"O código mais caro não é aquele que foi escrito. É aquele que foi escrito para um futuro que nunca chegou."


Prólogo — O Depósito das Funcionalidades Fantasma

Após derrotar mais uma legião de Agentes Smith, Neo recebeu um convite inesperado do Arquiteto.

— Hoje vou lhe mostrar um lugar que nem mesmo o Oráculo costuma visitar.

Os dois atravessaram uma enorme porta metálica escondida atrás do núcleo da Matrix.

Do outro lado havia um gigantesco depósito.

Prateleiras infinitas.

Milhões de linhas de código.

Módulos completos.

APIs.

Menus.

Botões.

Rotinas.

Neo perguntou:

— O que é tudo isso?

O Arquiteto respondeu:

— Funcionalidades.

Neo ficou impressionado.

— Quantas pessoas usam?

Silêncio.

Depois de alguns segundos o Arquiteto respondeu:

— Nenhuma.

Neo caminhou entre corredores intermináveis.

Encontrou módulos chamados:

FUTURO-PROJETO.

CLIENTE-PREMIUM-V3.

IA-EXPERIMENTAL.

RELATORIO-UNIVERSAL.

MODULO-MULTIMOEDA.

SISTEMA-DE-TELETRANSPORTE.

Perguntou:

— Isso tudo está em produção?

O Arquiteto respondeu.

— Está.

— Funciona?

— Sim.

— É usado?

— Nunca foi.

O Oráculo apareceu.

Serviu café para Neo.

Depois disse calmamente:

"O maior desperdício da engenharia não é escrever código ruim. É escrever código que jamais resolverá um problema real."

Naquele momento Neo compreendeu o verdadeiro significado do YAGNI.


O que significa YAGNI?

YAGNI significa:

You Aren't Gonna Need It

Em português:

"Você não vai precisar disso."

É um dos princípios mais conhecidos da metodologia Extreme Programming (XP).

Sua ideia é extremamente simples.

Não implemente hoje funcionalidades que talvez sejam necessárias amanhã.

Implemente apenas aquilo que resolve um problema existente.


A origem do princípio

O YAGNI surgiu no final da década de 1990 dentro do movimento Extreme Programming, criado por Kent Beck.

Na época, muitas equipes gastavam enorme quantidade de tempo construindo recursos para um futuro hipotético.

Esses recursos quase nunca eram utilizados.

Kent Beck propôs uma filosofia radical.

Construa somente aquilo que possui necessidade comprovada.

Quando surgir uma nova necessidade.

Implemente naquele momento.


Matrix explica perfeitamente

Imagine que o Arquiteto resolvesse prever todas as possibilidades da humanidade.

Então incluiria:

  • controle de dragões;

  • módulo para dinossauros;

  • protocolo para viagens no tempo;

  • economia marciana;

  • integração com civilizações alienígenas.

Tudo isso "caso um dia seja necessário".

Resultado?

A Matrix seria gigantesca.

Difícil de manter.

Lenta.

Cheia de código inútil.


Como nasce o excesso?

Sempre começa com boas intenções.

Alguém diz.

"Vai que um dia..."

Depois aparecem frases como:

  • "Já vamos deixar preparado."

  • "Aproveita e cria também..."

  • "É só mais um IF."

  • "No futuro pode servir."

Meses depois.

Ninguém usa.


O COBOL conhece isso muito bem

Imagine um sistema bancário.

O requisito diz:

Calcular IOF.

O desenvolvedor pensa.

"Vai que um dia o banco trabalhe com Bitcoin, Ouro, Marte e Lua."

Então cria:

  • vinte tabelas;

  • quinze tipos de moeda;

  • cinquenta parâmetros.

Quando entra em produção.

Existe apenas:

Real.


Um exemplo COBOL

Requisito.

Calcular juros.

Solução simples.

COMPUTE JUROS = SALDO * TAXA

Solução YAGNI ignorado.

Cria:

  • Framework de cálculo.

  • Plugin.

  • Factory.

  • Reflection.

  • Configuração XML.

  • API REST.

  • Tabela dinâmica.

Tudo para multiplicar dois números.


Matrix Reloaded

O Arquiteto mostra milhares de possibilidades futuras.

Neo pergunta.

— Precisamos construir tudo isso?

O Arquiteto responde.

— Não.

O Oráculo sorri.

— O futuro ainda não decidiu existir.


O efeito psicológico

Existe um medo comum entre desenvolvedores.

"E se amanhã precisarmos?"

Essa pergunta gera enormes desperdícios.

Porque o amanhã raramente acontece exatamente como imaginamos.


O Programador COBOL Padawan

Imagine seu primeiro projeto.

O gerente pede:

— Precisamos gerar um relatório.

Você responde.

— Já vou criar vinte modelos diferentes.

Pergunta.

O cliente pediu vinte?

Não.

Pediu um.


O Agente Smith ama funcionalidades imaginárias

Porque cada funcionalidade extra gera:

  • novos bugs;

  • novos testes;

  • nova documentação;

  • novas dependências;

  • novas exceções.

Quanto mais código.

Maior a superfície para ataques.


Um exemplo inspirado na Matrix

Neo pergunta.

— Quantas portas existem?

O Chaveiro responde.

— Mil.

Neo pergunta.

— Quantas usamos?

— Dez.

As outras novecentas e noventa foram criadas "caso um dia fossem necessárias".


O custo invisível

Toda funcionalidade possui custo.

Mesmo sem uso.

Ela precisa:

  • compilar;

  • ser testada;

  • documentada;

  • protegida;

  • revisada;

  • mantida.

Nada é gratuito.


O impacto no Mainframe

Em ambientes IBM Z aparecem frequentemente:

  • COPYBOOKs preparados para campos inexistentes;

  • layouts gigantes;

  • tabelas nunca utilizadas;

  • JCLs reservados para processos imaginários;

  • programas chamados apenas "no futuro".

Tudo isso aumenta:

  • CPU;

  • armazenamento;

  • manutenção.


Curiosidade

Diversos estudos em desenvolvimento de software mostram que uma parcela significativa das funcionalidades presentes em sistemas corporativos é usada muito raramente ou nunca é utilizada pelos usuários finais.

Isso reforça a importância de validar necessidades reais antes de implementar novas capacidades.


Atenção!

YAGNI não significa:

"Nunca pensar no futuro."

Significa:

"Não implementar antes da hora."

Arquitetura pode prever evolução.

Código desnecessário não.


A diferença

Preparar arquitetura

Permitir crescimento.


Implementar tudo

Criar desperdício.


Matrix e Zion

Imagine construir:

  • cem hangares;

  • mil naves;

  • cinquenta hospitais.

Antes mesmo de saber quantas pessoas viverão em Zion.

Seria desperdício.


Ferramentas ajudam

Hoje podemos medir uso real.

  • Telemetria.

  • Analytics.

  • Logs.

  • Feature Flags.

  • IBM Instana.

  • OMEGAMON.

  • Monitoramento de APIs.

Esses dados mostram o que realmente é utilizado.


O papel da IA

A IA frequentemente sugere funcionalidades extras.

Cabe ao engenheiro perguntar.

"O cliente pediu isso?"

Se a resposta for não.

Talvez seja YAGNI.


Os riscos

Ignorar YAGNI gera:

  • overengineering;

  • manutenção cara;

  • código morto;

  • testes maiores;

  • documentação enorme;

  • mais bugs.


Erros clássicos

  • Programar para cenários imaginários.

  • Criar abstrações prematuras.

  • Implementar requisitos inexistentes.

  • Confundir arquitetura extensível com funcionalidades prontas.

  • Aceitar "vai que um dia".


Boas práticas

  • Desenvolver apenas requisitos atuais.

  • Validar com usuários.

  • Medir utilização.

  • Evoluir incrementalmente.

  • Refatorar quando necessário.

  • Simplificar continuamente.


Aplicabilidade

YAGNI aparece em:

  • COBOL.

  • Java.

  • Python.

  • Cloud.

  • APIs.

  • Microsserviços.

  • Mobile.

  • IA.

  • DevOps.

  • ERP.


Um exemplo COBOL

Cliente pede.

Cadastro de Endereço.

Você cria.

  • Rua.

  • Número.

  • Cidade.

  • Estado.

  • CEP.

Não precisa adicionar:

  • Colônia em Marte.

  • Quadrante Galáctico.

  • Planeta de Origem.

  • Coordenadas Quânticas.

Até que alguém realmente peça.


YAGNI e os outros princípios

YAGNI conversa diretamente com quase todos os princípios estudados nesta série.

Ele reduz:

  • Golden Hammer, porque evita criar soluções grandiosas para problemas pequenos.

  • Lasagna Code, porque impede camadas desnecessárias.

  • Lava Flow, porque evita código que nunca será usado e depois ninguém tem coragem de remover.

  • Boiling Frog, porque impede o crescimento silencioso da complexidade.

  • KISS, porque incentiva soluções simples.

  • Death March, porque reduz trabalho desnecessário.

  • Brooks's Law, porque menos funcionalidades significam menos necessidade de crescimento artificial da equipe.

YAGNI é um excelente antídoto contra o excesso de zelo que acaba produzindo desperdício.


O ensinamento do Oráculo

O Oráculo entrega uma mochila para Neo.

Dentro dela existem:

  • vinte lanternas;

  • quinze bússolas;

  • dez rádios;

  • cinco espadas;

  • três computadores;

  • duas cafeteiras.

Neo tenta levantá-la.

Não consegue.

Ela retira tudo.

Deixa apenas:

uma bússola.

água.

e uma lanterna.

Neo sorri.

— Agora consigo caminhar.

Ela responde.

"Quem leva tudo para uma jornada acaba sem forças para percorrê-la."


Lições para um Programador COBOL Padawan

Ao longo da carreira você ouvirá muitas sugestões começando com:

  • "Já aproveita..."

  • "Vai que..."

  • "Quem sabe no futuro..."

  • "Deixa preparado..."

Antes de aceitar, faça algumas perguntas:

  • Existe um requisito aprovado?

  • Há uma necessidade real?

  • Algum usuário pediu isso?

  • Existe previsão concreta de uso?

  • Estamos aumentando a complexidade sem necessidade?

Se a resposta for "não", provavelmente você está diante de um caso clássico de YAGNI.

Projetar sistemas preparados para evoluir é excelente.

Implementar funcionalidades imaginárias é desperdício.


Curiosidades

O princípio YAGNI influenciou fortemente várias práticas modernas:

  • Agile, priorizando valor entregue a cada iteração.

  • Lean Software Development, eliminando desperdícios.

  • Feature Flags, permitindo ativar funcionalidades apenas quando realmente necessárias.

  • MVP (Minimum Viable Product), que incentiva lançar a menor solução capaz de gerar valor.

  • Continuous Delivery, favorecendo evolução contínua em vez de grandes antecipações.

Todos compartilham a mesma ideia: desenvolva apenas aquilo que gera valor agora.


Conclusão — O Futuro Ainda Não Escreveu Seu Código

Quando Neo percorreu o depósito do Arquiteto, percebeu que milhares de módulos existiam apenas para responder a perguntas que ninguém jamais faria.

Na Engenharia de Software isso acontece com frequência.

O princípio YAGNI nos lembra que o futuro é imprevisível. As funcionalidades imaginadas hoje dificilmente corresponderão exatamente às necessidades reais de amanhã.

Para um Programador COBOL, especialmente em ambientes IBM Z onde estabilidade, desempenho e facilidade de manutenção são essenciais, escrever menos código costuma ser uma decisão mais inteligente do que escrever código "por precaução".

Cada linha adicionada representa mais testes, mais documentação, mais manutenção e mais oportunidades para o Agente Smith encontrar uma brecha.

No universo Bellacosa Mainframe existe uma máxima que certamente estaria gravada na oficina do Chaveiro:

"Não construa hoje a chave de uma porta que talvez nunca exista. Quando essa porta aparecer, você terá conhecimento, ferramentas e experiência para fabricar exatamente a chave de que ela precisa."

Porque o verdadeiro engenheiro não é aquele que tenta prever todos os futuros possíveis.

É aquele que constrói sistemas simples, elegantes e preparados para evoluir quando o futuro finalmente bater à porta.