Qual é a maneira mais eficaz de executar revisões de código? [fechadas]

Eu nunca encontrei a maneira ideal de executar revisões de código e, no entanto, muitas vezes meus clientes precisam delas. Cada cliente parece fazê-lo de uma maneira diferente e nunca me senti satisfeito com nenhum deles.

Qual foi a maneira mais eficaz de você executar revisões de código?

Por exemplo:

• Uma pessoa é considerada o guardião da qualidade e analisa o código ou a equipe possui o padrão?
• Você analisa o código como um exercício de equipe usando um projetor?
• É feito pessoalmente, por e-mail ou usando uma ferramenta?
• Você evita as revisões e usa coisas como programação em pares e propriedade coletiva do código para garantir a qualidade do código?

No meu trabalho, temos uma regra muito simples: as alterações devem ser revisadas por pelo menos um outro desenvolvedor antes de uma mesclagem ou confirmação do tronco . No nosso caso, isso significa que a outra pessoa se senta fisicamente com você no seu computador e passa pela lista de alterações. Este não é um sistema perfeito, mas, no entanto, melhorou notavelmente a qualidade do código.

Se você sabe que seu código será revisado, obriga você a analisá-lo primeiro. Muitos problemas se tornam aparentes então. De acordo com o nosso sistema, você precisa explicar o que fez ao revisor, o que novamente faz com que você note problemas que talvez já tenham esquecido. Além disso, se algo no seu código não estiver imediatamente claro para o revisor, isso é uma boa indicação de que é necessário um nome melhor, um comentário ou uma refatoração. E, é claro, o revisor também pode encontrar problemas. Além disso, além de analisar a alteração, o revisor também pode perceber problemas no código próximo.

Existem duas desvantagens principais neste sistema. Quando a mudança é trivial, faz pouco sentido revisá-la. No entanto, temos absolutamente de nos ater às regras, para evitar a inclinação escorregadia de declarar que as alterações são "triviais" quando não o são. Por outro lado, essa não é uma maneira muito boa de revisar alterações significativas no sistema ou adicionar novos e grandes componentes.

Tentamos análises mais formais antes, quando um desenvolvedor enviava um código por e-mail para ser revisado para o restante da equipe e, em seguida, toda a equipe se reunia e discutia. Isso levou muito tempo para todos e, como resultado, essas revisões foram poucas e distantes, e apenas uma pequena porcentagem da base de código foi revisada. A "outra pessoa revisa as alterações antes de confirmar" funcionou muito melhor para nós.

Eu gosto de revisões de código, embora possam ser uma dor. A razão de eu gostar deles é que eles têm mais olhos no código e uma perspectiva diferente. Acredito que, mesmo com a programação em pares, o código deve ser revisado. É fácil o suficiente para duas pessoas trabalhando no mesmo código coletivamente cometerem o mesmo erro que um conjunto diferente de olhos pode não perceber.

Se feito em grupo com um projetor, ele realmente deve ser revisado individualmente antes da reunião. Caso contrário, é apenas uma perda de tempo irritante.

Eu só fiz revisões de código por e-mail e em grupo. De um modo geral, não acho que devam ser feitos pessoalmente. Você sente um pouco mais de pressão para percorrer o código com alguém olhando por cima do seu ombro. Acredito que uma ferramenta projetada para a revisão de código seria um bom trunfo, pois pode ajudar com alguns dos aspectos mundanos e facilitar a sinalização de bits problemáticos de código, então é via email.

O problema de ter uma pessoa fazendo todas as revisões de código é que isso pode ser um gargalo. Com padrões de codificação bem documentados e projetados, não deve ser necessário. Dependendo do ambiente / cronograma de lançamento, pode ser uma boa ideia sempre ter alguém como revisor de código em espera.

Eu acredito que a propriedade do código é uma boa idéia, pois essa pessoa pode fazer sua prioridade entender esse código e potencialmente desempenhar um papel de gatekeeper.

No SmartBear , não apenas fazemos uma ferramenta de revisão de código , mas também a usamos no dia a dia. É uma parte essencial do nosso processo de desenvolvimento. Analisamos todas as alterações que são registradas.

