Code Smells: Como identificar e prevenir os Code Bloaters

Ao desenvolver um software, é comum nos depararmos com questionamentos sobre a qualidade do código que estamos escrevendo. Buscamos aplicar algumas regras básicas para tornar o nosso código mais eficiente e fácil de manter. No entanto, nem sempre seguimos essas regras, principalmente quando estamos começando ou não temos muita experiência técnica. Muitas vezes, nos preocupamos apenas em fazer o código funcionar, sem considerar a sua manutenção futura ou o trabalho que deixaremos para outros desenvolvedores.

O que são Code Smells?

Code Smells, ou "maus cheiros de código", são práticas comuns no desenvolvimento de software que podem causar problemas. São partes do código que nos fazem pensar: "Isso vai dar problema". Alguns Code Smells são tão evidentes que vêm acompanhados de comentários destacados, como se estivessem protegendo o bloco de código com a frase: "Tomar cuidado ao mexer no código abaixo!!!!!". Quando você "sente esse cheiro", parabéns, você identificou um Code Smell.

Como Martin Fowler diz: "Os melhores Code Smells são aqueles que são fáceis de identificar e, na maioria das vezes, levam a problemas realmente interessantes."

Code Bloaters

Neste artigo, vamos falar especificamente sobre Code Bloaters, que são um tipo de Code Smell. Os Code Bloaters são os sinais mais comuns de maus odores no código. Eles não surgem da noite para o dia, mas à medida que alimentamos classes e métodos de forma descontrolada, eles se tornam gigantescos. Na minha opinião, esses são os casos mais difíceis de refatoração.

Para identificá-los, basta dar uma olhada no seu código e verificar se existem métodos longos, classes extensas (aquelas com milhares de linhas de código), partes do código com um conjunto de variáveis idênticas (conhecidos como Data Clumps), comentários desnecessários ou duplicação de código.

Classes ou métodos grandes

Um Code Bloater comum é uma classe ou método que se torna muito extenso. Isso dificulta a compreensão e manutenção do código. Classes grandes geralmente possuem muitas responsabilidades e podem ser divididas em classes menores e mais especializadas. Métodos grandes podem ser fragmentados em métodos menores e mais específicos, facilitando a leitura e a reutilização do código.

class Order {
    // Propriedades e métodos da classe

    public function calculateTotalAmount() {
        // Cálculos complexos para obter o total do pedido
        // ...
    }

    public function printOrderDetails() {
        // Impressão dos detalhes do pedido
        // ...
    }

    // Mais métodos...
}

Métodos com muitas responsabilidades

Outro Code Bloater comum é um método que realiza várias tarefas diferentes. Isso viola o princípio da responsabilidade única, onde cada método deve ter uma única responsabilidade bem definida.

class ShoppingCart {
    // ...

    public function checkout() {
        // Validação do carrinho de compras
        // Cálculo do total
        // Geração do pedido
        // Atualização do estoque
        // Envio de e-mails de confirmação
        // ...
    }

    // ...
}

Nesse caso, o método checkout() realiza várias etapas, desde a validação do carrinho até o envio de e-mails de confirmação. Seria mais adequado dividir essas responsabilidades em métodos separados, como validateCart(), calculateTotal(), generateOrder(), updateInventory() e sendConfirmationEmails().

Comentários desnecessários

Comentários em excesso e desnecessários também podem indicar a presença de Code Bloaters. Um código limpo e bem estruturado deve ser autoexplicativo na maioria das vezes. Os comentários devem ser utilizados para explicar a intenção do código, não para explicar o que o código está fazendo.

// Obtém o nome do cliente
$name = $customer->getName();

Nesse caso, o comentário é redundante, pois o código em si já é autoexplicativo.

Duplicação de código

A presença de código duplicado, também conhecido como "código clone", é outro exemplo de Code Smell. A duplicação torna a manutenção mais difícil, uma vez que qualquer alteração precisa ser feita em várias partes do código.

class ProductService {
    // ...

    public function calculateDiscountedPrice($price, $discount) {
        $discountedPrice = $price - ($price * $discount / 100);
        return $discountedPrice;
    }

    public function calculateSpecialPrice($price, $specialDiscount) {
        $specialPrice = $price - ($price * $specialDiscount / 100);
        return $specialPrice;
    }

    // ...
}

Essa duplicação pode ser evitada criando um único método genérico para calcular o preço com desconto, aceitando o desconto como parâmetro.

Data Clumps

Os Data Clumps são conjuntos de variáveis idênticas ou semelhantes que aparecem repetidamente em várias partes do código. Essa repetição indica uma falta de abstração adequada.

class Customer {
    public $name;
    public $email;
    public $phone;
    public $address;
}

class Order {
    public $customerName;
    public $customerEmail;
    public $customerPhone;
    public $customerAddress;

    // ...
}

Seria mais adequado criar uma única classe Customer e referenciá-la na classe Order, evitando a duplicação e melhorando a organização dos dados.

Conclusão

Identificar e prevenir Code Bloaters é essencial para manter um código limpo, eficiente e fácil de manter. Ao aplicar boas práticas de programação e realizar refatorações adequadas, podemos evitar esses Code Smells e melhorar a qualidade do nosso código.

Lembre-se sempre das palavras de Martin Fowler: "Os melhores Code Smells são aqueles que são fáceis de identificar e, na maioria das vezes, levam a problemas realmente interessantes."

Referências

• Martin Fowler, "CodeSmell": martinfowler.com/bliki/CodeSmell.html
• Sourcemaking
• Uncle Bob, "Clean Code: A Handbook of Agile Software Craftsmanship" (2008)

Fonte: Publicado originalmente no Medium