Translate

Mostrar mensagens com a etiqueta Engenharia de Software. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Engenharia de Software. Mostrar todas as mensagens

domingo, 14 de junho de 2026

O Dia em que um Banco Declarou a Própria Liquidação: Lições de Engenharia, Governança e Confiabilidade a partir do Incidente do Nubank

Bellacosa Mainframe e o incidente informatico do Nubank

O Dia em que um Banco Declarou a Própria Liquidação: Lições de Engenharia, Governança e Confiabilidade a partir do Incidente do Nubank

Introdução

Em junho de 2026, um episódio incomum chamou a atenção do mercado financeiro brasileiro, dos profissionais de tecnologia e dos especialistas em gestão de riscos. Clientes do Nubank receberam comunicações oficiais informando que a instituição teria entrado em processo de liquidação. A mensagem, enviada por canais legítimos da empresa, parecia autêntica, utilizava terminologia regulatória correta e mencionava procedimentos relacionados ao Fundo Garantidor de Créditos (FGC).

O problema era simples e ao mesmo tempo alarmante: a informação era falsa.

Em poucas horas, a notícia se espalhou pelas redes sociais, grupos de investidores, fóruns especializados e veículos de imprensa. O Banco Central precisou esclarecer que não existia qualquer procedimento de liquidação em andamento. O Nubank confirmou que se tratava de um erro operacional decorrente de uma falha em processos internos.

À primeira vista, o incidente parece apenas um erro de comunicação. Entretanto, uma análise mais profunda revela um caso clássico de falha sistêmica envolvendo automação, governança, gestão de mudanças, segregação de ambientes e controles de produção.

Mais importante ainda: o episódio oferece uma oportunidade rara para discutir um tema frequentemente negligenciado em empresas digitais modernas — a diferença entre construir sistemas rápidos e construir sistemas confiáveis.


O que aconteceu

Segundo informações divulgadas publicamente, um fluxo responsável por notificações relacionadas a processos de liquidação institucional teria sido acionado indevidamente.

A comunicação foi distribuída para clientes reais utilizando canais oficiais.

Do ponto de vista do usuário final, todos os elementos indicavam legitimidade:

  • origem oficial;

  • identidade visual correta;

  • linguagem regulatória compatível;

  • referência ao FGC;

  • comunicação direta da instituição.

Em segurança da informação existe um princípio fundamental:

O usuário não possui mecanismos para diferenciar uma mensagem legítima de uma mensagem enviada legitimamente por engano.

Essa frase resume a gravidade do incidente.

Quando uma comunicação falsa vem de um atacante externo, o cliente pode desconfiar.

Quando a mesma comunicação vem do próprio banco, a confiança desaparece como mecanismo de defesa.


O erro informático por trás do incidente

Embora os detalhes técnicos completos não tenham sido divulgados, a descrição pública permite inferir algumas hipóteses plausíveis.

O problema parece ter ocorrido em uma combinação de:

  • automação de mensagens;

  • parametrização inadequada;

  • ausência de validações obrigatórias;

  • insuficiência de mecanismos de aprovação.

Em engenharia de software, isso é conhecido como um erro de "guard rails", ou seja, ausência de barreiras que impeçam uma ação perigosa.

Imagine um sistema com a seguinte lógica:

Evento:
Liquidação Institucional

Instituição:
[NOME_DO_BANCO]

Ação:
Enviar comunicação aos clientes

Se o campo da instituição estiver vazio, o sistema deveria interromper imediatamente o processo.

No entanto, em muitos sistemas corporativos existem valores padrão.

Exemplo:

if banco == null:
    banco = "Nubank"

Ou ainda:

if banco == "":
    utilizar_instituicao_padrao()

Pequenos atalhos criados durante desenvolvimento, testes ou homologação podem se transformar em bombas-relógio quando chegam à produção.


Quando ambientes de teste contaminam a produção

Uma das hipóteses mais discutidas é a existência de um fluxo originalmente criado para testes.

Esse cenário é extremamente comum.

Empresas desenvolvem sistemas utilizando ambientes distintos:

Desenvolvimento

Local onde programadores criam funcionalidades.

Homologação

Ambiente utilizado para validações.

Produção

Sistema real utilizado por clientes.

Na teoria, esses ambientes são completamente isolados.

Na prática, muitas organizações acabam criando atalhos.

Exemplos comuns:

  • cópia de bases produtivas;

  • reutilização de configurações;

  • compartilhamento de APIs;

  • uso de dados reais em homologação.

Quando isso acontece, uma fronteira crítica desaparece.

O resultado é que ações originalmente pensadas para teste passam a ter impacto real.


A armadilha da automação

O setor financeiro moderno depende de automação em larga escala.

Bancos digitais enviam diariamente:

  • notificações;

  • alertas;

  • extratos;

  • avisos regulatórios;

  • comunicações de segurança.

Uma única plataforma pode disparar milhões de mensagens por hora.

O benefício é evidente:

  • redução de custos;

  • velocidade operacional;

  • escalabilidade.

O problema é que a automação amplifica erros.

Um funcionário que envia uma mensagem errada manualmente afeta algumas pessoas.

Um sistema automatizado pode afetar milhões.

Existe uma máxima conhecida em operações de TI:

A automação não elimina erros humanos. Ela multiplica seus efeitos.

O incidente ilustra perfeitamente esse princípio.


O papel dos controles de mudança

Toda alteração em sistemas críticos deveria seguir um processo formal.

Esse processo normalmente inclui:

Revisão técnica

Validação por outros desenvolvedores.

Aprovação operacional

Análise dos impactos.

Aprovação de negócio

Validação da área responsável.

Testes

Verificação funcional.

Plano de rollback

Capacidade de reversão rápida.

Quando qualquer uma dessas etapas falha, o risco aumenta exponencialmente.

A questão não é impedir erros.

Erros são inevitáveis.

A questão é impedir que erros individuais alcancem clientes.


O conceito de “blast radius”

Engenheiros de confiabilidade utilizam o conceito de blast radius.

Traduzindo livremente:

"raio de explosão".

A pergunta é simples:

Se algo der errado, quantas pessoas serão afetadas?

Sistemas modernos devem ser projetados para minimizar esse impacto.

Exemplo:

Em vez de enviar uma comunicação para toda a base de clientes, o sistema deveria:

  1. enviar para um grupo piloto;

  2. validar resultados;

  3. liberar gradualmente;

  4. expandir para toda a população.

Essa técnica é utilizada por empresas como:

  • Google;

  • Amazon;

  • Microsoft;

  • Netflix.

Caso o disparo incorreto tivesse sido submetido a um rollout progressivo, o incidente provavelmente teria sido detectado nos primeiros minutos.


O problema dos dados reais em testes

Outro aprendizado importante envolve o uso de dados produtivos.

Muitas empresas utilizam bases reais para reproduzir cenários complexos.

Isso facilita testes.

Também aumenta riscos.

Dados reais possuem características imprevisíveis:

  • relacionamentos existentes;

  • integrações ativas;

  • gatilhos automáticos;

  • usuários legítimos.

Uma rotina criada para laboratório pode encontrar condições inesperadas quando executada em produção.

É por isso que organizações maduras investem em:

  • anonimização;

  • mascaramento de dados;

  • ambientes sintéticos.

O objetivo é reproduzir a realidade sem colocar clientes reais em risco.


O fator psicológico do incidente

Existe um aspecto pouco discutido.

O dano não foi apenas tecnológico.

Foi psicológico.

O sistema financeiro funciona baseado em confiança.

Quando um banco afirma que está sendo liquidado, o cliente não realiza uma análise técnica.

Ele reage emocionalmente.

