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

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

Code review (revisão de código) é um dos processos-chave no desenvolvimento moderno. Para iniciantes em Kotlin, muitas vezes parece assustador: como encontrar erros? O que exatamente observar? Como não ofender o autor do código? Neste artigo, vamos analisar o que observar ao fazer code review de projetos em Kotlin e como dar feedback para que ele seja útil, e não ofensivo. O material é adequado tanto para quem está aprendendo a revisar quanto para quem deseja melhorar suas habilidades.

Por que o code review é necessário em Kotlin?

Kotlin é uma linguagem moderna, concisa e segura, mas oferece muita liberdade ao desenvolvedor. Sem code review, é fácil cometer erros relacionados à segurança contra null, uso incorreto de corrotinas ou complexidade excessiva. A revisão ajuda a:

• Encontrar bugs em estágios iniciais.
• Melhorar a legibilidade e a manutenibilidade do código.
\
• Disseminar conhecimento dentro da equipe.
• Manter um estilo de código consistente.

Para iniciantes, também é uma excelente maneira de aprender com exemplos alheios. Vamos aos detalhes.

O que verificar ao fazer code review de código em Kotlin

Aqui está uma checklist de pontos-chave que vale a pena verificar em cada pull request. Vamos dividi-los em blocos lógicos.

1. Segurança contra null e tipos

Kotlin se orgulha de sua segurança contra null, mas ela pode ser violada. Verifique:

• Os tipos nullable (por exemplo, String?) são usados apenas onde realmente necessário?
• Não há !! (non-null assertion) desnecessários? Idealmente, eles não devem existir no código de produção.
• São usadas chamadas seguras (?.let { ... }) e o operador elvis (?:) em vez de if (x != null)?

Exemplo ruim:

val name: String? = getName()val length = name!!.length // Perigoso: causará NPE se name == null

Exemplo bom:

val name: String? = getName()val length = name?.length ?: 0 // Seguro: se for null, retorna 0

2. Funções e suas assinaturas

Kotlin suporta argumentos nomeados e valores padrão. Verifique:

• A função é muito longa (mais de 20–30 linhas)? Talvez deva ser dividida.
• Parâmetros padrão são usados para simplificar a chamada?
• Não há funções com mais de 3–4 parâmetros? Isso dificulta a leitura.
• O uso de extension functions é adequado? Elas não devem alterar o estado do objeto.

Exemplo:

// Em vez disso:fun processUserData(name: String, age: Int, email: String, city: String, phone: String) { ... }

// Melhor assim:data class UserData(val name: String, val age: Int, val email: String, val city: String, val phone: String)fun processUserData(user: UserData) { ... }

3. Trabalho com corrotinas (Coroutines)

Corrotinas são uma ferramenta poderosa do Kotlin, mas é fácil usá-las incorretamente. Observe:

• A thread está bloqueada dentro da corrotina (chamada de Thread.sleep() ou E/S bloqueante)?
• O dispatcher correto está sendo usado (Dispatchers.IO para requisições de rede, Dispatchers.Main para UI)?
• Não há vazamentos de corrotinas (por exemplo, iniciadas em uma Activity sem cancelamento)?
• withContext é usado para trocar de dispatcher, em vez de launch dentro de launch?

Exemplo ruim:

fun fetchData() {    GlobalScope.launch { // Vazamento: não é cancelado quando o componente é destruído        Thread.sleep(1000) // Bloqueia a thread!    }}

Exemplo bom:

fun fetchData(scope: CoroutineScope) {    scope.launch {        withContext(Dispatchers