O que Uncle Bob me Ensinou sobre Clean Code (e Como Isso Mudou Minha Forma de Programar)

Escrever código é fácil. Escrever código limpo, legível e sustentável é um desafio. Quem já precisou lidar com código confuso sabe o quanto isso pode ser um pesadelo. Foi nesse contexto que os ensinamentos de Robert C. Martin, mais conhecido como Uncle Bob, fizeram toda a diferença para mim. O livro Clean Code mudou minha forma de programar, e neste artigo compartilho sete princípios fundamentais que aprendi e aplico no meu dia a dia.

Clean Code na Prática: Lições Valiosas que Aprendi com Uncle Bob

1. Nomes Significativos e Expressivos

Nomes importam. Variáveis, funções e classes devem ter nomes que comuniquem claramente sua intenção. Ao invés de algo como:

let d = new Date();

Prefira:

let currentDate = new Date();

Isso melhora a legibilidade e reduz a necessidade de comentários desnecessários. Um código que se explica por si só é um código limpo.

2. Funções Pequenas e com uma Única Responsabilidade

Funções devem fazer apenas uma coisa e fazê-la bem. Se você precisa descrever uma função com um "e", provavelmente ela está fazendo mais do que deveria:

function processPayment(user, amount) {
    validateUser(user);
    calculateDiscount(user);
    chargeUser(user, amount);
    sendConfirmationEmail(user);
}

Essa função tem múltiplas responsabilidades. Podemos quebrá-la em funções menores:

function processPayment(user, amount) {
    if (!validateUser(user)) return;
    const finalAmount = calculateDiscount(user, amount);
    chargeUser(user, finalAmount);
    notifyUser(user);
}

Isso torna o código mais modular, reutilizável e fácil de testar.

3. Evite Comentários Desnecessários

Comentários são úteis quando explicam por que algo foi feito, não o que está sendo feito. Se o código precisar de um comentário para ser entendido, ele provavelmente não está limpo. Compare:

// Verifica se o usuário tem permissão
if (user.role === 'admin') {
    allowAccess();
}

Com um código autoexplicativo:

const isAdmin = user.role === 'admin';
if (isAdmin) allowAccess();

Sempre que possível, faça o código falar por si só.

4. Reduza Dependências e Evite Código Repetitivo (DRY - Don't Repeat Yourself)

A duplicação de código aumenta a complexidade e dificulta a manutenção. Se você percebe padrões se repetindo, encapsule-os em uma função:

function calculateFinalPrice(price, discount) {
    return price - (price * discount);
}

const productA = calculateFinalPrice(100, 0.1);
const productB = calculateFinalPrice(200, 0.2);

Isso evita a repetição de lógica e facilita a manutenção.

5. Utilize Estruturas de Controle Simples

Evite aninhamentos profundos, que tornam o código difícil de entender. Veja este exemplo ruim:

if (user) {
    if (user.isActive) {
        if (user.hasPermission) {
            grantAccess();
        }
    }
}

Reescrevendo de forma mais limpa:

if (!user || !user.isActive || !user.hasPermission) return;
grantAccess();

Isso torna a leitura mais fluida e o código mais elegante.

6. Teste Seu Código

Código limpo não é apenas legível, mas também confiável. Escrever testes automatizados ajuda a garantir que as funções fazem o que deveriam. Por exemplo, um teste para a função calculateFinalPrice poderia ser:

test('calculateFinalPrice should apply discount correctly', () => {
    expect(calculateFinalPrice(100, 0.1)).toBe(90);
    expect(calculateFinalPrice(200, 0.2)).toBe(160);
});

Isso evita que futuras alterações introduzam bugs sem que percebamos.

7. Refatoração Contínua

Código limpo não nasce pronto, ele é refinado com o tempo. A refatoração deve ser uma prática contínua para manter o código simples e eficiente. Se algo pode ser melhorado, faça!

Considere este exemplo:

function getUserFullName(user) {
    return user.firstName + ' ' + user.lastName;
}

Podemos refatorar usando template literals:

function getUserFullName(user) {
    return `${user.firstName} ${user.lastName}`;
}

Pequenas melhorias acumuladas fazem grande diferença na qualidade do código.

Conclusão

Aprender Clean Code com Uncle Bob mudou minha perspectiva sobre desenvolvimento. Aplicar esses princípios resulta em código mais legível, manutenível e sustentável. No fim, código limpo não é apenas um favor para os outros desenvolvedores — é um presente para o nosso eu do futuro.

Que tal começar a aplicar essas práticas no seu código hoje? 🚀