1. Preparação da revisão

Antes de começar a revisar, alinhe o objetivo da mudança e o impacto esperado em performance. Uma revisão bem preparada reduz ruído e acelera o ciclo de feedback.

• Contexto claro: entenda o problema que a mudança se propõe a resolver (issue, user story ou ticket).
• Diff enxuto: confirme que as alterações estão diretamente relacionadas ao objetivo; se necessário, separe em PRs menores.
• Conformidade com guias de estilo: verifique aderência a padrões do projeto ( nomenclaturas, formatação, estruturas de dados escolhidas ).
• Critérios de desempenho: identifique métricas relevantes (tempo de execução, memória, I/O, latência de chamadas externas) para validação.
• Benchmark local: rode cenários simples para ter uma referência de comportamento antes da revisão.
• Formato de feedback objetivo: tenha perguntas específicas e sugestões de melhoria já mapeadas.

2. Técnicas de leitura de código para performance

Durante a leitura, direcione o olhar para hotspots que costumam impactar desempenho. Evite entregas apenas funcionais; enfatize eficiência, escalabilidade e equilíbrio entre tempo de execução e uso de recursos.

• Identifique hotspots: concentre-se nas partes do código com maior custo computacional ou alto I/O.
• Complexidade: questione a complexidade de tempo (O(n), O(n^2), etc.) e memória usada.
• Estruturas de dados: avalie se coleções escolhidas são adequadas ao padrão de acesso (listas, conjuntos, dicionários, caches locais).
• Chamadas externas: avalie impacto de chamadas a rede/banco de dados e possíveis gargalos de latência.
• Evite duplicação de trabalho: detecção de operações repetidas, recomputação desnecessária e alocações repetidas.
• Profiling leve: use benchmarks simples, timers locais e logs de desempenho para contextualizar as alterações.

Exemplo prático de melhoria de performance

Às vezes, pequenas mudanças no código ajudam a reduzir significativamente o tempo de execução. Abaixo ilustro uma melhoria clássica na remoção de duplicatas de uma lista.

# Versão ineficiente (O(n^2) em listas grandes)
def unique(items):
    res = []
    for x in items:
        if x not in res:
            res.append(x)
    return res

# Versão eficiente (aproximadamente O(n))
def unique_fast(items):
    return list(dict.fromkeys(items))
      

Observação: a segunda versão usa hashing para evitar checagens lineares repetidas, reduzindo o tempo de execução em cenários com listas grandes.

3. Estrutura de feedback com foco em performance

O feedback deve ser claro, acionável e mensurável. Estruture comentários que guiem o time para melhorias reais, sem perder o foco na qualidade geral.

• Impacto explícito: descreva o que muda no desempenho, memória e escalabilidade.
• Seja específico: aponte linha(s) de código, proponha uma refatoração concreta ou uma alternativa viável.
• Priorize mudanças pequenas: peça ajustes incrementais que, somados, geram ganho significativo.
• Proposta de validação: inclua um teste ou benchmark simples para confirmar o ganho esperado.
• Conteúdo técnico objetivo: evite ruídos e comentários genéricos; traga dados ou estimativas sempre que possível.

4. Fluxo de revisão e qualidade de código

Adote um fluxo que gratuitemente priorize qualidade de performance sem atrasar a entrega. Abaixo estão itens que ajudam a manter o padrão mesmo em equipes diversas.

• Checklist de performance: avalie a complexidade de tempo, uso de memória, e impacto de I/O ou chamadas externas.
• Escolha de algoritmos e estruturas: questione se há alternativa mais eficiente para o caso de uso.
• Diff legível: mantenha mudanças focadas, com contexto suficiente e evitar grandes reescritas em um único PR.
• Divisão de mudanças grandes: quebre em PRs menores para facilitar a validação de performance de cada etapa.
• Consistência com guias: alinhe-se aos padrões de nomenclatura, modularização e práticas recomendadas do projeto.