Translate

Mostrar mensagens com a etiqueta simplicidade. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta simplicidade. Mostrar todas as mensagens

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.

sábado, 22 de fevereiro de 2020

KISS Rules : Quando um Programador COBOL Descobriu que o Arquiteto da Matrix Não Vencia Pela Complexidade… Mas Pela Simplicidade

  

Bellacosa Mainframe apresenta o KISS rules

☕ Um Café no Bellacosa Mainframe

KISS Rules sem Mistérios

Quando um Programador COBOL Descobriu que o Arquiteto da Matrix Não Vencia Pela Complexidade… Mas Pela Simplicidade

"A maior demonstração de inteligência não é construir algo complicado. É construir algo tão simples que continue funcionando décadas depois."


Prólogo — O Código Secreto do Arquiteto

Depois de inúmeras batalhas contra o Agente Smith, Neo finalmente teve acesso ao núcleo da Matrix.

Esperava encontrar algoritmos impossíveis.

Equações gigantescas.

Milhares de níveis de abstração.

Mas encontrou algo completamente diferente.

O coração da Matrix era surpreendentemente simples.

Poucas regras.

Poucas interfaces.

Poucos componentes.

Neo olhou espantado para o Arquiteto.

— Isso é tudo?

O Arquiteto respondeu calmamente.

— A complexidade não está no código.

Está no mundo.

Nos usuários.

Nos negócios.

Nos requisitos.

Nos imprevistos.

Neo insistiu.

— Então por que não criar uma arquitetura extremamente sofisticada?

O Oráculo apareceu.

Serviu duas xícaras de café.

Depois colocou sobre a mesa dois relógios.

Um possuía centenas de engrenagens.

Outro tinha poucas peças.

Perguntou:

— Qual você acha que continuará funcionando daqui a cinquenta anos?

Neo sorriu.

Naquele instante compreendeu o verdadeiro significado do KISS.


O que significa KISS?

KISS significa:

Keep It Simple, Stupid

Em português:

"Mantenha tudo o mais simples possível."

Apesar do termo "Stupid" soar ofensivo em português, ele nasceu como uma forma bem-humorada de lembrar engenheiros de que a simplicidade costuma ser mais poderosa do que soluções excessivamente sofisticadas.

Hoje muitas empresas preferem versões como:

  • Keep It Simple

  • Keep It Short and Simple

  • Keep It Simple and Smart

Mas a essência permanece a mesma.


A origem do princípio

O princípio surgiu na década de 1960.

Foi popularizado pelo engenheiro Kelly Johnson, líder da famosa divisão Skunk Works, da Lockheed.

Johnson orientava sua equipe a desenvolver aviões militares extremamente eficientes, porém fáceis de manter em condições adversas.

Sua filosofia era simples:

Um mecânico em um campo de batalha deve conseguir reparar o avião com ferramentas comuns.

Se o projeto fosse complexo demais para ser mantido, ele já havia fracassado.

Décadas depois, esse princípio tornou-se um dos pilares da Engenharia de Software.


Matrix explica perfeitamente

Imagine duas versões da Matrix.

A primeira possui:

  • cinco componentes;

  • regras claras;

  • comunicação simples.

A segunda possui:

  • cinquenta frameworks;

  • cem microsserviços;

  • dezenas de filas;

  • múltiplas camadas;

  • configurações espalhadas.

Qual delas Neo conseguiria compreender primeiro?

Provavelmente a mais simples.


Simples não significa simplório

Esse é um dos maiores mal-entendidos.

KISS não significa fazer menos.

Significa fazer apenas o necessário.

Existe enorme diferença.


O COBOL nasceu seguindo KISS

Quando COBOL surgiu, seu objetivo era ser:

  • legível;

  • previsível;

  • próximo da linguagem humana.

Observe.

ADD VALOR
   TO SALDO.

Ou.

IF CLIENTE-ATIVO

Mesmo décadas depois.

Ainda conseguimos entender.

Essa clareza foi uma decisão arquitetural.


Como nasce a complexidade?

Ela raramente aparece de uma vez.

Primeiro surge um pequeno framework.

Depois outro.

Depois uma camada.

Depois uma abstração.

Depois uma exceção.

Anos depois.

Ninguém consegue explicar a arquitetura completa.


