Boas Práticas Nathan Geeksman

Princípios YAGNI e DRY: Quando Aplicar?

Princípios YAGNI e DRY: Quando Aplicar?

Princípios YAGNI e DRY: Quando Aplicar?

Introdução

O desenvolvimento de software é um campo que evolui rapidamente, com novas tecnologias e abordagens surgindo constantemente. Nesse cenário dinâmico, os princípios YAGNI (You Ain't Gonna Need It) e DRY (Don't Repeat Yourself) se estabeleceram como referências fundamentais para a construção de sistemas escaláveis e manuteníveis.

Esses dois conceitos são frequentemente citados em discussões sobre boas práticas de programação, mas é comum encontrarmos projetos que não os aplicam corretamente ou nem sequer consideram a importância deles. Isso pode levar a código redundante, difícil de manter e propenso a erros.

Neste artigo, vamos explorar os princípios YAGNI e DRY em detalhes, explicando como eles devem ser aplicados na prática para maximizar a eficiência no desenvolvimento de software. Você aprenderá a identificar quando esses princípios são necessários e como incorporá-los ao seu processo de desenvolvimento para criar sistemas mais robustos e escaláveis.

O que é e por que importa

Os princípios YAGNI (You Ain't Gonna Need It) e DRY (Don't Repeat Yourself) são conceitos fundamentais na programação orientada a objetos, mas podem parecer confusos ou difíceis de aplicar para os iniciantes. No entanto, entendê-los corretamente é crucial para desenvolver sistemas escaláveis e fáceis de manter.

YAGNI visa evitar o excesso de funcionalidades no código, que pode se tornar um problema se não forem necessárias posteriormente. Esse princípio foi popularizado por Martin Fowler em 2004 e consiste basicamente em criar o mínimo necessário para resolver o problema atual. Isso inclui adicionar apenas as features necessárias e evitar a inclusão de funcionalidades que podem ser necessárias no futuro.

Por outro lado, DRY se concentra na eliminação da duplicidade de código em um projeto, garantindo que cada função ou método seja executado uma vez somente. Essa abordagem visa melhorar a manutenibilidade do sistema e reduzir o tempo gasto em correções. O DRY foi concebido para evitar o problema conhecido como "dupliques" onde informações são repetidas em diferentes partes da aplicação, dificultando a modificação do código sem causar problemas.

A motivação por trás desses princípios é simples: ao longo do tempo, sistemas que não seguem essas diretrizes tendem a se tornar cada vez mais complexos e difíceis de manter. A duplicidade no código pode levar a erros e corrupção de dados, já que pequenas alterações podem ter consequências inesperadas em outras partes do sistema.

Além disso, esses princípios contribuem para uma programação mais eficiente e escalável. Ao evitar o excesso de funcionalidades desnecessárias, os sistemas se tornam menores e mais fáceis de manter, o que é fundamental para projetos que necessitam mudar frequentemente ou lidar com grandes volumes de dados.

Como funciona na prática

Para aplicar os princípios YAGNI e DRY, é fundamental seguir uma abordagem sistemática que envolva desde a concepção do projeto até a manutenção dele ao longo do tempo. Aqui estão as etapas para implementá-los:

Identificar Necessidades Reais

  • Antes de começar a escrever código, é essencial definir precisamente o problema que se deseja resolver.
  • Analise requisitos e especifique funcionalidades necessárias com base nos requisitos identificados.

Aplicação do YAGNI

  • Crie apenas as funcionalidades mínimas necessárias para atender aos requisitos especificados.
  • Evite a inclusão de funcionalidades que não são atualmente necessárias, mesmo que sejam potencialmente úteis no futuro.

Implementação do DRY

  • Ao implementar novas funcionalidades, busque evitar duplicações de código existentes em outras partes da aplicação.
  • Identifique pontos onde o código pode ser reutilizado e aplique a solução única para todos esses casos.

Manutenção Contínua

  • Mantenha uma documentação atualizada das funcionalidades implementadas e dos códigos utilizados.
  • Ao realizar alterações no sistema, faça um mapeamento da área afetada e verifique se não há outras partes do código que também precisem ser modificadas.

Análise Continua

  • Desenvolva práticas de Code Review para garantir que novas implementações estejam alinhadas com os princípios YAGNI e DRY.
  • Mantenha uma visão geral das funcionalidades implementadas no sistema, buscando oportunidades para melhorar a eficiência do código ao longo do tempo.

Essa abordagem sistemática garantirá que você esteja aplicando de forma eficaz os princípios YAGNI e DRY em seu projeto.

Exemplo real

Código de exemplo: Calculadora de imposto sobre a renda