As perguntas surgem imediatamente:

  • Meu dinheiro está seguro?

  • Preciso sacar recursos?

  • Minha conta continuará funcionando?

  • Meu cartão será cancelado?

  • Vou perder investimentos?

Em poucos minutos pode surgir um fenômeno conhecido como corrida informacional.

Não necessariamente uma corrida bancária tradicional.

Mas uma corrida por esclarecimentos.

Milhares de pessoas acessam simultaneamente:

  • aplicativo;

  • central de atendimento;

  • redes sociais;

  • imprensa.

O volume gerado pode se tornar um problema operacional por si só.


O impacto no mercado

Embora o incidente tenha sido rapidamente esclarecido, ele produziu repercussões relevantes.

Mercados financeiros são altamente sensíveis à informação.

Especialmente quando envolve:

  • liquidez;

  • solvência;

  • regulação.

Investidores institucionais monitoram continuamente sinais de risco.

Uma notícia sobre liquidação, ainda que falsa, pode provocar:

  • volatilidade;

  • aumento de dúvidas;

  • especulação;

  • pressão reputacional.

Mesmo após o esclarecimento, permanece uma questão:

Como um mecanismo tão crítico conseguiu ser acionado incorretamente?

Essa pergunta interessa mais ao mercado do que o próprio erro.

Porque ela trata da maturidade operacional da organização.


O custo invisível da reputação

Empresas costumam medir:

  • receita;

  • lucro;

  • crescimento;

  • número de clientes.

Poucas conseguem medir confiança.

Entretanto, confiança é um dos ativos mais valiosos do setor financeiro.

Uma instituição pode gastar bilhões em marketing.

Mas basta um único incidente de credibilidade para comprometer anos de construção de marca.

A reputação é semelhante a um sistema distribuído:

Leva muito tempo para convergir.

Pode ser afetada em segundos.


O que empresas podem aprender

O incidente produz diversas lições para organizações digitais.

1. Sistemas críticos precisam de múltiplas aprovações

Nenhuma comunicação regulatória deveria depender de uma única ação.

Princípio dos quatro olhos:

duas pessoas precisam validar.

2. Produção deve ser protegida contra operadores

O objetivo não é desconfiar das pessoas.

É reconhecer que erros acontecem.

Sistemas precisam impedir ações perigosas.

3. Rollouts graduais reduzem impacto

Nenhum disparo massivo deveria ocorrer instantaneamente.

4. Testes precisam ser isolados

Ambientes de homologação devem permanecer separados da produção.

5. Alertas precisam monitorar comportamentos anormais

Se uma mensagem de liquidação for enviada, alarmes automáticos deveriam disparar imediatamente.


O paradoxo dos bancos digitais

O caso revela um paradoxo interessante.

Os bancos digitais são extraordinariamente eficientes.

Conseguem:

  • abrir contas em minutos;

  • aprovar cartões rapidamente;

  • processar milhões de transações.

Mas velocidade e confiabilidade nem sempre evoluem no mesmo ritmo.

À medida que organizações crescem, seus sistemas tornam-se mais complexos.

Mais integrações.

Mais automações.

Mais dependências.

Mais pontos de falha.

O desafio deixa de ser construir funcionalidades.

Passa a ser controlar complexidade.


A maturidade dos sistemas modernos

Os maiores incidentes tecnológicos raramente acontecem por falhas sofisticadas.

Na maioria das vezes eles surgem de:

  • configurações incorretas;

  • permissões inadequadas;

  • processos incompletos;

  • validações ausentes.

A história da tecnologia está repleta de exemplos semelhantes.

Falhas milionárias já foram causadas por:

  • campos vazios;

  • scripts de manutenção;

  • comandos executados no ambiente errado;

  • parâmetros incorretos.

O problema não é a tecnologia.

O problema é a interação entre tecnologia, pessoas e processos.


Conclusão

O episódio envolvendo a falsa comunicação de liquidação do Nubank não deve ser interpretado apenas como um erro operacional isolado.

Ele representa um estudo de caso sobre os desafios da engenharia moderna em sistemas de missão crítica.

O incidente demonstrou como um único evento pode atravessar múltiplas camadas organizacionais:

  • tecnologia;

  • governança;

  • comunicação;

  • segurança;

  • reputação;

  • mercado financeiro.

Mais importante, revelou uma verdade frequentemente esquecida em ambientes digitais:

A confiabilidade não nasce da ausência de erros.

Ela nasce da capacidade de impedir que erros inevitáveis se transformem em crises.

Em um mundo onde bancos são plataformas de software, cada linha de código, cada configuração e cada processo operacional participa diretamente da construção da confiança do cliente.

E confiança, diferentemente do software, não pode ser restaurada simplesmente com um novo deploy.

Ela precisa ser reconquistada.

Para ir mais longe

Bellacosa Mainframe e o incidente do nubank







sábado, 13 de junho de 2026

Guard Rails, COBOL, Mainframe, Engenharia de Software, Desenvolvimento COBOL, Sistemas Críticos, Confiabilidade, Governança de TI, DevOps, Arquitetura de Software, Batch Processing, Segurança da Informação, SRE, Boas Práticas, Tecnologia Bancária

 

Bellacosa Mainframe e o guard rails em desenvolvimento de software

Guard Rails: A Arte de Impedir que um Desenvolvedor Derrube o Banco

Uma conversa que todo desenvolvedor COBOL deveria ter

Imagine a seguinte situação.

Você acabou de entrar em uma instituição financeira.

É seu terceiro mês como desenvolvedor COBOL.

Depois de semanas corrigindo pequenos bugs, finalmente recebe uma tarefa importante.

Uma rotina responsável pelo envio de notificações para clientes.

O gerente explica:

— Precisamos incluir um novo tipo de comunicação.

Você faz a alteração.

Compila.

Executa os testes.

Tudo parece funcionar.

A mudança é promovida para produção.

Horas depois, milhares de clientes recebem uma mensagem errada.

O call center entra em colapso.

O aplicativo registra picos de acesso.

O time de negócios inicia uma reunião de emergência.

A diretoria quer explicações.

E então surge a pergunta:

Como isso foi possível?

A resposta geralmente não é:

"Porque o desenvolvedor errou."

A resposta correta costuma ser:

"Porque o sistema permitiu que um erro chegasse à produção."

É exatamente nesse ponto que surge um dos conceitos mais importantes da engenharia moderna:

Guard Rails.


O que são Guard Rails?

A tradução literal seria:

"trilhos de proteção".

A inspiração vem das rodovias.

Quando um carro sai da pista, existe uma barreira metálica para impedir que ele caia de um penhasco.

O guard rail não evita o erro do motorista.

Ele reduz as consequências.

Na engenharia de software acontece exatamente a mesma coisa.

Os desenvolvedores inevitavelmente cometerão erros.

Os analistas inevitavelmente esquecerão requisitos.

Os operadores inevitavelmente clicarão em algo errado.

Os administradores inevitavelmente executarão comandos incorretos.

O objetivo não é eliminar o erro humano.

O objetivo é impedir que o erro se transforme em desastre.


O erro é inevitável

Desenvolvedores juniores costumam acreditar que sistemas caem porque alguém não sabia programar.

Essa visão desaparece rapidamente em ambientes corporativos.

Os maiores incidentes da história da tecnologia não foram causados por programadores incompetentes.

Foram causados por profissionais experientes trabalhando sob pressão.

Pessoas excelentes.

Pessoas inteligentes.

Pessoas treinadas.

Pessoas humanas.

A questão nunca foi:

"Quem errou?"

A questão sempre foi:

"Por que o sistema permitiu?"

Essa diferença muda completamente a forma de construir software.


