Código, depuração e revisão na entrevista

Como conduzir um live coding em voz alta, depurar com método sob pressão, revisar código priorizando riscos e provar a correção com um teste.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Seguir um roteiro de live coding: entender, criar exemplos, explicar o plano, codificar e testar
  • Ler um traceback de baixo para cima e formular uma hipótese a partir do tipo do erro
  • Isolar um bug com uma reprodução mínima e corrigi-lo mudando uma coisa de cada vez
  • Classificar problemas de uma revisão em bug, legibilidade, segurança e desempenho, priorizando o que causa dano
  • Escrever um teste de regressão e explicar causa, correção, prova e limitação

Em boa parte dos processos seletivos de tecnologia, alguém vai pedir para você escrever, consertar ou revisar código enquanto observa. Quem avalia raramente espera a solução perfeita: quer ver como você pensa, como reage a um erro e se explica o que está fazendo. A boa notícia é que isso tem método, e método se treina como qualquer outra habilidade.

Pensar em voz alta: o roteiro do live coding

Live coding é programar ao vivo, com alguém acompanhando: por videochamada com tela compartilhada, num editor online ou numa lousa. O que conta ponto não é só o código final, mas o caminho: as perguntas que você faz, os exemplos que testa e como corrige o rumo.

  1. Entender

    Repita o problema com suas palavras e pergunte sobre o que não está claro: que tipo de dado entra, o que deve sair, o que fazer com entrada vazia. Perguntar não é fraqueza, é o que pessoas experientes fazem no trabalho.

  2. Exemplos

    Escreva dois ou três casos pequenos com a resposta esperada: um caso comum, um caso de borda (lista vazia, valor repetido, número negativo) e, se couber, um caso grande.

  3. Plano

    Antes de digitar, diga o plano em português: “vou percorrer a lista uma vez, guardando o que já vi num dicionário”. Se a pessoa discordar, você descobre agora, e não depois de vinte minutos.

  4. Código

    Escreva com nomes claros e vá narrando. Se travar, diga onde travou. Uma solução simples que funciona vale mais do que uma ideia brilhante pela metade.

  5. Testar

    Rode seus exemplos, à mão ou no editor. Mostre que você mesmo procura o erro. Termine comentando o que melhoraria com mais tempo.

Coloque em ordem o roteiro de um bom live coding.

  • Repetir o problema com suas palavras e tirar dúvidas
  • Escrever exemplos de entrada e saída, incluindo casos de borda
  • Explicar o plano em voz alta antes de digitar
  • Escrever o código narrando as decisões
  • Rodar os exemplos e corrigir o que falhar
  • Comentar limitações e o que melhoraria

A pessoa entrevistadora diz: “Escreva uma função que remove os itens repetidos de uma lista.” Qual é o melhor primeiro movimento?

  • Começar a digitar logo, para mostrar agilidade
  • Perguntar se a ordem original precisa ser mantida e combinar o que acontece com uma lista vazia
  • Dizer que vai usar a solução mais otimizada possível
  • Ficar em silêncio pensando até ter a resposta completa
Se você travar no meio do código e não souber continuar, o que é melhor dizer em voz alta?

Algo como: “Travei em como guardar os itens já vistos. Uma opção é uma lista, mas a busca fica lenta; vou usar um set”. Mostrar onde está a dúvida permite que a pessoa dê uma dica, e muitas entrevistas contam ponto justamente por saber pedir e usar ajuda.

Depurar sob pressão: leia o erro primeiro

No Python, quando algo quebra aparece um traceback: o caminho que o programa percorreu até o erro. Com nervosismo, a tendência é ignorar esse texto e sair mexendo no código. Ler com calma economiza minutos preciosos.

Um traceback real do Python. Leia de baixo para cima.

Traceback (most recent call last):
  File "loja.py", line 9, in <module>
    print(total_do_carrinho(carrinho))
  File "loja.py", line 4, in total_do_carrinho
    total += item["preco"] * item["qtd"]
TypeError: can't multiply sequence by non-int of type 'str'
  • Cabeçalho: “A chamada mais recente por último”: a pista mais importante fica no fim. Por isso se lê de baixo para cima.
  • Onde começou: A linha 9 chamou a função. Ela não tem culpa: só acionou o código que quebrou mais adiante.
  • Onde quebrou: Arquivo, número da linha, nome da função e o próprio código. É aqui que você coloca o olho primeiro.
  • Tipo do erro: TypeError significa operação com o tipo de dado errado. Outros comuns: NameError (nome não existe), KeyError (chave que não está no dicionário), IndexError (posição fora da lista).
  • Mensagem: “Não dá para multiplicar uma sequência por algo que não é inteiro, do tipo texto”. Tradução livre: alguém tentou multiplicar texto por texto.