Eu acho que é uma má idéia ter um único revisor de código de gatekeeper por vários motivos. Essa pessoa se torna um gargalo e precisa fazer muita revisão de código (apenas para manter o projeto em andamento) para realmente ser eficaz (60 a 90 minutos de cada vez é o limite de eficácia). As revisões de código são uma ótima maneira de compartilhar idéias e conhecimentos. Não importa o tamanho de sua superestrela, seu gatekeeper pode aprender com os outros membros da equipe. Além disso, fazer com que todos revisem o código também cria um ambiente de "propriedade coletiva do código" - onde as pessoas sentem que possuem a qualidade do código (não é apenas o controle de qualidade ou o gatekeeper).

Temos um whitepaper gratuito sobre " Práticas recomendadas para revisão de código por pares ", com 11 dicas para tornar as revisões de código eficazes. Muito disso é o mesmo conteúdo do livro que João mencionou de uma forma mais destilada.

Sem desculpa. Prática de programação em pares. É a melhor revisão de código possível. Qualquer outro mecanismo resulta em jogo de culpa. A programação em pares induz o espírito de equipe e a propriedade coletiva. Além disso, você debate suas idéias com o seu par, falha rapidamente, toma uma ação corretiva e é apenas o código codificado e revisado do par que é comprometido no CMS (Configuration Management System). Programação de par feliz!

Se você estiver trabalhando em um projeto em que várias pessoas contribuam para a base de código, é necessário estabelecer um padrão.

Neste ponto, na minha experiência, é melhor designar uma pessoa como o "rei" da revisão de código, se você quiser e o que ela diz. Nesse sentido, se um usuário não seguir os padrões, o rei cuidará disso.

Como desenvolvedor, eu reviso meu próprio código muitas vezes para ser legível, sensível e tudo mais. Geralmente usamos javadoc ou similar em determinados idiomas com os quais codificamos e usamos a tag @author para atribuir propriedade a funções, classes etc.

Se uma função não estiver correta, conversamos com o proprietário, o mesmo com a classe etc.

Na minha empresa, cada tarefa recebe um testador para testá-la e também um revisor de código para revisar o código.

Se o seu produto já foi lançado e você deseja garantir que não está fazendo nada de errado (como um vazamento de identificador ou vazamento de memória), as revisões de código são ótimas. Acho que durante o desenvolvimento inicial antes de lançar seu produto, as revisões de código podem ser muito trabalhosas.

Se sua equipe tiver todos os desenvolvedores seniores, a revisão por pares ainda será útil. Todo mundo comete erros às vezes. Se sua equipe tem alguns seniores e juniores, deixe que os desenvolvedores seniores façam as revisões de código, mas ainda tenham revisões de código para o código de seniores.

Uma coisa importante sobre a revisão de código é que ela pode detectar erros que cometemos, mas não substitui os testes.

Eu recomendo o uso de revisões de código se você não estiver fazendo programação em pares.

Para não discutir os prós e os contras com o emparelhamento, mas é difícil contestar os efeitos positivos de ter seu código constantemente revisado por (pelo menos) outra pessoa. O código é escrito e projetado por (pelo menos) dois programadores - dificilmente pode ser melhor do que isso. Estou dizendo "pelo menos" porque, imo, você deve tentar alternar muito os pares para que todos possam trabalhar com o código.

Uma das coisas que tento fazer nas revisões de código das quais participo é depois de revisar o código pessoalmente, faço uma análise estática do código, usando ferramentas como Findbugs, PMD, JavaNCCP et al. E analisamos os problemas encontrados por essas ferramentas em o código a ser revisado. Eu particularmente quero examinar qualquer coisa que tenha níveis incomumente altos de complexidade, pedindo que eles expliquem por que esse nível de complexidade é necessário ou por que a vulnerabilidade sugerida não é importante.

YMMV

Atualmente, onde trabalho, produzimos dispositivos de hardware e o software que faz interface com eles que entram na infraestrutura crítica. Consequentemente, temos um foco muito alto na qualidade do lançamento. Utilizamos uma variante da Inspeção Fagan e temos um processo formal de revisão. Temos a certificação ISO 9001, entre outras certificações.

O setor de infraestrutura crítica está muito interessado na confiabilidade e repetibilidade dos mesmos. :-)

Na minha empresa, temos revisões de código obrigatórias para programadores juniores e revisões voluntárias para idosos. Não há revisor de código designado; as solicitações de revisão são enviadas a todos os desenvolvedores.

Esse sistema funciona bem - as revisões são feitas conforme o tempo permitir e as alterações podem ser revisadas por vários conjuntos de olhos.