Um exemplo COBOL simples

Considere um programa que realiza transferência bancária.

Versão sem Guard Rails:

IF SALDO-CONTA > 0
   SUBTRACT VALOR FROM SALDO-CONTA
END-IF.

Parece correto.

Mas existe um problema.

Suponha:

Saldo = 100

Transferência = 1000

O programa permitirá saldo negativo.

Agora uma versão mais segura.

IF VALOR > SALDO-CONTA
   DISPLAY "TRANSFERENCIA NEGADA"
   GO TO FIM-PROGRAMA
END-IF.

O sistema agora protege o negócio.

Isso é um Guard Rail.


Guard Rail não é regra de negócio

Esse é um erro comum.

Muitos desenvolvedores confundem os dois conceitos.

Regra de negócio:

"O cliente não pode sacar mais que possui."

Guard Rail:

"Mesmo que alguém esqueça a regra, o sistema impedirá a operação."

Uma regra define comportamento.

Um Guard Rail protege comportamento.


A filosofia do mainframe

Durante décadas, os ambientes mainframe desenvolveram uma cultura diferente do mundo moderno.

Em startups existe uma frase famosa:

Move fast.

Nos bancos existe outra:

Don't break production.

A razão é simples.

Um erro em rede social gera reclamações.

Um erro bancário gera prejuízo.

Por isso o mundo COBOL sempre valorizou:

  • validação;

  • redundância;

  • auditoria;

  • segregação;

  • rastreabilidade.

Sem perceber, os ambientes mainframe implementavam Guard Rails muito antes do conceito ganhar popularidade.


O caso clássico do JCL

Todo profissional de mainframe já ouviu histórias de horror envolvendo JCL.

Imagine um dataset:

CLIENTES.PRODUCAO

Agora imagine um utilitário de exclusão.

DELETE CLIENTES.PRODUCAO

Um comando simples.

Um erro simples.

Um desastre gigantesco.

Por isso empresas maduras criam Guard Rails.

Por exemplo:

  • confirmação obrigatória;

  • aprovação dupla;

  • ambiente segregado;

  • backup automático.

A exclusão continua possível.

Mas torna-se muito mais difícil.


O princípio do “Are You Sure?”

Existe uma categoria inteira de Guard Rails baseada em confirmação.

Exemplo.

Você tenta apagar um arquivo.

O sistema pergunta:

"Tem certeza?"

Parece algo trivial.

Mas essa simples pergunta já evitou milhões de erros ao longo da história da computação.

Em sistemas financeiros essa ideia evolui.

Em vez de uma confirmação:

  • duas confirmações;

  • dois operadores;

  • dois gestores;

  • duas aprovações.

Chamamos isso de Four Eyes Principle.

Princípio dos quatro olhos.


Guard Rails em processamento batch

O universo COBOL vive cercado de batches.

Folha de pagamento.

Compensação bancária.

Fechamento contábil.

Liquidação financeira.

Imagine um programa que processa:

10.000 registros

Normal.

Agora imagine:

100 milhões de registros

Algo está errado.

Sem Guard Rails o programa continua.

Com Guard Rails ele interrompe:

IF QTDE-REGISTROS > LIMITE-MAXIMO
   DISPLAY "PROCESSAMENTO ANORMAL"
   ABEND
END-IF.

Esse simples teste pode evitar horas de caos operacional.


O conceito de Fail Fast

Existe um princípio muito importante:

Fail Fast.

Falhe rapidamente.

Muitos sistemas tentam continuar funcionando mesmo após identificar inconsistências.

Isso parece inteligente.

Na prática costuma piorar tudo.

Se um dado crítico estiver errado, o melhor comportamento é parar imediatamente.

Exemplo:

IF CODIGO-CLIENTE = SPACES
   ABEND
END-IF.

Parar cedo é melhor do que produzir milhões de registros incorretos.


Guard Rails contra desenvolvedores

Esse é um tema que incomoda iniciantes.

Ninguém gosta de ouvir:

"O sistema precisa proteger a empresa de você."

Mas essa é a realidade.

Um Guard Rail existe justamente porque até profissionais excelentes erram.

Imagine um comando SQL.

Sem proteção:

DELETE FROM CLIENTES;

Com proteção:

DELETE FROM CLIENTES
WHERE ID = :CLIENTE;

Ou ainda melhor.

Permissão somente leitura em produção.

O desenvolvedor continua competente.

O ambiente apenas se torna mais seguro.


O incidente do Nubank e os Guard Rails

O caso do falso aviso de liquidação tornou-se um exemplo interessante.

Independentemente dos detalhes internos, uma pergunta surgiu:

Como uma comunicação tão crítica chegou aos clientes?

A resposta provavelmente envolve ausência ou falha de Guard Rails.

Por exemplo:

  • validação insuficiente;

  • aprovação inadequada;

  • rollout inexistente;

  • testes incompletos.

Nenhum sistema deveria conseguir informar a liquidação de um banco sem múltiplas camadas de proteção.


Rollout gradual

Imagine um envio para:

50 milhões de clientes

Sem Guard Rail:

envio imediato.

Com Guard Rail:

1% da base.

Validação.

5%.

Validação.

10%.

Validação.

100%.

Empresas como Google, Amazon e Netflix utilizam esse modelo constantemente.

O objetivo é reduzir o raio da explosão.


Blast Radius

Todo arquiteto experiente faz uma pergunta.

Se isso falhar, quantas pessoas serão afetadas?

Chamamos isso de Blast Radius.

Raio de explosão.

Exemplo.

Erro em um batch:

Impacto:

500 clientes.

Blast Radius pequeno.

Erro em compensação nacional:

Impacto:

50 milhões de clientes.

Blast Radius enorme.

Guard Rails existem para reduzir esse raio.


Observabilidade também é Guard Rail

Muitos desenvolvedores acreditam que Guard Rails são apenas validações.

Não.

Monitoramento também é proteção.

Imagine:

Processamento esperado:

1000 transações por minuto

Sistema detecta:

500.000 transações por minuto

Algo claramente está errado.

Um bom sistema dispara alarmes.

Isso também é Guard Rail.


O conceito de Circuit Breaker

Em sistemas distribuídos modernos existe outro Guard Rail famoso.

Circuit Breaker.

Inspirado nos disjuntores elétricos.

Se uma dependência começa a falhar:

o sistema corta a conexão.

Em vez de derrubar tudo.

No mundo mainframe encontramos equivalentes há décadas:

  • limites operacionais;

  • interrupções controladas;

  • filas protegidas;

  • rejeições automáticas.

A ideia é a mesma.

Conter danos.


O erro mais caro é o silencioso

Existe uma frase conhecida entre engenheiros de confiabilidade:

Sistemas barulhentos são irritantes.

Sistemas silenciosamente errados são perigosos.

Um programa que falha imediatamente chama atenção.

Um programa que produz dados incorretos durante três dias pode gerar prejuízos gigantescos.

Por isso Guard Rails modernos privilegiam transparência.

Tudo deve ser:

  • registrado;

  • monitorado;

  • auditado;

  • rastreável.


A maturidade profissional

Existe um momento na carreira em que o desenvolvedor deixa de pensar:

"Meu código funciona."

E começa a pensar:

"O que acontece quando ele falhar?"

Essa mudança separa programadores iniciantes de engenheiros experientes.

O foco deixa de ser funcionalidade.

Passa a ser confiabilidade.


O que um desenvolvedor COBOL Jr deve fazer

Sempre pergunte:

O que pode dar errado?

Quem será impactado?

Existe limite operacional?

Existe validação?

Existe rollback?

Existe auditoria?

Existe monitoramento?

Existe aprovação?

Existe segregação?

