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?

2:00 PM – Professor, estou querendo descobrir o valor máximo e o menor valor de um array de números. Já tentei usar essas funções max e min que tem na biblioteca Math e nada.
vou mandar meu código pro senhor ver, ah desculpa enviar isso a uma hora dessa.

let notas = [6.5, 4.3, 8.75, 9, 3];
Math.max(notas);
Math.min(notas);

2:01 PM A resposta que sai é NaN. Help me!

Já vi daqui o seu problema, jovem chimpanzé, e vou te ajudar a encontrar a melhor solução! Mas antes temos que considerar algumas coisas sobre as funções max e min da biblioteca Math:

1. Ambas precisam que números sejam passados como argumentos, caso não seja passado nenhum, o resultado será -Infinity (max) ou Infinity(min).
2. Caso algum dos argumentos passados não possa ser convertido para número o retorno é NaN.
   

No seu caso, você está tentando passar um array, vamos considerar três alternativas, e a última eu acho que é mais bacana.

1 – Utilizando o método reduce()

esqueleto do método:
array.reduce((s, a)=> ‘operação com s e a’);

Em geral o método reduce() é utilizado para somar todos os elementos de um array. Mas, no seu caso, podemos utilizá-lo para comparar par por par de elementos do array e ficar só com o menor ao final. da seguinte forma:

2 – usando o apply : O ES6/ES2015 ajudando de montão.

Essa é a hora de você dizer “E era só isso?”.
Indica-se que deva ser usado em arrays com poucos elementos, mas o melhor está ainda por vir, o terceiro modo é um filezinho.

3 – Três pontinhos do poder 😀

Nobre, entenda que todo o problema residia no fato de você estar tentando desde o início empurrar um array pela goela do Math.max() e do seu irmão Math.min(). A partir de agora você vai espalhar os elementos do array dentro desse método utilizando o spread operator.

e voilá, meu amigo. Em outra postagem falarei mais sobre o poder do spread operator, usos, aplicações e sobre seu gêmeo o rest operator.

Todo o diálogo foi fictício porém baseado em fatos reais.

Sem mais delongas, para instalar o Node no Ubuntu e já sair criando uns backends marotos use o apt para essa tarefa.

Para dar certo o que o tio vai mostrar nesse tuto voce deve se certificar que está usando o Ubuntu 20.XX. Abra o terminal e siga os passos que se seguem.

Passo 1 – Atualizar a lista de versões dos pacotes disponíveis

$ sudo apt update

Passo 2 – Instalar o Node.JS

$ sudo apt install nodejs

Passo 3 – checar se o Node está resalmente instadado, e qual a versão.

$ node -v

Voilá, já está pronto para o uso do rebento!