A ferramenta excelente e gratuita do Review Board funciona muito bem para nós e provou ser uma excelente maneira de comunicar comentários.

Na minha empresa, nunca fazemos revisões formais de código antes dos check-ins, a menos que modifiquemos uma produção altamente crítica e não tenhamos tempo para executar nosso processo padrão de controle de qualidade.

O que fazemos é que, sempre que sentimos que uma revisão de código seria útil, adicionamos um comentário "// todo: code review by joe" ao código modificado. Normalmente, selecionamos Joe porque ele é o proprietário do código modificado, mas se esse critério de seleção não se aplica (normalmente, se aplica), escolhemos outra pessoa aleatoriamente. E, é claro, se Joe estiver disponível naquele momento, usamos o bom e velho método de revisão por cima do ombro.

Como revisor, a única coisa que você precisa fazer é procurar periodicamente todo o código por "// todo: revisão do código por mim" , revisar as alterações e verificar o código novamente sem o comentário "todo ..."

Se houver algum problema, voltamos aos métodos de comunicação tradicionais (email / chat / etc).

Esse método fornece as duas principais qualidades que buscamos em um sistema de revisão:

• sobrecarga muito leve
• rastreabilidade

Nós achamos que a maneira mais eficaz de fazer revisões de código é individual, usando o github para mostrar as diferenças no ramo.

• Uma pessoa é considerada o guardião da qualidade e analisa o código ou a equipe possui o padrão?

  • Depende do tamanho da equipe - a equipe de 3 terá 1 sênior com o melhor conhecimento de boas práticas, enquanto uma equipe de 12 poderá ter 3 ou 4 pessoas que desempenharão esse papel.

• Você analisa o código como um exercício de equipe usando um projetor?

  • Em pessoa. 1 em 1 para ser menos ameaçador. Às vezes, é feito na área comum, mas para disseminação de conhecimento. Depende da situação exata, pessoas, horário, etc.

• É feito pessoalmente, por e-mail ou usando uma ferramenta?

  • Em pessoa. Usamos o git e o github e ele possui ótimas ferramentas de revisão de código e comparação de diferenças para facilitar a revisão do código.

• Você evita as revisões e usa coisas como programação em pares e propriedade coletiva do código para garantir a qualidade do código?

  • Tentamos fazer as duas coisas conforme apropriado. Isso significa que, quando preso a um problema particularmente espinhoso, ou ao trabalhar na infraestrutura principal ou ao se preparar para férias ou sair da empresa, o emparelhamento pode ser feito para compartilhar e transferir conhecimento. A maioria dos códigos ou códigos que possuem algo além de alterações cosméticas também deve ser revisada no final.

Como em todos os itens de codificação, a resposta correta deve levar em consideração:

• Tipo de empresa (por exemplo, startup vs. grande corporação)
• Tamanho da empresa
• Número de desenvolvedores
• Despesas
• Prazo
• Carga de trabalho
• Complexidade do código
• Capacidade do (s) revisor (es)
• Disponibilidade do (s) revisor (es)

Já trabalhei em muitas empresas e vi muitos processos. Minha equipe atual lida com isso da melhor maneira que já vi até agora.

Usamos um processo de desenvolvimento ágil e, como parte disso, temos portões pelos quais cada história precisa passar. Um desses portões é a revisão de código. A história não é testada até que a revisão do código seja concluída.

Além disso, armazenamos nosso código em github.com. Portanto, depois que um desenvolvedor termina sua alteração, ele publica o link no (s) commit (s) na história.

Em seguida, identificamos um colega desenvolvedor para revisar. O Github possui um sistema de comentários que permite que alguém comente diretamente na linha de código em questão. O Github envia um e-mail para a distro, então, às vezes, recebemos mais atenção de algumas de nossas outras equipes.

Esse processo funcionou muito bem para nós. Utilizamos uma ferramenta de processo ágil que facilita a publicação dos commits, além de facilitar a comunicação.

Se um problema for particularmente difícil, nos sentaremos e discutiremos. Isso funciona porque é parte integrante do nosso processo e todo mundo concorda com o funcionamento do processo. Podemos mover os tíquetes de volta para o andamento se a revisão do código resultar em retrabalho necessário e, em seguida, ela pode ser revisada novamente após as alterações serem feitas, ou o revisor pode observar na história que a correção dos itens é suficiente e não precisa ser revisada novamente.

Se o teste retroceder algo, ele voltará ao andamento e outras alterações também serão revisadas.