Existe plano de contingência?

Se alguma resposta for "não sei", continue investigando.


A grande lição

Guard Rails não existem porque desenvolvedores são ruins.

Eles existem porque sistemas são complexos.

Quanto maior a empresa, mais perigoso se torna assumir que ninguém cometerá erros.

O verdadeiro papel da engenharia não é criar sistemas perfeitos.

É criar sistemas resilientes.

Sistemas que sobrevivam a erros humanos.

Sistemas que sobrevivam a falhas operacionais.

Sistemas que sobrevivam a decisões equivocadas.

No universo bancário, onde bilhões de reais transitam diariamente por programas COBOL escritos ao longo de décadas, essa diferença não é apenas uma questão técnica.

É uma questão de sobrevivência operacional.

E talvez a principal lição para qualquer desenvolvedor COBOL Jr seja esta:

Seu trabalho não é apenas fazer o programa funcionar.

Seu trabalho é impedir que ele cause danos quando inevitavelmente algo der errado.

Esse é o verdadeiro significado de Guard Rails.


sexta-feira, 12 de junho de 2026

Blast Radius: Por Que um Pequeno Erro Pode Derrubar um Banco Inteiro

 

Bellacosa Mainframe e o blast radius em desenvolvimento de software

Blast Radius: Por Que um Pequeno Erro Pode Derrubar um Banco Inteiro

Uma das perguntas mais importantes da engenharia moderna

Imagine que você acabou de entrar em uma grande instituição financeira.

Você é um desenvolvedor COBOL Jr.

Recebe uma tarefa aparentemente simples.

Alterar uma rotina de validação em um programa batch.

O código possui apenas algumas linhas.

A mudança é pequena.

O teste passou.

O deploy foi aprovado.

Tudo parece sob controle.

Dois dias depois surge uma reunião de crise.

Executivos estão reunidos.

Gerentes estão nervosos.

Equipes de infraestrutura trabalham durante a madrugada.

Milhões de registros foram processados incorretamente.

O prejuízo é enorme.

E então alguém faz uma pergunta que todo arquiteto experiente conhece:

Qual era o Blast Radius dessa mudança?

Essa pergunta vale mais do que qualquer revisão de código.

Mais do que qualquer ferramenta de monitoramento.

Mais do que qualquer framework moderno.

Porque ela determina o tamanho potencial do desastre.


O que significa Blast Radius?

A tradução literal seria:

Raio de Explosão.

O termo vem do universo militar.

Quando ocorre uma explosão, existe uma área diretamente afetada.

Quanto maior a explosão, maior o raio de destruição.

A engenharia de software adotou exatamente a mesma ideia.

Quando um sistema falha, uma pergunta precisa ser respondida:

Quantas pessoas, sistemas, operações ou clientes serão impactados?

Essa área de impacto é chamada Blast Radius.


O erro que afeta um cliente

Imagine um programa COBOL responsável por atualizar dados cadastrais.

Um erro afeta:

1 cliente

Problema?

Sim.

Crise?

Provavelmente não.

O impacto é localizado.

O Blast Radius é pequeno.


O erro que afeta um banco inteiro

Agora imagine um programa responsável pela compensação financeira nacional.

Um erro afeta:

30 milhões de clientes

Mesma quantidade de linhas alteradas.

Mesmo programador.

Mesmo tipo de erro.

Resultado completamente diferente.

Por quê?

Porque o Blast Radius mudou.


A pergunta que diferencia um programador de um engenheiro

O desenvolvedor iniciante normalmente pergunta:

Meu código funciona?

O engenheiro experiente pergunta:

O que acontece se ele falhar?

Essa mudança de mentalidade é uma das maiores evoluções na carreira de tecnologia.

Porque sistemas críticos não são avaliados apenas pelo sucesso.

Eles são avaliados pela forma como falham.


O mito do pequeno erro

Existe uma crença perigosa em ambientes corporativos.

"Foi só uma alteração pequena."

O tamanho do código raramente determina o tamanho do impacto.

Um único caractere já derrubou sistemas inteiros.

Um único parâmetro incorreto já gerou perdas milionárias.

Uma única configuração errada já interrompeu operações globais.

O impacto depende do Blast Radius.

Não da quantidade de código.


O universo COBOL e o poder invisível

Desenvolvedores COBOL trabalham em uma situação peculiar.

Muitas vezes manipulam sistemas que movimentam bilhões de reais diariamente.

Mas a interface parece simples.

Uma tela verde.

Alguns arquivos.

JCLs.

Datasets.

Rotinas batch.

Tudo parece tranquilo.

Até que alguém descobre que aquele programa processa:

  • contas correntes;

  • cartões;

  • empréstimos;

  • investimentos;

  • liquidações;

  • compensações.

De repente o código ganha outra dimensão.


O efeito dominó

Imagine uma falha em um cadastro.

Cliente incorreto.

Esse dado alimenta:

  • CRM;

  • antifraude;

  • cobrança;

  • compliance;

  • atendimento;

  • relatórios regulatórios.

Agora uma pequena falha inicial se transforma em dezenas de falhas secundárias.

Isso é amplificação de Blast Radius.


O conceito de dependências

Sistemas modernos não vivem isolados.

Um programa chama outro.

Que chama outro.

Que alimenta outro.

Que gera arquivos para outro.

O resultado é uma rede gigantesca.

Quando um componente falha, o impacto se propaga.

Como peças de dominó.


O exemplo do CPF inválido

Imagine uma rotina simples.

Um CPF inválido passa pela validação.

O erro parece pequeno.

Mas esse dado segue adiante.

Abre conta.

Gera cartão.

Produz relatórios.

Entra em auditorias.

Alimenta modelos analíticos.

Meses depois ninguém sabe mais onde o problema começou.

O Blast Radius cresceu silenciosamente.


O incidente do Nubank como estudo de caso

O episódio envolvendo o falso aviso de liquidação trouxe uma lição interessante.

Independentemente dos detalhes internos, a pergunta arquitetural é:

Qual era o Blast Radius daquele processo?

Se a mensagem atingisse:

10 clientes

O incidente seria pequeno.

Se atingir milhões:

O cenário muda completamente.

A mesma falha produz consequências exponencialmente maiores.


Blast Radius e ambientes de produção

Uma regra simples:

Quanto mais próximo da produção, maior o Blast Radius.

Ambiente de desenvolvimento:

Impacto quase zero.

Homologação:

Impacto limitado.

Produção:

Impacto real.

Produção financeira:

Impacto potencialmente gigantesco.

É por isso que instituições financeiras possuem tantos controles.

Não por burocracia.

Mas porque o custo do erro é enorme.


O perigo dos batches

O mundo COBOL é dominado por processamento em massa.

Um programa pode executar durante horas.

Processando milhões de registros.

O problema é simples.

Se houver um erro:

Ele será repetido milhões de vezes.

Um erro individual torna-se um erro industrializado.


O erro multiplicado

Imagine:

1 registro incorreto

Sem batch:

impacto pequeno.

Agora imagine:

50 milhões de registros

Processados pela mesma lógica defeituosa.

O erro não mudou.

O Blast Radius mudou.


Como arquitetos pensam

Arquitetos raramente perguntam:

"Qual tecnologia usamos?"

Eles perguntam:

"Qual o pior cenário possível?"

Essa pergunta direciona toda a arquitetura.

Porque sistemas críticos são construídos para sobreviver a falhas.

Não apenas para funcionar.


Blast Radius e permissões

Um desenvolvedor possui acesso de leitura.

Blast Radius reduzido.

Um desenvolvedor possui acesso irrestrito.

Blast Radius elevado.