// Definição da classe para calcular o imposto sobre a renda
public class ImpostoSobreRenda {
    public static double calcularImposto(double salarioBruto) {
        // Definindo os percentuais de imposto sobre a renda
        final double ALÍQUOT_MÍNIMO = 15000.0;
        final double PERCENTUAL_ALÍQUOT_MÍNIMO = 5.0 / 100.0;

        final double SALÁRIO_LÍSQUARE = 25000.0;
        final double PERCENTUAL_SALÁRIO_LÍSQUARE = 10.0 / 100.0;

        // Definindo o cálculo do imposto sobre a renda
        if (salarioBruto <= ALÍQUOT_MÍNIMO) {
            return salarioBruto * PERCENTUAL_ALÍQUOT_MÍNIMO;
        } else if (salarioBruto > SALÁRIO_LÍSQUARE) {
            return salarioBruto * 20.0 / 100.0;
        } else {
            double impostoMínimo = ALÍQUOT_MÍNIMO * PERCENTUAL_ALÍQUOT_MÍNIMO;
            double impostoSalarial = (salarioBruto - ALÍQUOT_MÍNIMO) * PERCENTUAL_SALÁRIO_LÍSQUARE;

            return impostoMínimo + impostoSalarial;
        }
    }

    public static void main(String[] args) {
        // Exemplo de uso da classe
        System.out.println("Imposto sobre a renda: " + calcularImposto(20000.0));
        System.out.println("Imposto sobre a renda: " + calcularImposto(100000.0));
    }
}

Nesse exemplo, aplicamos o princípio YAGNI ao criar apenas as funcionalidades necessárias para calcular o imposto sobre a renda, evitando a inclusão de cálculos desnecessários ou futuros. Além disso, utilizamos o princípio DRY ao evitar duplicações de código existentes em outras partes da aplicação, identificando e reutilizando soluções únicas para todos os casos necessários.

O código acima demonstra como a implementação dos princípios YAGNI e DRY pode ser efetiva no desenvolvimento de sistemas, simplificando a manutenção e melhorando a eficiência do código ao longo do tempo.

Boas práticas

DRY e fatoração de cálculos

  • Fatorar cálculos complexos em funções separadas, tornando o código mais modular e reutilizável.
  • Evitar a repetição de código ao máximo possível.

Armadilhas comuns

  • O YAGNI é sinônimo de "não fazer": Embora seja verdade que a implementação do YAGNI evite a inclusão de funcionalidades desnecessárias, é fundamental lembrar que o desenvolvimento deve seguir um ciclo contínuo de melhoria, onde o cunho prático permite incorporar futuras necessidades com agilidade.
  • A tentação de "sobrecargar" métodos: Ao aplicar o princípio DRY em excesso, é fácil acabar sobrecarregando os métodos com lógica demais. Para evitar isso, é importante manter as responsabilidades claramente definidas e evitando a adição de condicionais desnecessários.

Conclusão

Aplicar os princípios YAGNI e DRY é crucial para desenvolver sistemas escaláveis, manuteníveis e eficientes ao longo do tempo. Ao priorizar a simplicidade e modularidade do código, facilita-se a identificação de problemas e melhorias futuras, evitando-se duplicações de cálculos desnecessários.

Para prosseguir com a aplicação desses princípios em projetos, é importante continuar monitorando o código e implementar mudanças incrementais, mantendo um equilíbrio entre simplicidade e funcionalidade. Além disso, é recomendável buscar melhores práticas de fatoração de cálculos e manter um ambiente de desenvolvimento colaborativo para identificar áreas que necessitam de melhoria.

Aprofundar no estudo da programação orientada a objetos (POO) e do design de padrões pode ajudar na implementação desses princípios, pois os torna mais eficazes em projetos complexos. Além disso, revisitar conceitos relacionados a refatoração e reestruturação de código é fundamental para garantir que as melhorias não sejam apenas superficiais, mas sim estruturais.

Referências

  • Fowler, M. Don't Repeat Yourself. Disponível em: https://martinfowler.com/bliki/DonKey.html. Acesso: 2024.
  • "Princípio YAGNI" na documentação do Thoughtworks. Disponível em: https://www.thoughtworks.com/pt-br/blog/principio-yagni. Acesso: 2024.
  • Martin Fowler, Refatoração. Disponível em: https://martinfowler.com/books/refactoring.html. Acesso: 2024.
  • "Princípios DRY e YAGNI" na documentação do MDN. Disponível em: https://developer.mozilla.org/pt-BR/docs/Glossary/DRY. Acesso: 2024.
  • 12factor, Principios Fundamentais para Desenvolvimento de Aplicações. Disponível em: https://12factor.net/pt_br/build-stages-guidelines. Acesso: 2024.