Code review em Kotlin: o que verificar e como dar feedback

Code review em Kotlin: o que verificar e como dar feedback

Code review é uma das ferramentas mais eficazes para manter a qualidade do código, compartilhar conhecimento na equipe e prevenir bugs. No entanto, apenas "passar os olhos" pelo pull request não é suficiente. Na linguagem Kotlin, com seu rico sistema de tipos, coroutines e recursos funcionais, é importante prestar atenção a pontos específicos. Neste artigo, vamos analisar exatamente o que observar ao revisar código em Kotlin e como formular observações para que sejam úteis, e não ofensivas.

1. Princípios básicos de feedback construtivo

Antes de passar para os detalhes técnicos, vamos lembrar algumas regras que tornam o code review útil para todos os participantes.

Foco no código, não no autor

Em vez de "Você escreveu um código ruim", diga "Este método pode ser simplificado usando let". A especificidade e o tom neutro reduzem a tensão.

Divisão em categorias

Marque as observações como:

• Blocking — deve ser corrigido obrigatoriamente (erro lógico, vazamento de recurso).
• Nitpick — pequenas críticas (estilo, formatação).
• Question — esclarecimento (intenção não está clara).

Explicação do "porquê"

Não basta dizer "use filterNotNull()". Adicione: "Isso eliminará um loop desnecessário e tornará o código autodocumentado". Assim, o autor aprende, e não apenas corrige.

2. Null safety e tipos: os principais aliados do Kotlin

Kotlin foi projetado para evitar NullPointerException em tempo de compilação. Verifique se essa proteção não foi violada.

Evite !! (not-null assertion) desnecessários

O operador !! é um grito de socorro. Seu uso deve ser exceção, não regra.

// Ruim: risco de NPEfun process(user: User?) {    val name = user!!.name}

// Bom: chamada segurafun process(user: User?) {    val name = user?.name ?: "Convidado"}

O que verificar: se você vir !!, pergunte ao autor se pode ser substituído por ?.let, ?: (elvis) ou requireNotNull().

Uso correto de tipos nullable

Nem todos os parâmetros precisam ser nullable. Se a função sempre espera um valor, declare o tipo sem o ponto de interrogação.

// Questionável: null não significa nadafun log(message: String?) {    println(message ?: "null")}

// Melhor: exigência explícitafun log(message: String) {    println(message)}

3. Coroutines e threads: assincronicidade sem dor

Kotlin Coroutines é uma ferramenta poderosa, mas é fácil usá-la incorretamente. Ao revisar, preste atenção aos seguintes pontos.

Dispatcher correto para as tarefas

Não execute operações longas (rede, disco) no Dispatchers.Main.

// Ruim: bloqueia a UIGlobalScope.launch(Dispatchers.Main) {    val data = fetchFromNetwork() // trava}

// Bom: troca de contextoviewModelScope.launch {    val data = withContext(Dispatchers.IO) {        fetchFromNetwork()    }    updateUI(data)}

Vazamento de coroutines e structured concurrency

Use viewModelScope, lifecycleScope ou coroutineScope em vez de GlobalScope. Este último vive enquanto o aplicativo vive e facilmente leva a vazamentos.

// Perigoso: vazamentoGlobalScope.launch { /* ... */ }

// Seguro: vinculado ao ciclo de vidalifecycleScope.launch { /* ... */ }

4. Coleções e estilo funcional: concisão e legibilidade

Kotlin oferece uma biblioteca rica para trabalhar com coleções. Use-a em vez de loops explícitos.

Encadeamentos em vez de mutações

Evite adicionar manualmente a uma lista se puder coletar a res