É por isso que ambientes maduros trabalham com:

  • menor privilégio;

  • segregação;

  • controle de acesso;

  • aprovações.

Tudo isso é gestão de Blast Radius.


Blast Radius e banco de dados

Imagine um comando SQL.

Primeiro cenário:

UPDATE CLIENTES
SET STATUS='A'
WHERE ID=100;

Impacto:

um cliente.

Segundo cenário:

UPDATE CLIENTES
SET STATUS='A';

Impacto:

todos os clientes.

A diferença visual é mínima.

A diferença operacional é gigantesca.


O princípio da contenção

Existe uma palavra muito importante.

Contenção.

Todo sistema moderno deveria conter falhas.

Não espalhá-las.

Por isso empresas investem em:

  • segmentação;

  • isolamento;

  • partições;

  • zonas independentes.

O objetivo é impedir que uma falha local se torne global.


O conceito de células

Empresas como Amazon popularizaram a ideia de Cell Architecture.

Em vez de uma estrutura única gigante.

Criam-se células menores.

Se uma célula falhar:

As demais continuam operando.

Isso reduz drasticamente o Blast Radius.


Mainframe já fazia isso há décadas

Curiosamente, ambientes mainframe utilizavam conceitos semelhantes muito antes da computação em nuvem.

Exemplos:

  • LPARs;

  • regiões CICS;

  • filas separadas;

  • ambientes segregados;

  • jobs independentes.

A filosofia era exatamente a mesma.

Conter impactos.


O problema do compartilhamento excessivo

Quanto mais sistemas compartilham recursos, maior o Blast Radius.

Banco compartilhado.

Fila compartilhada.

Storage compartilhado.

Processamento compartilhado.

Tudo isso cria pontos únicos de falha.

Um problema em um componente afeta dezenas de outros.


O conceito de Blast Radius Humano

Pouca gente fala sobre isso.

Mas pessoas também possuem Blast Radius.

Imagine:

Um único operador consegue executar qualquer comando em produção.

Blast Radius enorme.

Agora imagine:

Necessidade de aprovação dupla.

Blast Radius reduzido.

A governança existe para limitar o alcance dos erros humanos.


O papel dos Guard Rails

Blast Radius e Guard Rails caminham juntos.

Guard Rails tentam impedir erros.

Blast Radius tenta limitar consequências.

Exemplo:

Guard Rail:

impedir exclusão acidental.

Blast Radius:

caso a exclusão ocorra, limitar o impacto.

São conceitos complementares.


Rollout gradual

Uma das formas mais modernas de controlar Blast Radius é o rollout progressivo.

Em vez de liberar uma mudança para todos.

Liberamos para poucos.

Por exemplo:

1%.

Depois 5%.

Depois 10%.

Depois 100%.

Se houver erro, ele será detectado cedo.

O impacto permanece pequeno.


O medo saudável da produção

Existe uma característica interessante nos profissionais experientes de mainframe.

Eles respeitam produção.

Não porque tenham medo da tecnologia.

Mas porque entendem o Blast Radius.

Produção concentra:

  • clientes;

  • dinheiro;

  • contratos;

  • obrigações regulatórias;

  • reputação.

Uma pequena falha pode produzir consequências gigantescas.


Observabilidade e Blast Radius

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

Por isso monitoramento é fundamental.

Imagine um batch que normalmente processa:

500 mil registros

Hoje processou:

50 milhões

Algo claramente está errado.

Um sistema observável detecta rapidamente.

Quanto mais cedo o problema é identificado, menor o Blast Radius.


O custo da reputação

Em bancos existe um ativo invisível.

Confiança.

Quando uma falha afeta poucos clientes, a recuperação costuma ser simples.

Quando afeta milhões, surge um problema adicional.

Reputação.

O Blast Radius passa a incluir:

  • imprensa;

  • investidores;

  • reguladores;

  • mercado.

O dano deixa de ser apenas tecnológico.


O exercício mental que todo COBOL Jr deveria fazer

Antes de qualquer alteração, pergunte:

Se eu errar:

  • Quantos clientes serão impactados?

  • Quantos sistemas dependem disso?

  • Existe rollback?

  • Existe monitoramento?

  • Existe plano de contingência?

  • Existe limite operacional?

  • Existe validação?

  • Existe segregação?

Essas perguntas valem mais do que qualquer linha de código.


A verdadeira maturidade profissional

Existe um momento em que o desenvolvedor deixa de ser apenas um programador.

Ele passa a enxergar sistemas.

Passa a enxergar operações.

Passa a enxergar negócios.

Passa a enxergar riscos.

Nesse momento surge uma nova pergunta.

Não mais:

O programa funciona?

Mas sim:

Qual é o Blast Radius se ele parar de funcionar?

Essa mudança de perspectiva transforma a forma de desenvolver software.


Conclusão

Blast Radius é um dos conceitos mais importantes da engenharia moderna porque nos obriga a pensar além do código.

Ele nos força a enxergar impacto.

A enxergar consequências.

A enxergar riscos.

Para um desenvolvedor COBOL Jr, compreender Blast Radius significa entender que o tamanho de uma alteração não determina sua importância.

Uma linha de código pode alterar milhões de contas.

Um único parâmetro pode interromper operações nacionais.

Uma pequena falha pode se propagar por dezenas de sistemas.

Os melhores engenheiros não são aqueles que acreditam que nunca errarão.

São aqueles que projetam sistemas assumindo que erros inevitavelmente acontecerão.

E quando eles acontecerem, o objetivo não será impedir a explosão.

Será garantir que o raio da explosão seja o menor possível.

Esse é o verdadeiro significado de Blast Radius.


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


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

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

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

Mas existe uma curiosidade que poucos conhecem:

O COBOL nunca foi exclusivo do Mainframe.

Durante décadas existiram versões para:

  • MS-DOS

  • Windows

  • Linux

  • Unix

  • AIX

  • HP-UX

  • Solaris

  • AS/400

  • VMS

  • até mesmo Raspberry Pi atualmente

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

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

A pergunta é inevitável:

Por que isso aconteceu?

Por que Java virou universal?

Por que C conquistou sistemas operacionais?

Por que Python dominou a automação?

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

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

Pegue seu café.

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


O MAIOR MITO SOBRE COBOL

Existe uma crença popular:

"COBOL só funciona em Mainframe."

Isso nunca foi verdade.

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

Nos anos 80 surgiram versões para:

  • DOS

  • Unix

  • VAX/VMS

Nos anos 90:

  • Windows

  • OS/2

  • Linux

Nos anos 2000:

  • .NET

  • JVM

  • Web Services

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

Mas não seguiu.


O PROBLEMA NUNCA FOI A LINGUAGEM

Essa é a primeira coisa que surpreende muita gente.

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

Na verdade ele possuía diversas vantagens.

Extremamente legível

Exemplo:

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

Até alguém sem conhecimento profundo consegue entender.


Excelente para regras de negócio

Bancos adoram COBOL porque ele descreve regras empresariais com clareza.

Por exemplo:

COMPUTE JUROS =
    VALOR * TAXA / 100

Não existe mistério.


Forte manipulação de registros

Antes dos bancos relacionais se popularizarem, isso era ouro.


Precisão decimal

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

E dinheiro não aceita erro.


O VERDADEIRO PROBLEMA: O COBOL NASCEU PARA NEGÓCIOS

A palavra COBOL significa:

Common Business Oriented Language

Observe:

Não é:

  • Common Game Language

  • Common Scientific Language

  • Common Internet Language

É:

Business.

Negócios.

Empresas.

Contabilidade.

Folha de pagamento.

Seguros.

Finanças.

Faturamento.

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


ENQUANTO ISSO, O MUNDO MUDOU

