70% do tempo do desenvolvedor é lendo código. Veja como reduzir com Clean Code

Introdução

Olá, devs! Sabiam que cerca de 70% do nosso tempo é gasto lendo e entendendo código, enquanto apenas 30% é realmente codando?

De acordo com um estudo realizado por Bin Lin e Gregorio Robles (https://cs.paperswithcode.com/paper/investigating-the-impact-of-vocabulary), os desenvolvedores passam a maior parte do tempo compreendendo o código fonte durante o desenvolvimento de software.

O estudo destaca que a facilidade de compreensão do código proporciona vários benefícios, como facilitar revisões de código e acelerar o processo de integração de novos desenvolvedores no projeto. Além disso, o renomado autor de Clean Code, Uncle Bob, afirma que em sistemas legados essa proporção pode ser ainda maior, chegando a 10:1. Técnicas de Clean Code são essenciais para melhorar nossa produtividade e eficiência.

Vamos explorar como isso pode fazer a diferença.

Técnica 1: Nomes Significativos

Nomes significativos são fundamentais para a clareza do código.

Utilizar nomes claros e descritivos para variáveis, funções e classes ajuda a entender rapidamente o propósito e a funcionalidade de cada elemento. 

Evite abreviações e prefira termos que expressem claramente a intenção do código.

// Bad example
public void Calc(int d)
{
    var r = d * 1.19;
    Console.WriteLine(r);
}

// Good example
public void CalculateTotalPrice(int basePrice)
{
    const decimal taxRate = 0.19m;
    decimal totalPrice = basePrice * (1 + taxRate);
    Console.WriteLine(totalPrice);
}

Técnica 2: Métodos Pequenos

Manter métodos curtos e específicos é uma prática essencial de Clean Code. Essa abordagem também é fundamental na Clean Architecture para garantir que cada componente tenha uma responsabilidade única.

Métodos pequenos são mais fáceis de ler, entender e testar. Eles devem fazer apenas uma coisa e fazer bem.

Se um método está fazendo mais de uma tarefa, considere dividi-lo em métodos menores.

Essa abordagem não só melhora a legibilidade, mas também facilita a manutenção e a reutilização do código.

Técnica 3: Formatação Consistente

A formatação consistente do código ajuda a manter a organização e a legibilidade.

Siga um padrão de formatação definido e utilize ferramentas de linting para garantir a conformidade. Indentação, espaçamento e quebra de linhas são aspectos importantes a serem considerados.

Além disso, técnicas como o fail fast e evitar aninhar if-else ajudam a deixar o código mais claro e compreensível. Veja abaixo a diferença de legibilidade entre dois métodos somente reposicionando o retorno e evitando aninhamento de ifs.

// Bad example
public void ProcessUser(User user)
{
    if (user is not null)
    {
        if (user.HasSubscription)
        {
            if (user.Age >= 18)
            {
                ShowFullVersion();
            }
            else
            {
                ShowChildVersion();
            }
        }
        else
        {
            throw new Exception("User needs a subscription");
        }
    }
    else
    {
        throw new Exception("No user found");
    }
}

// Good example
public void ProcessUser(User user)
{
    if (user is null)
        throw new Exception("No user found");

    if (!user.HasSubscription)
        throw new Exception("User needs a subscription");

    if (user.Age >= 18)
    {
        ShowFullVersion();
        return;
    }

    ShowChildVersion();
}

Técnica 4: Princípio DRY (Don't Repeat Yourself)

O princípio DRY sugere que você não deve duplicar código desnecessariamente. Reutilize funções e métodos sempre que possível.

Isso não só reduz a quantidade de código, mas também facilita a manutenção e a atualização.

// Bad example
public decimal CalculateCustomerDiscount(decimal amount, decimal discount)
{
    return amount - (amount * (discount / 100));
}

public decimal CalculateProductDiscount(decimal amount, decimal discount)
{
    return amount - (amount * (discount / 100));
}

// Good example
public decimal CalculateDiscount(decimal amount, decimal discount)
{
    return amount - (amount * (discount / 100));
}

public decimal CalculateCustomerDiscount(decimal amount, decimal discount)
{
    return CalculateDiscount(amount, discount);
}

public decimal CalculateProductDiscount(decimal amount, decimal discount)
{
    return CalculateDiscount(amount, discount);
}

Técnica 5: Refatoração Contínua

Refatorar o código regularmente é uma prática importante para manter o código limpo e eficiente.

Revise e melhore o código continuamente, corrigindo problemas e simplificando a estrutura conforme necessário.

A refatoração ajuda a evitar a degradação do código ao longo do tempo, garantindo que ele permaneça compreensível e fácil de modificar. Incorporar a refatoração como uma atividade contínua no seu fluxo de trabalho pode prevenir a acumulação de “dívida técnica”.

Conclusão

Aplicar essas técnicas de Clean Code pode reduzir significativamente o tempo gasto lendo e entendendo código.

Adotar essas práticas no seu dia a dia tornará o código mais legível, fácil de manter e melhorará sua produtividade.

Invista tempo em escrever código limpo e colha os benefícios a longo prazo.

Até!

Assine
Assine