Matrix Reloaded

O Arquiteto mostra para Neo inúmeras versões anteriores da Matrix.

Cada uma tornou-se mais sofisticada.

Mas também mais difícil de controlar.

Quanto maior a complexidade.

Maior o número de efeitos colaterais.


O efeito psicológico

Existe um fenômeno curioso.

Profissionais iniciantes frequentemente acreditam que:

"Código complicado impressiona."

Profissionais experientes descobrem justamente o contrário.

Código simples impressiona muito mais.

Porque é difícil escrever algo realmente simples.


O Programador COBOL Padawan

Imagine duas soluções.

Primeira.

IF CLIENTE-ATIVO

Segunda.

IF CLIENTE-ATIVO
   AND WS-FLAG-01 = "S"
   OR WS-FLAG-02 = "N"
   AND WS-STATUS-XYZ NOT = ZERO
   ...

Qual será compreendida daqui a quinze anos?


O Agente Smith ama complexidade

Porque sistemas complicados escondem:

  • bugs;

  • inconsistências;

  • duplicações;

  • vulnerabilidades.

Quanto mais difícil entender.

Mais difícil corrigir.


Um exemplo inspirado na Matrix

Neo precisa abrir uma porta.

Versão simples.

Uma chave.

Versão complexa.

Quatro chaves.

Cinco senhas.

Três certificados.

Dois tokens.

Sete validações.

No final.

A porta continua sendo apenas uma porta.


O custo invisível

Complexidade gera:

  • treinamento maior;

  • documentação maior;

  • testes maiores;

  • manutenção maior;

  • risco maior.

Tudo cresce.


O impacto no Mainframe

Em ambientes IBM Z encontramos aplicações com quarenta anos de vida.

Sistemas assim sobrevivem porque muitos seguiram princípios como:

  • simplicidade;

  • modularização;

  • previsibilidade;

  • estabilidade.

Não porque eram sofisticados.


Curiosidade

Albert Einstein costuma receber a frase:

"Everything should be made as simple as possible, but not simpler."

Embora a autoria exata seja debatida, a ideia resume perfeitamente o KISS:

Simplifique.

Mas nunca elimine o essencial.


Quando KISS é ignorado?

Começam a surgir:

  • frameworks desnecessários;

  • padrões aplicados sem necessidade;

  • heranças enormes;

  • interfaces excessivas;

  • configurações infinitas.

Tudo para resolver problemas simples.


Um exemplo COBOL

Imagine um cálculo.

Versão simples.

COMPUTE TOTAL = PRECO * QUANTIDADE

Versão complicada.

Três programas.

Cinco CALLs.

Duas APIs.

Uma fila MQ.

Resultado idêntico.


Matrix e o Chaveiro

O Chaveiro representa uma lição interessante.

Ele cria chaves.

Não cem ferramentas.

Cada chave resolve exatamente um problema.

Essa é uma excelente representação do KISS.


Atenção!

KISS não significa evitar arquitetura.

Significa evitar arquitetura desnecessária.


A diferença

Arquitetura Elegante

Resolve o problema.


Arquitetura Complicada

Cria novos problemas.


O papel da simplicidade

Sistemas simples apresentam:

  • menos bugs;

  • menor custo;

  • maior previsibilidade;

  • onboarding mais rápido;

  • documentação menor.


Ferramentas ajudam

No universo IBM.

Ferramentas como:

  • IBM ADDI;

  • SonarQube;

  • COBOL Check;

  • Enterprise Analyzer;

ajudam a localizar:

  • duplicações;

  • complexidade ciclomática;

  • código morto;

  • módulos gigantes.


O papel da IA

A IA frequentemente sugere soluções sofisticadas.

Cabe ao engenheiro perguntar:

"Existe uma maneira mais simples?"

Essa talvez seja uma das perguntas mais importantes da profissão.


Os riscos

Quando KISS é ignorado.

Surgem:

  • overengineering;

  • manutenção cara;

  • dependências excessivas;

  • curva de aprendizado enorme;

  • baixa produtividade.


Erros clássicos

  • Adotar tecnologia apenas porque está na moda.

  • Aplicar Design Patterns em todo lugar.

  • Criar abstrações prematuras.

  • Usar cinco frameworks quando um resolveria.

  • Confundir inteligência com complexidade.