Na década de 1960 isso era perfeito.

Mas nas décadas seguintes surgiram novos mercados.


Computação científica

FORTRAN dominou.


Sistemas operacionais

C dominou.


Inteligência Artificial

LISP dominou inicialmente.


Aplicações gráficas

C++


Internet

Java

PHP

Perl

JavaScript


Ciência de Dados

Python

R


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


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

Aqui existe um fator psicológico interessantíssimo.

Pense nos heróis da programação:

  • Linus Torvalds → C

  • Guido van Rossum → Python

  • Bjarne Stroustrup → C++

  • James Gosling → Java

Agora pense em COBOL.

A maioria das pessoas nem sabe quem foi Grace Hopper.

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

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

Ela foi vendida como algo:

  • estável

  • corporativo

  • burocrático

E isso afasta jovens desenvolvedores.


O EFEITO "BANCO"

Imagine dois anúncios.

Linguagem A

"Crie jogos incríveis!"

Linguagem B

"Automatize cálculos atuariais."

Qual parece mais divertida?

Foi exatamente isso que aconteceu.

COBOL ficou associado a:

  • bancos

  • seguradoras

  • governos

  • sistemas legados

Enquanto outras linguagens ficaram associadas à inovação.


O ERRO DE MARKETING MAIS CARO DA HISTÓRIA

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

  • C

  • Pascal

  • C++

  • Java

COBOL desapareceu dos cursos.

A consequência foi devastadora.

Menos estudantes.

Menos projetos.

Menos comunidade.

Menos livros.

Menos ferramentas.

Menos conteúdo.

Menos adoção.

Criou-se um círculo vicioso.


O PROBLEMA DAS FERRAMENTAS

Vamos ser honestos.

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

Visual Basic tinha:

  • botões

  • janelas

  • eventos

Você arrastava componentes.

Tudo aparecia na tela.

COBOL continuava focado em:

OPEN INPUT CLIENTES
READ CLIENTES

O apelo visual era praticamente zero.


O MUNDO APAIXONOU-SE POR INTERFACES GRÁFICAS

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

Eles queriam construir:

  • telas

  • jogos

  • multimídia

COBOL não era o candidato natural.


O MAINFRAME PROTEGEU O COBOL

Aqui está a maior ironia.

O Mainframe foi simultaneamente:

  • a maior força do COBOL

  • e sua maior prisão

Sem Mainframe talvez COBOL tivesse desaparecido.

Mas graças ao Mainframe ele sobreviveu.

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

Os bancos já estavam satisfeitos.

Por que mudar?


O FATOR ECONÔMICO

Imagine um banco.

Você possui:

  • 50 milhões de linhas COBOL

  • 40 anos de história

  • bilhões movimentados diariamente

Qual decisão é mais segura?

Opção A

Migrar tudo.

Opção B

Continuar usando COBOL.

A resposta é óbvia.


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

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

Um sistema bancário precisa:

  • estabilidade

  • previsibilidade

  • auditoria

Não precisa ser moderno.

Precisa funcionar.

E COBOL funciona.

Muito bem.


A CHEGADA DA INTERNET

Nos anos 90 surgiu a Web.

Foi uma nova corrida do ouro.

Linguagens correram para conquistar esse território.

  • Java

  • PHP

  • Perl

  • ASP

COBOL chegou depois.

Muito depois.

Quando chegou, o mercado já tinha donos.


O PROBLEMA DA COMUNIDADE

Uma linguagem vive ou morre pela comunidade.

Python possui:

  • milhões de usuários

  • milhares de bibliotecas

  • eventos globais

Java possui ecossistema gigantesco.

COBOL sempre teve uma comunidade menor.

Extremamente qualificada.

Mas menor.


O FATOR OPEN SOURCE

Outro golpe importante.

O movimento Open Source impulsionou:

  • Linux

  • Python

  • PHP

  • Perl

COBOL permaneceu muito ligado ao mundo corporativo.

Licenças caras.

Compiladores pagos.

Ferramentas empresariais.

Isso limitou sua expansão.


MAS EXISTE COBOL OPEN SOURCE

Hoje existe o fantástico:

GNUCobol

GnuCOBOL Official Project

Ele compila COBOL para C e roda em:

  • Linux

  • Windows

  • macOS

Mostrando que o COBOL continua vivo fora do Mainframe.


O COBOL É LENTO?

Outro mito.

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

Especialmente em processamento transacional.

O problema nunca foi desempenho.


O COBOL É ANTIGO DEMAIS?

Também não.

Veja a ironia.

Hoje temos:

  • APIs REST

  • JSON

  • XML

  • Kafka

  • Containers

  • Docker

E o COBOL já conversa com tudo isso.

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

O problema não é tecnológico.

É percepção de mercado.


O PARADOXO DO SUCESSO

O COBOL sofreu do mesmo problema que o DB2 Mainframe.

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

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


O QUE ACONTECERIA SE O COBOL FOSSE CRIADO HOJE?

Imagine uma linguagem com:

  • sintaxe legível

  • precisão decimal nativa

  • foco em regras de negócio

  • forte tipagem

  • excelente auditoria

Provavelmente seria vendida como:

  • FinTech Language

  • Banking Language

  • Enterprise Language

E talvez fosse considerada revolucionária.


O COBOL PERDEU A GUERRA?

Não.

Na verdade, ele venceu uma guerra diferente.

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

Poucas tecnologias na história conseguiram isso.


A VERDADE QUE POUCOS ADMITEM

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

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

Isso muda completamente a forma de projetar software.


A GRANDE LIÇÃO PARA OS PADAWANS

A pergunta correta não é:

"Por que COBOL ficou nichado no Mainframe?"

A pergunta correta é:

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

Porque o COBOL nasceu para resolver problemas empresariais gigantescos.

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

  • confiabilidade

  • segurança

  • disponibilidade

  • escalabilidade

  • integridade transacional

O COBOL não ficou preso ao Mainframe.

Na realidade, ele encontrou seu habitat natural.

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

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

Dentro do Mainframe ele se tornou rei.

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

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

Poucas linguagens podem dizer isso.

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

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

Ele já estava ocupado movendo o mundo. ☕🚀



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


sábado, 23 de maio de 2026

☕🔥 “O MUNDO É UM BATCH JOB INSTÁVEL” — A VERDADE QUE SÓ UM MAINFRAME PROGRAMMER ENXERGA

 

Bellacosa Mainframe o mundo do programador mainframe

☕🔥 “O MUNDO É UM BATCH JOB INSTÁVEL” — A VERDADE QUE SÓ UM MAINFRAME PROGRAMMER ENXERGA

Existe uma diferença brutal entre como o mundo enxerga o profissional de mainframe…
e como o profissional de mainframe enxerga o mundo.

A imagem acima não é apenas uma piada.
Ela é uma metáfora perfeita da realidade invisível da computação corporativa moderna.

De um lado, vemos o estereótipo clássico:

“COBOL? Isso ainda existe?”
“Mainframe não morreu?”
“Isso é tecnologia de museu?”

A sociedade digitalizada acredita que tudo gira em torno de apps coloridos, IA generativa, cloud infinita e startups que prometem reinventar o universo a cada quinze minutos.

Mas o outro lado da imagem revela algo assustadoramente verdadeiro:

O mundo inteiro roda em cima de batch jobs.

E quase ninguém percebe isso.


☕ O MAINFRAME NÃO É O PASSADO — ELE É A INFRAESTRUTURA OCULTA DO PRESENTE

O jovem da esquerda vê um “programador jurássico”.