Olhando o traceback acima, qual é a hipótese mais provável?

  • O preço ou a quantidade chegaram como texto, por exemplo "2" em vez de 2
  • A linha 9 está errada, porque é a primeira que aparece
  • Falta um try/except em volta do cálculo
  • A variável total não foi criada

Nem todo bug gera erro. Às vezes o programa roda e devolve a resposta errada, que é mais traiçoeiro. Aí a técnica é comparar: qual era o resultado esperado, qual veio, e em que linha os dois começam a se separar. Um print bem colocado mostra isso.

Conserte a contagem de aprovações

A regra da escola: aprova quem tira 7 ou mais. A função abaixo roda sem erro, mas conta errado. Use print dentro do laço para ver cada nota visitada, encontre os dois bugs e corrija. Depois apague os prints de investigação.

def contar_aprovados(notas, minimo=7):
    aprovados = 0
    for i in range(1, len(notas)):
        if notas[i] > minimo:
            aprovados += 1
    return aprovados


print(contar_aprovados([7, 5, 9]))  # esperado: 2
  • Quem tirou exatamente 7 conta como aprovado
  • A primeira nota da lista não é pulada
  • Lista vazia devolve zero

Reproduzir pequeno, isolar a causa

Uma reprodução mínima é o menor exemplo que ainda mostra o bug. Se o relatório de vendas do mês sai errado, você não investiga com 30 mil pedidos: tenta com dois. Quanto menor o exemplo, mais rápido você enxerga a causa.

A função deveria dizer se a lista tem algum número negativo. Com [3, -1] ela responde False. Siga a execução e encontre o momento exato do erro.

def tem_negativo(valores):
    for v in valores:
        if v < 0:
            return True
        else:
            return False
    return False

print(tem_negativo([3, -1]))
  1. Linha 1: O Python guarda a função. Nada dentro dela roda ainda.
  2. Linha 9: A chamada com a reprodução mínima: só dois números, um positivo e um negativo.
  3. Linha 2: Primeira volta do laço: v recebe 3.
  4. Linha 3: 3 < 0 é falso, então a execução vai para o else.
  5. Linha 6: Aqui está o bug: return encerra a função na primeira volta. O -1 nunca é visitado. A pessoa que escreveu queria dizer “se nenhum for negativo”, mas isso só se sabe depois do laço inteiro.
  6. Linha 9: A função devolve False e o resultado é impresso. Correção: apagar o else e deixar só o return False da linha 7, depois do laço. Saída: False

Você está numa entrevista e o teste falhou. Quais atitudes ajudam a isolar a causa e quais atrasam a investigação?

Ajuda a isolar · Atrasa a investigação

  • Reduzir a entrada ao menor exemplo que ainda falha
  • Imprimir o valor da variável logo antes da linha suspeita
  • Ler a última linha do traceback antes de mexer no código
  • Dizer a hipótese em voz alta e testar uma de cada vez
  • Mudar várias linhas ao mesmo tempo para ver se resolve
  • Reescrever a função do zero sem entender o erro
  • Envolver tudo num try/except para o erro sumir
  • Apagar o teste que está falhando

Corrija a reprodução mínima

Conserte tem_negativo para que ela olhe a lista inteira antes de concluir que não há negativos.

def tem_negativo(valores):
    for v in valores:
        if v < 0:
            return True
        else:
            return False
    return False


print(tem_negativo([3, -1]))  # esperado: True
  • Acha o negativo mesmo quando ele não é o primeiro
  • Lista só com positivos devolve False
  • Lista vazia devolve False

A entrevista de revisão de código

Em vez de escrever, às vezes você recebe um trecho pronto e a pergunta: “o que você mudaria aqui?”. Isso se chama revisão de código (code review), e é parte do dia a dia: antes de entrar no projeto, toda mudança é lida por outra pessoa.

Uma função que chegou para revisão. Clique nas partes destacadas.

def relatorio(conn, cidade):
    sql = f"SELECT nome, email FROM clientes WHERE cidade = '{cidade}'"
    x = conn.execute(sql).fetchall()
    unicos = []
    for c in x:
        if c not in unicos:
            unicos.append(c)
    try:
        media = len(unicos) / len(x)
    except:
        media = 0
    return unicos[1:], media
  • Segurança: O texto que veio da pessoa usuária é colado dentro do SQL. Quem digitar x' OR '1'='1 lê a tabela inteira. Isso é SQL injection; a correção é usar parâmetros: conn.execute("... WHERE cidade = ?", (cidade,)).
  • Legibilidade: O nome x não diz o que guarda. clientes ou linhas deixa o resto da função mais fácil de ler.
  • Desempenho: in numa lista percorre a lista inteira. Dentro de um laço, isso vira trabalho que cresce ao quadrado. Com um set de vistos, cada verificação é quase instantânea.
  • Bug escondido: Um except sem tipo engole qualquer erro, inclusive os que você nem imaginou. Seja específico (except ZeroDivisionError) ou, melhor ainda, trate o caso vazio com um if.
  • Bug: [1:] corta o primeiro elemento. Nada no nome da função sugere isso: o primeiro cliente some do relatório.

