Quando começamos nos primeiros passos na programação, é comum focar apenas em fazer o código funcionar. Pois o objetivo do que vem antes é entender a lógica, a sintaxe e os conceitos básicos da programação. Ao longo de todos esses anos ministrando disciplinas de introdução à lógica e aos rudimentos da programação, eu já adotei diversas estratégias de ensino. Desde o uso de fluxogramas para o entendimento dos algoritmos, passando pelos pseudocódigos (linguagens como portugol, etc), até que me convenci que é melhor estabelecer certos padrões de qualidade para ficarem encrustados à cultura do futuro programador. Assim, há tempos tomei duas decisões, a primeira é usar uma linguagem de programação desde o primeiro dia. Segundo, passei a ensinar o Clean code aos iniciantes desde o dia um. Neste post, vou explicar por que essa abordagem é fundamental e como ela impacta positivamente a jornada de aprendizado e a carreira dos programadores.

O que é Clean Code?

Clean Code, ou código limpo, é um conceito popularizado por Robert C. Martin (Uncle Bob) em seu livro de mesmo nome, que enfatiza a escrita de código que seja fácil de entender, modificar e manter. Isso inclui:

• Nomes claros e significativos para variáveis, funções e classes.
• Estrutura lógica e simples.
• Comentários apenas quando necessários.
• Evitar duplicação e complexidade desnecessária.
• Organização consistente e legível.

Por que ensinar Clean Code desde o início?

1. Cria bons hábitos desde o começo
   Aprender a programar é como aprender um novo idioma. Se você começar falando errado, vai ser difícil corrigir depois. Ensinar Clean Code desde o primeiro contato ajuda o aluno a desenvolver bons hábitos que serão naturais e automáticos no futuro.
2. Facilita o entendimento e a colaboração
   Mesmo que o aluno esteja escrevendo código só para si, a clareza é essencial. Quando o código é limpo, fica mais fácil revisar, corrigir erros e expandir funcionalidades. Além disso, em projetos reais, a colaboração é inevitável, e um código limpo é a base para um trabalho em equipe eficiente.
3. Reduz a frustração e o retrabalho
   Código confuso gera bugs difíceis de encontrar e corrige. Ensinar Clean Code ajuda a evitar esses problemas, tornando o aprendizado mais fluido e menos frustrante.
4. Prepara para o mercado de trabalho
   Empresas valorizam profissionais que escrevem código limpo porque isso economiza tempo e dinheiro. Ao aprender Clean Code desde cedo, o aluno já se destaca e está mais preparado para desafios reais.

Minha filosofia de ensino: aprender fazendo, com qualidade

Eu acredito que o aprendizado de programação deve ser prático, mas nunca às custas da qualidade. Por isso, desde o primeiro exercício, incentivo os alunos a:

• Escolher nomes que façam sentido.
• Dividir o código em funções pequenas e com responsabilidades claras.
• Refatorar o código sempre que possível.
• Escrever código que eles mesmos gostariam de ler no futuro.

Além disso, uso exemplos reais e situações do dia a dia para mostrar que Clean Code não é meramente um amontoado de regras vazias, mas uma ferramenta poderosa para programar melhor e com mais prazer.

Vamos tomar como exemplo a função ‘faz_algo()’ a seguir:

def faz_algo(x, y):
    a = x * 2
    b = y + 10
    c = a + b
    print(c)
    d = []
    for i in range(x):
        if i % 2 == 0:
            d.append(i)
    return d

resultado = faz_algo(5, 3)
print(resultado)

Problemas desta função:

1. Nomes não descritivos (faz_algo, x, y, a, b, c, d)
2. Faz duas operações não relacionadas (cálculo e filtragem de números pares)
3. Tem um efeito colateral (print) além de retornar um valor
4. Não tem tipagem de parâmetros ou retorno

Versão Refatorada com Clean Code

from typing import List

def calculate_combined_value(multiplier: int, additive: int) -> int:
    """Calcula um valor combinado com base nos parâmetros de entrada.
    
    Argumentos:
        multiplier: O número a ser duplicado.
        additive: O número a ser aumentado em 10.
        
    Retorna:
        O resultado de (multiplier * 2) + (additive + 10)
    """
    doubled_value = multiplier * 2
    increased_value = additive + 10
    return doubled_value + increased_value

def get_even_numbers_up_to(limit: int) -> List[int]:
    """Gera uma lista de números pares até o limite especificado.
    
    Argumentos:
       limite: O limite superior (exclusivo) para os números pares.

   Retorna:
        Uma lista de números pares de 0 até (mas não incluindo) o limite.
    """
    return [num for num in range(limit) if num % 2 == 0]

# Exemplo de uso
if __name__ == "__main__":
    # Cálculo do valor combinado
    result = calculate_combined_value(multiplier=5, additive=3)
    print(f"Calculated value: {result}")
    
    # Obtenção de números pares
    even_numbers = get_even_numbers_up_to(limit=5)
    print(f"Even numbers up to 5: {even_numbers}")

Princípios do Clean Code aplicados:

1. Single Responsibility Principle: Cada função faz apenas uma coisa
   • calculate_combined_value: apenas cálculos matemáticos
   • get_even_numbers_up_to: apenas geração de números pares
2. Nomes significativos:
   • Os nomes das funções e parâmetros deixam claro seu propósito
3. Tipagem explícita:
   • Uso de type hints para documentar os tipos esperados
4. Docstrings completas:
   • Documentação clara do propósito, parâmetros e retorno
5. Simplicidade:
   • Cada função é simples e fácil de entender
   • Uso de list comprehension para clareza
6. Sem efeitos colaterais:
   • As funções apenas retornam valores (exceto pelo print no bloco principal)
7. Organização lógica:
   • Separação clara entre as operações matemáticas e a geração da lista

Esta versão é muito mais fácil de:

• Manter
• Testar (podem ser testadas isoladamente)
• Reutilizar (cada função tem um propósito específico)
• Compreender (os nomes e estrutura são auto-explicativos)

Boas práticas que ensino desde o início

• Nomes descritivos: Variáveis e funções devem ter nomes que expliquem seu propósito.
• Funções pequenas: Cada função deve fazer uma coisa só, e fazê-la bem.
• Evitar duplicação: Reutilizar código para evitar erros e facilitar manutenção.
• Comentários úteis: Usar comentários para explicar “porquê”, não “o quê”.
• Indentação e espaçamento: Código bem formatado é mais fácil de ler.
• Testes simples: Introduzir a ideia de testar o código para garantir que funciona.

Conclusão

Ensinar Clean Code desde os primeiros contatos com programação é um investimento que traz retorno imediato e a longo prazo. Ajuda o aluno a construir uma base sólida, evita maus hábitos e prepara para o mercado de trabalho. Mais do que ensinar a programar, ensino a programar bem — com clareza, organização e responsabilidade.

Se você está começando a aprender programação, ou é professor, experimente incorporar o Clean Code desde o início. Você vai se surpreender com a diferença que isso faz!

Se quiser, posso lhe ajudar a criar um roteiro para uma aula ou um workshop sobre Clean Code para iniciantes. Quer?