O engenheiro da direita vê:

  • dependências quebradas

  • jobs encadeados

  • datasets críticos

  • filas congestionadas

  • produção falhando

  • sistemas sem tratamento de exceção

  • integrações caóticas

  • pipelines frágeis

  • mudanças emergenciais às 3 da manhã

Ou seja…

Ele vê a realidade.

Porque o profissional de mainframe aprende cedo algo que poucos aprendem no mundo moderno:

Sistemas grandes não vivem de hype.

Sistemas grandes vivem de estabilidade.


☕ O PADAWAN MODERNO FOI ENSINADO A CRIAR APPS

O MAINFRAME ENSINA A SUSTENTAR CIVILIZAÇÕES

Essa é a grande diferença.

Um app pode falhar e gerar reclamações no Twitter.

Um sistema bancário central falha…
e milhões de pessoas ficam sem salário.

Um aplicativo pode reiniciar.

Um processamento de compensação bancária não pode.

Um e-commerce pode cair.

Mas um sistema de previdência nacional não pode simplesmente “deployar em produção e ver no que dá”.


☕ O MAINFRAME É O LADO ADULTO DA COMPUTAÇÃO

O programador moderno muitas vezes aprende:

  • frameworks

  • front-end

  • APIs

  • containers

  • cloud

  • microservices

Tudo isso é importante.

Mas o mainframe ensina algo raro:

responsabilidade computacional.

Você aprende:

  • consistência transacional

  • tolerância a falhas

  • processamento massivo

  • segurança séria

  • performance extrema

  • rastreabilidade

  • governança

  • resiliência operacional

  • continuidade de negócios

E principalmente:

Você aprende que tecnologia não existe para parecer bonita.

Ela existe para NÃO PARAR.


☕ A IMAGEM ESCONDE UMA VERDADE PROFUNDA SOBRE A VIDA CORPORATIVA

Observe o painel da direita.

Tudo é caos:

  • “FAILED JOBS”

  • “DATASET NOT FOUND”

  • “UNHANDLED EXCEPTION: HUMANITY”

  • “URGENT”

  • “PRODUCTION CHANGE WITHOUT TESTING”

Isso é quase um documentário do mundo corporativo moderno.

O profissional de mainframe desenvolve uma visão sistêmica rara.

Ele aprende a perceber:

  • gargalos invisíveis

  • dependências frágeis

  • riscos silenciosos

  • processos mal desenhados

  • automações perigosas

  • integrações irresponsáveis

Depois de anos em produção…

Você começa a enxergar o mundo inteiro como um JES2 gigantesco.


☕ MAINFRAME NÃO É SOMENTE TECNOLOGIA

É UMA ESCOLA DE ENGENHARIA MENTAL

Poucas stacks ensinam tanto sobre:

  • disciplina

  • análise

  • confiabilidade

  • impacto real

  • continuidade operacional

O profissional de mainframe aprende a pensar em:

“O que acontece se isso quebrar?”

Essa pergunta muda completamente a forma de enxergar sistemas.

E honestamente?

O mundo atual precisa desesperadamente dessa mentalidade.

Porque estamos vivendo a era do:

  • deploy sem teste

  • arquitetura sem governança

  • cloud sem controle de custo

  • IA sem entendimento estrutural

  • aplicações sem observabilidade

E então descobrem, tarde demais…

que alguém precisa manter o núcleo funcionando.

E quase sempre…

esse alguém conhece COBOL.


☕ PADAWAN, O MAINFRAME NÃO É UM FIM DE CARREIRA

ELE PODE SER O COMEÇO DA SUA EVOLUÇÃO

Existe um mito extremamente perigoso:

“Mainframe limita sua carreira.”

Na prática…

o mainframe expande sua visão sobre computação de maneira absurda.

Porque você passa a entender:

  • computação em escala real

  • processamento crítico

  • engenharia de missão crítica

  • sistemas financeiros

  • arquitetura corporativa

  • segurança institucional

  • integração entre plataformas

  • legado vivo

  • evolução contínua

Você deixa de pensar somente em código.

E começa a pensar em ecossistemas.


☕ O FUTURO NÃO VAI MATAR O MAINFRAME

O FUTURO VAI SE CONECTAR A ELE

A nova geração acredita que IA substituirá tudo.

Mas existe uma pergunta interessante:

Quem vai conectar a IA aos sistemas bancários reais?

Quem vai integrar modelos modernos aos:

  • CICS

  • DB2

  • IMS

  • VSAM

  • filas MQ

  • processamento batch

  • z/OS

  • RACF

  • sistemas financeiros históricos

O futuro não elimina o core corporativo.

O futuro precisa conversar com ele.

E aí surge o verdadeiro diferencial do próximo profissional raro:

alguém que entende o legado…

e também entende o futuro.


☕ A STACK MAINFRAME É UM UNIVERSO

Quando você entra nesse mundo, descobre que ele não é “apenas COBOL”.

Você encontra:

  • z/OS

  • JCL

  • CICS

  • DB2

  • RACF

  • TSO/ISPF

  • SORT

  • MQ

  • VSAM

  • Assembler

  • automação

  • monitoração

  • segurança

  • tuning

  • integração web

  • APIs REST

  • DevOps corporativo

  • observabilidade

  • containers híbridos

  • Open Mainframe Project

  • LinuxONE

  • IA integrada ao Z

É literalmente um ecossistema inteiro.


☕ O PROGRAMADOR MAINFRAME NÃO É UM RELÍQUIA

Ele é o operador silencioso da infraestrutura do planeta.

Enquanto o mundo discute tendências…

ele mantém:

  • bancos funcionando

  • cartões autorizando

  • folhas de pagamento rodando

  • companhias aéreas operando

  • governos processando dados

  • seguradoras sobrevivendo

  • transações acontecendo em milissegundos

Sem glamour.

Sem hype.

Sem palco.

Mas com estabilidade.


☕ E ENTÃO, PADAWAN…

Talvez esteja na hora de parar de enxergar o mainframe como “tecnologia antiga”.

E começar a enxergá-lo como:

a camada invisível que sustenta o mundo moderno.

Porque no final…

a piada da imagem é verdadeira.

Para muitos, o programador mainframe parece um fóssil.

Mas para quem conhece produção de verdade…

o mundo inteiro realmente parece:

“um gigantesco batch job instável esperando falhar às 2h da manhã.” ☕🔥


quarta-feira, 20 de maio de 2026

🔥☕ Do COBOL ao Arquiteto Enterprise Por Que Engenharia de Software Virou a Skill Mais Importante Para o Programador Mainframe Moderno

 

Bellacosa Mainframe e topicos de engenharia de software para mainframers


🔥☕ Do COBOL ao Arquiteto Enterprise

Por Que Engenharia de Software Virou a Skill Mais Importante Para o Programador Mainframe Moderno

Existe uma frase silenciosa que ecoa dentro dos grandes bancos, seguradoras e sistemas financeiros do planeta:

“O sistema pode até mudar de interface… mas o COBOL continua sustentando o mundo.”

E isso não é exagero.

Enquanto muita gente acredita que o universo enterprise vive apenas de microservices coloridos, containers e frameworks JavaScript da moda… milhões de transações financeiras continuam atravessando silenciosamente ambientes IBM Z, CICS, DB2 e aplicações COBOL gigantescas que nunca podem parar.

Mas algo mudou.

Muito.

O mercado não procura mais apenas:

  • “quem sabe COBOL”

Hoje o mercado procura:

  • engenheiros de software enterprise.

E existe uma diferença brutal entre essas duas coisas.


☕ O Antigo Programador COBOL

Durante décadas, muitos profissionais cresceram no modelo clássico:

  • alterar rotina

  • corrigir bug

  • compilar

  • subir pacote

  • fechar chamado

O foco era:

  • implementação

  • manutenção

  • operação