Classifique cada problema encontrado em revisões de código.

Bug · Legibilidade · Segurança · Desempenho

  • unicos[1:] descarta o primeiro cliente sem motivo
  • range(1, len(notas)) pula a primeira nota
  • Variável chamada x que guarda a lista de clientes
  • Função de 80 linhas que faz cinco coisas diferentes
  • Texto digitado pela pessoa usuária colado dentro do SQL
  • Senha do banco escrita no código e enviada ao Git
  • c not in unicos percorrendo a lista a cada volta
  • Uma consulta ao banco feita dentro do laço, uma por pedido

Você tem tempo para um único comentário sobre a função acima. Qual deve ser?

  • Trocar a montagem do SQL por uma consulta com parâmetros
  • Renomear x para clientes
  • Usar um set para deixar a deduplicação mais rápida
  • Padronizar aspas simples ou duplas no arquivo

Conserte, prove e explique

Corrigir um bug tem três partes: entender a causa, mudar o código e provar que funcionou. A prova é um teste de regressão: um teste que reproduz o bug e passa a falhar se alguém, no futuro, trouxer o erro de volta.

Em Python, o jeito mais simples de escrever um teste é com assert: ele não faz nada se a condição for verdadeira e para o programa com AssertionError se for falsa. Em projetos reais, você usaria uma ferramenta como pytest (Python) ou Vitest (JavaScript), mas a ideia é a mesma.

Conserte a divisão da conta e escreva a regressão

A função divide a conta do restaurante entre as pessoas. Hoje ela perde os centavos e aceita zero ou menos pessoas. Faça ela devolver o valor com 2 casas (use round) e levantar ValueError quando pessoas for menor ou igual a zero. No fim, escreva pelo menos dois assert e imprima testes ok.

def dividir_conta(total, pessoas):
    return total // pessoas


def levanta_valueerror(funcao, *args):
    try:
        funcao(*args)
    except ValueError:
        return True
    except Exception:
        return False
    return False


# Escreva aqui seus testes com assert
# e, no fim, print("testes ok")
  • R$ 100 para 3 pessoas dá 33.33
  • Zero pessoas levanta ValueError
  • Número negativo de pessoas levanta ValueError
  • Seus testes rodaram até o fim e imprimiram "testes ok"

A mesma correção em Python e em JavaScript. Se a vaga for de frontend, a entrevista pode pedir a versão em JS.

Python

def dividir_conta(total, pessoas):
    if pessoas <= 0:
        raise ValueError("pessoas precisa ser maior que zero")
    return round(total / pessoas, 2)

assert dividir_conta(100, 3) == 33.33

JavaScript

function dividirConta(total, pessoas) {
  if (pessoas <= 0) {
    throw new Error("pessoas precisa ser maior que zero");
  }
  return Math.round((total / pessoas) * 100) / 100;
}

console.assert(dividirConta(100, 3) === 33.33);

Complete a explicação que você daria ao final, em voz alta, sobre a correção.

Causa: o operador ____ descartava os centavos.
Correção: troquei por / e arredondei com ____.
Prova: um teste de ____ com 100 dividido por 3.
Limitação: com centavos, a soma das partes pode dar 99.99.

Fechamento

  • No live coding, metade do trabalho vem antes do código: entender, criar exemplos e explicar o plano em voz alta.
  • O traceback se lê de baixo para cima: tipo do erro, mensagem e a última linha de código listada.
  • Uma reprodução mínima e um print bem colocado isolam a causa mais rápido do que mexer em várias linhas.
  • Na revisão, classifique o problema (bug, legibilidade, segurança, desempenho) e priorize o que causa dano.
  • Todo conserto termina com um teste de regressão e uma explicação curta da causa, da correção e da limitação.

Corrija um bug de verdade e explique o diff

Pegue um projeto seu (ou um exercício antigo) e trate-o como uma entrevista: encontre ou provoque um bug, corrija com método e grave você mesmo explicando, como se alguém estivesse assistindo.

  1. Escolha uma função do seu projeto e escreva três exemplos de entrada e saída, incluindo um caso de borda
  2. Encontre um caso em que ela falha e reduza até uma reprodução mínima
  3. Corrija mudando uma coisa de cada vez e escreva um teste de regressão
  4. Leia o diff com git diff e explique em voz alta: causa, correção, prova e limitação
  5. Peça para alguém revisar e anote os comentários em bug, legibilidade, segurança ou desempenho

Referências

Cursos relacionados