Boas práticas

  • Resolver primeiro o problema.

  • Medir antes de otimizar.

  • Escrever código legível.

  • Modularizar.

  • Eliminar duplicações.

  • Revisar continuamente.

  • Questionar toda nova dependência.


Aplicabilidade

KISS aparece em:

  • COBOL.

  • CICS.

  • Db2.

  • Java.

  • Python.

  • APIs.

  • Cloud.

  • Kubernetes.

  • Microsserviços.

  • IA.

É um princípio universal.


KISS e os outros princípios

Curiosamente.

KISS conversa diretamente com vários conceitos já vistos nesta série.

Ele reduz:

  • Spaghetti Code, porque incentiva clareza.

  • Lasagna Code, porque evita camadas desnecessárias.

  • Golden Hammer, porque escolhe apenas as ferramentas necessárias.

  • Big Ball of Mud, porque favorece organização.

  • Boiling Frog, porque dificulta o crescimento invisível da complexidade.

  • Death March, porque soluções simples costumam ser entregues e testadas mais rapidamente.

Não é apenas um princípio isolado.

É uma filosofia que influencia praticamente todos os demais.


O ensinamento do Oráculo

O Oráculo entrega dois mapas para Neo.

O primeiro possui centenas de símbolos.

Setas.

Anotações.

Cores.

Camadas.

O segundo mostra apenas três caminhos.

Neo escolhe imediatamente o segundo.

Ela sorri.

— Por quê?

Neo responde.

— Porque consigo entender para onde estou indo.

Ela coloca a mão sobre seu ombro.

"Um sistema que ninguém compreende deixa de servir às pessoas e passa a exigir que as pessoas sirvam a ele."


Lições para um Programador COBOL Padawan

Durante sua carreira você encontrará colegas extremamente inteligentes.

Alguns escreverão soluções impressionantes.

Mas observe atentamente os profissionais realmente admirados após vinte ou trinta anos de experiência.

Quase sempre eles possuem outra característica.

Escrevem programas fáceis de ler.

Escolhem nomes claros.

Criam módulos pequenos.

Documentam decisões.

Eliminam o desnecessário.

Esses profissionais sabem que a manutenção representa a maior parte do ciclo de vida de um software.

Quem simplifica hoje está ajudando um colega — ou a si mesmo — daqui a dez anos.


Curiosidades

O princípio KISS influenciou diretamente diversas metodologias modernas:

  • Agile, ao priorizar entregas simples e incrementais.

  • Extreme Programming (XP), com foco na solução mais simples que funciona.

  • YAGNI (You Aren't Gonna Need It), evitando funcionalidades imaginárias.

  • Lean Software Development, reduzindo desperdícios.

  • Unix Philosophy, que recomenda ferramentas pequenas fazendo uma única tarefa muito bem.

Embora tenham surgido em épocas diferentes, todas compartilham a mesma ideia: simplicidade gera sustentabilidade.


Conclusão — O Código Verde da Matrix Era Simples

Quando Neo finalmente enxergou o código verde da Matrix, ele percebeu que por trás de toda aquela realidade existiam padrões claros e elegantes.

Os sistemas mais duradouros seguem exatamente esse caminho.

O princípio KISS nos ensina que complexidade deve existir apenas quando ela é realmente necessária. Cada camada, cada framework, cada abstração e cada linha de código precisam justificar sua existência.

Para um Programador COBOL que trabalha com IBM Z, essa lição é ainda mais valiosa. Sistemas bancários, seguradoras e governos dependem de aplicações que continuarão sendo mantidas por décadas. Quanto mais simples, legíveis e previsíveis forem essas aplicações, maior será sua capacidade de evoluir sem perder confiabilidade.

No universo Bellacosa Mainframe existe uma máxima que certamente estaria escrita na parede da sala do Arquiteto:

"A verdadeira genialidade não está em criar uma Matrix impossível de compreender. Está em construir uma tão simples que qualquer Padawan consiga mantê-la funcionando mesmo cinquenta anos depois."

Porque, no fim, o software que atravessa gerações não é aquele que impressiona pela complexidade.

É aquele que continua resolvendo problemas quando todas as tecnologias da moda já ficaram para trás.