Cenário

As aulas são conduzidas em um laboratório com computadores desktop, com uma turma de aproximadamente 18 pessoas do curso de Ciência da Computação. Os alunos tinham conhecimentos desnivelados de programação: alguns já atuavam profissionalmente, enquanto outros estavam dando os primeiros passos na área.

Preparação

Uma aula antes da aplicação da Programação por Pares foi dedicada a uma atividade de nivelamento. É importante perceber que, para cada experiência, você pode encontrar um cenário diferente; aí entra a sensibilidade do professor para preparar bem os alunos para a atividade.
Nessa atividade niveladora em particular, revisitamos os conceitos de listas em Python, fizemos operações com listas, laços, condicionais, list comprehension e funções lambda. Dessa forma, no encontro seguinte haveria menos lacunas a preencher.
O material para esta aula está documentado neste link do GitHub:

Aplicação da técnica

A Programação por Pares consiste em dois programadores trabalhando juntos em uma única máquina, compartilhando o teclado e o mouse, e escrevendo código de forma colaborativa. Um programador atua como “motorista” (ou driver), escrevendo o código, enquanto o outro atua como “navegador” (ou observer), revisando o código em tempo real, dando sugestões e identificando potenciais erros. Os papéis são alternados regularmente.
Costumo dar um tempo de 7 a 10 minutos por rodada até que ocorra a troca de papéis. No dia a dia profissional, essa técnica em geral é aplicada por dois colegas que alternam entre si. Entretanto, na minha aula promovo um rodízio de duplas, para incentivar a integração entre todos os participantes. Assim, ao final de cada rodada, os navegadores mudam para a estação à direita, e os drivers para a estação à esquerda. Na nova estação, eles alternam os papéis: quem era driver passa a ser navegador e vice-versa.

Resultado

Nessa experiência em particular, foram realizadas oito rodadas com tempo variando de 7 a 10 minutos. Ao final, os participantes compartilharam suas impressões, destacando os pontos positivos e os desafios da atividade de programar em duplas.
As respostas foram diversas, entre aspectos positivos e pontos de estranhamento:

• Dificuldade em continuar a atividade ao mudar de estação e se deparar com código feito por outra pessoa;
• Duplas bem afinadas eram desfeitas, e uma nova relação precisava ser construída rapidamente;
• Com as novas interações, habilidades foram adquiridas, assim como novas formas de abordar problemas;
• A comunicação nem sempre era eficaz em algumas duplas;
• O receio inicial de “não saber programar direito” foi superado com o apoio do navegador.

Ao final, desafiei os alunos a aplicar a técnica em projetos pessoais, utilizando ferramentas de teletrabalho com chamada de vídeo e compartilhamento de telas. Julgo que isso os prepara para compor equipes de desenvolvimento de software com mais confiança para enfrentar os desafios do dia a dia.

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?

Já parou pra pensar sobre se as coisas que você sabe são entendidas da mesma forma pelas pessoas a sua volta? Tipo quando duas pessoas falam sobre Futebol, ou pirâmides ou sobre video game, as imagens mentais feitas por cada um são as mesmas? De cara a resposta é não, o modo como vemos as coisas depende muito de quem somos ou do que vivemos, ficou confuso? pois é, é o cérebro fazendo cócegas, isso é um ótimo sinal.

Charles Peirce, um doidera americano e estudioso de Semiótica e simbologia em geral, afirmou que as pessoas exprimem o contexto a sua volta a partir de uma tríade:

SIGNO – INTERPRETANTE – OBJETO

Entenda o signo como a centelha do pensamento, aquilo que ativa o modo como você vai pensar sobre algo, é a parte perceptível e representada de alguma coisa. O interpretante é o modo como cada um dos envolvidos vai entender o assunto, e o objeto é a coisa em si.

Por exemplo: Se em uma conversa alguém chamar você para tomar um sorvete, a palavra sorvete é o signo, a imagem mental que você e quem te convidou fizeram do sorvete é o interpretante, essa imagem é diferente de pessoa para pessoa, e o objeto é o sorvete propriamente dito.

Os signos, para Peirce também são uma tríade a parte formado por

ÍCONE – ÍNDICE – SÍMBOLO

O ícone é uma imagem mental, é uma representação que mais se aproxima esteticamente do objeto. Já o índice, como o próprio nome sugere, são indícios da ocorrência daquele objeto ou fenômeno. Por fim, o símbolo seria o modo mais abstrato de representar algo, normalmente é o nome, e a essa altura você já sacou que um mesmo objeto pode ter nomes diferentes em diferentes lugares do globo, ou seja abstrações mil.

Por exemplo:
Objeto ou fenômeno: Chuva.
Ícone: Desenho de uma nuvem com gotas.
Índice: Nuvens escuras no horizonte, indicando que vai chover.
Símbolo: A própria palavra CHUVA

Este texto é fruto de uma aula de semiótica que ministrei a uma turma de Jogos Digitais. Como reflexão, debatemos sobre o papel dos elementos da semiótica de Peirce para o enriquecimento e coerência dos assets e ambientes dos jogos digitais.
Se quiser ver mais tirinhas, mais artes resultantes das aulas, basta ir lá no insta @profpabloramon.