E isso funcionou por muito tempo.

Mas o mundo enterprise moderno virou um ecossistema absurdamente mais complexo.

Hoje um simples sistema bancário pode envolver:

  • APIs REST

  • aplicações mobile

  • cloud híbrida

  • microsserviços

  • observabilidade

  • CI/CD

  • autenticação distribuída

  • mensageria

  • integração em tempo real

  • analytics

  • IA

E no meio disso tudo…

o COBOL continua lá.

Silencioso.

Processando.

Confiável.


🏗️ O Que é Engenharia de Software de Verdade?

Muita gente acha que engenharia de software é:

  • aprender framework

  • decorar design pattern

  • usar UML

Mas engenharia de software é algo muito maior.

Ela existe para resolver um problema fundamental:

Como construir sistemas gigantes sem criar caos?

Porque sistemas enterprise crescem.

E crescem rápido.

Sem arquitetura:

  • o sistema vira espaguete

  • manutenção explode

  • bugs aumentam

  • deploys quebram produção

  • integração vira pesadelo

A engenharia surge para controlar complexidade.


🧱 Arquitetura Não É Luxo. É Sobrevivência.

O programador júnior normalmente olha para:

  • programas

  • copybooks

  • tabelas

  • jobs

O arquiteto olha para:

  • ecossistemas

  • fluxos

  • dependências

  • escalabilidade

  • disponibilidade

  • integração

Essa mudança de mentalidade é gigantesca.

Um banco não sobrevive décadas apenas porque tem “código”.

Ele sobrevive porque existe:

  • arquitetura

  • organização

  • separação de responsabilidades

  • governança

E curiosamente…

o mundo mainframe sempre fez isso muito antes da cloud existir.


☕ O Mainframe Já Pensava Como Cloud Décadas Atrás

Esse talvez seja um dos maiores segredos da computação enterprise.

Muitos conceitos vendidos hoje como “modernos” já existiam no ecossistema IBM há décadas.

Veja isso:

Mundo ModernoMainframe Enterprise
Alta disponibilidadeSysplex
Load BalancingCICSPlex
APIsz/OS Connect
TransactionsCICS
ObservabilidadeOMEGAMON
Segurança centralizadaRACF
MensageriaMQ

Ou seja…

o IBM Z nunca ficou ultrapassado.

O que aconteceu foi:

  • a interface mudou

  • o marketing mudou

  • o nome mudou

Mas os fundamentos de engenharia continuaram fortíssimos.


⚔️ O Problema do “Só Saber Programar”

Existe um erro muito comum entre iniciantes.

Acreditar que carreira se resume a:

  • linguagem

  • sintaxe

  • framework

Mas linguagens mudam.

Frameworks morrem.

Hypes desaparecem.

O que permanece é:

  • arquitetura

  • modelagem

  • design

  • integração

  • capacidade analítica

É exatamente por isso que engenheiros experientes continuam relevantes por décadas.

Eles entendem sistemas.

Não apenas ferramentas.


🧩 Design Patterns: O Conhecimento Condensado dos Veteranos

Quando um júnior vê:

  • Factory

  • Singleton

  • Observer

  • Strategy

ele normalmente pensa:

“isso parece complicado”

Mas design patterns são apenas soluções repetidas para problemas repetidos.

Eles nasceram porque grandes sistemas começaram a enfrentar:

  • acoplamento

  • manutenção impossível

  • crescimento descontrolado

  • dependências caóticas

Então engenheiros começaram a criar padrões reutilizáveis.

E isso mudou a indústria.

No fundo:

  • design patterns

  • clean code

  • arquitetura em camadas

  • UML

são tentativas humanas de controlar complexidade.


🧠 Clean Code Não É Frescura

Muitos sistemas COBOL antigos sofrem não por causa da idade.

Mas por causa da falta de engenharia.

Código ruim custa:

  • dinheiro

  • tempo

  • performance

  • estabilidade

  • saúde mental

E isso vale para qualquer linguagem.

Um programa COBOL bem escrito pode durar décadas.

Um programa moderno mal escrito pode virar lixo em seis meses.

A diferença está na engenharia.


🌐 O Novo COBOL Está Conectado

Hoje o programador mainframe moderno precisa entender:

  • APIs REST

  • JSON

  • integração

  • cloud híbrida

  • DevOps

  • pipelines

  • observabilidade

Porque o COBOL moderno não vive mais isolado.

Agora ele conversa com:

  • mobile

  • fintechs

  • microsserviços

  • IA

  • analytics

  • cloud pública

O COBOL deixou de ser “backoffice”.

Ele virou parte do ecossistema digital global.


🚀 DevOps Chegou ao IBM Z

Durante muito tempo existiu um mito:

“Mainframe não acompanha DevOps.”

Hoje isso caiu completamente.

O ecossistema IBM já possui:

  • Git

  • CI/CD

  • automação

  • pipelines

  • testes automatizados

  • observabilidade moderna

  • integração cloud-native

Ferramentas como:

  • Zowe

  • Jenkins

  • UrbanCode

  • GitHub

  • OpenShift

aproximaram ainda mais o IBM Z do universo moderno.


☕ O Que o Mercado Espera Agora?

O mercado não procura mais apenas:

  • operador

  • codificador

  • executor de tarefas

Ele procura:

  • solucionadores de problemas

O profissional valioso hoje entende:

  • negócio

  • arquitetura

  • integração

  • confiabilidade

  • escalabilidade

  • comunicação

E aqui existe uma vantagem absurda para quem vem do mainframe.

Porque poucos ambientes ensinam:

  • sistemas críticos

  • alta disponibilidade

  • milhões de transações reais

  • tolerância zero para falhas

O programador COBOL enterprise já nasce perto de problemas gigantes.


🧭 O Roadmap do Programador COBOL Moderno

A evolução natural hoje passa por:

Base

  • COBOL

  • JCL

  • VSAM

  • SDSF

Intermediário

  • DB2

  • CICS

  • SQL

  • MQ

Modernização

  • APIs

  • JSON

  • REST

  • Git

  • DevOps

Engenharia

  • Arquitetura

  • Design Patterns

  • UML

  • Observabilidade

  • Segurança

Próximo nível

  • Cloud híbrida

  • SRE

  • Performance

  • Integração distribuída

  • Engenharia enterprise


🔥 O Grande Erro do Mercado

Enquanto muitos perseguem apenas:

  • hype

  • frameworks

  • modinhas

o mundo enterprise continua valorizando:

  • confiabilidade

  • estabilidade

  • engenharia sólida

E é exatamente aí que o profissional IBM Z moderno pode se tornar raro.

Porque ele entende:

  • legado

  • missão crítica

  • integração

  • arquitetura real


☕ O Futuro Não Está Escolhendo Entre COBOL ou Cloud

O futuro está integrando os dois.

Os sistemas modernos não vão substituir completamente o mainframe.

Eles vão conversar com ele.

Porque no final:

  • o aplicativo pode mudar

  • a interface pode mudar

  • a cloud pode mudar

Mas alguém ainda precisa garantir:

  • consistência

  • transação

  • segurança

  • disponibilidade

E silenciosamente…

o IBM Z continua fazendo isso melhor do que quase qualquer outra plataforma do planeta.


🔥☕ Conclusão Bellacosa Mainframe

O programador COBOL que entender engenharia de software deixará de ser apenas:

  • “o cara do legado”

e começará a se tornar:

  • arquiteto

  • integrador

  • especialista enterprise

  • engenheiro de sistemas críticos

Porque no final…

o verdadeiro diferencial nunca foi apenas a linguagem.

Sempre foi:

entender como sistemas gigantes funcionam.