Fazendo com que TODOS os desenvolvedores façam revisões de código

13

Sou desenvolvedor de software em uma equipe de 7-8 desenvolvedores. Fazemos revisões de código há algum tempo e a qualidade do código melhorou com o tempo.

No entanto, notei recentemente que alguns desenvolvedores estão solicitando mais análises de código do que outros. Receio que seja por causa de sua atitude flexível.

Na minha opinião, não é assim que as revisões de código devem ser feitas: toda a equipe deve ser responsável por isso e os revisores de código não devem ser escolhidos por sua disposição em aceitar facilmente alterações.

Como você lida com esse problema em sua equipe?

Você estabeleceu regras para escolher revisores de código?

Você acha que os revisores de código devem ser recompensados ​​pelo tempo que passam fazendo (boas) análises de código? E como eles devem ser recompensados?

Obrigado por suas respostas / idéias.

guillaumegallois
fonte
7
Você já pensou em criar um sistema round robin em que o codificador fica no escuro sobre quem está revisando e o revisor fica no escuro sobre quem é o codificador?
314 Neil
1
Não tenho, mas gosto dessa ideia! Obrigado!
22418
1
Quem está no comando e por que eles não realizam seu trabalho, o que deve envolver garantir que todos os outros façam o seu?
21818 JeffO
Na minha equipe, os revisores são atribuídos automaticamente sempre que uma solicitação de recebimento é aberta. Os revisores são selecionados no round-robin da equipe. Temos um webhook para cada um de nossos repositórios que atribui revisores automaticamente sempre que o PR é aberto. Basicamente, mantém uma lista de todos os desenvolvedores e quem foi designado pela última vez, e apenas percorre a lista.
Dan Jones

Respostas:

12

Não escolhemos revisores.

Em nossa equipe:

  • Todas as alterações de código devem ser revisadas antes que a solicitação de recebimento seja concluída
  • Pelo menos um desenvolvedor deve revisar o código (dois ou mais revisores são melhores e ter testadores, analistas e outros membros da equipe fazendo a revisão do código também é extremamente benéfico)

As revisões de código não são atribuídas, as pessoas as buscam quando funciona para elas. O entendimento é que não podemos divulgar histórias através do pipeline. Ocasionalmente, alguém mencionará que está esperando um CR na fila, mas é isso.

Eu gosto desse modelo, ele permite que as pessoas escolham o que podem e evita "dar emprego às pessoas".

Liath
fonte
6

Introduza uma regra na qual um bug possa ser atribuído para correção, não apenas para aqueles que confirmaram a alteração, mas apenas para quem a revisou. Isso deve criar uma perspectiva correta para a revisão do código.

Quanto a,

Você acha que os revisores de código devem ser recompensados ​​pelo tempo que passam fazendo (boas) análises de código?

Bem, eu não tenho certeza de como geralmente os desenvolvedores são recompensados ​​por fazer seu trabalho, exceto apenas recebendo um salário e se orgulhando do que fizeram. Mas como a revisão do código faz parte do trabalho deles, o revisor deve ter tempo para a revisão e compartilhar o crédito de alguma forma.

max630
fonte
2
É uma ideia interessante, mas muitas vezes quando um erro aparece, 90% do trabalho está calculando exatamente o que está causando o erro e 10% do trabalho está corrigindo-o. Fazer um post-mortem para descobrir exatamente qual mudança introduziu o bug pode nem acontecer, a menos que ajude a descobrir o que está acontecendo ou como fazer uma correção segura.
DaveG 13/07/19
Você fez uma boa observação sobre o crédito que os revisores de código devem receber. Esse é definitivamente um problema que deve ser resolvido. Obrigado pela sua resposta!
22418 Guillaumegallois
Eu acho que pode levar as pessoas a tentar não fazer nenhuma revisão de código ou pode ser que você não tenha feito nenhum trabalho porque as pessoas começarão a procurar.
Mateusz 13/07
5
Esta resposta assume que o objetivo das revisões de código é encontrar erros. Não é esse o caso, o objetivo principal é manter o código em um estado sustentável e evolutível (e se você tiver sorte, alguns erros também serão encontrados).
Doc Brown
@DocBrown para evitar erros e também para certificar-se de futuro correção do bug será mais rápido (ambos por familiarizar o outro desenvolvedor com o código e por ter certeza que o código é bem escrito)
max630
4

O principal problema que você tem não é técnico, mas algumas ferramentas podem diminuir a quantidade de esforço que as revisões de código exigem. Existem alguns desafios a serem superados:

  • Entendendo o que é a mudança. As solicitações Git Pull nas ramificações de recursos realmente ajudam esse processo.
  • Transformar o código em um evento em que as pessoas precisam estar na mesma sala. Isso aumenta o estresse de agendamento, reunião de recursos etc. O GitHub, o GitLab e o BitBucket permitem revisões assíncronas para que possam acontecer quando o par estiver pronto.
  • A capacidade de fornecer feedback significativo ao analisar o código. Para ser sincero, o recurso de comentários linha a linha no GitHub, GitLab e solicitações pull do Bitbucket são realmente mais úteis do que uma reunião cara a cara. Parece menos político.

Isso não quer dizer que você não possa usar o SubVersion ou outras ferramentas (como a Fisheye) para ajudar, mas a integração incorporada ao pipeline do Git com ramificações de recursos realmente torna o trabalho menos trabalhoso.

Fora das ferramentas, você precisa olhar para mais desafios sociais:

  • Faça com que seus desenvolvedores iniciem o dia revisando todas as solicitações de recebimento aberto para assinar.
  • Faça com que seus desenvolvedores analisem todas as solicitações abertas antes de iniciar uma nova tarefa
  • Exija a aprovação de mais de uma pessoa para suas solicitações de recebimento.

Também pode valer a pena verificar que tipos de tarefas estão sendo revisadas pelo código pelas pessoas mais envolvidas. Eles podem estar recebendo todas as críticas fáceis, o que torna as coisas mais dolorosas para todos os outros.

Berin Loritsch
fonte
O último ponto é bom. Certa vez, trabalhei com um desenvolvedor de uma equipe pequena que só revisava alterações no software que ele havia escrito, o que causava gargalos significativos em outras partes da equipe.
Robbie Dee
Nesse caso, parece que você tem alguém tentando proteger seu "território". Na medida do possível, você deseja promover um senso de propriedade da comunidade para o código. Em outras palavras, não há santuários protegidos no código que nenhum outro desenvolvedor, exceto os "abençoados", possam tocar. Entendo se existe uma lacuna de especialidade e você não pode revisar a matemática, mas pode pelo menos revisar até que ponto o código corresponde à sua intenção.
Berin Loritsch
2

Uma boa idéia é fazê-lo em rodízio - você escolhe alguém que fez o menor número de revisões para o seu código. Com o tempo, todos os membros da equipe deveriam ter feito aproximadamente um número igual de revisões. Também espalha o conhecimento.

Obviamente, haverá exceções ocasionais, como feriados, onde haverá picos e vales.

Não deve haver distinção entre juniores e seniores / leads. As revisões de código devem ser realizadas para o código de todos - independentemente da idade deles. Reduz o atrito e ajuda a compartilhar diferentes abordagens.

Se você ainda estiver preocupado com a qualidade das revisões, considere a introdução de um conjunto de padrões mínimos para a aprovação de uma revisão de código. O que você inclui depende inteiramente de você, mas algumas coisas que você pode querer considerar são: cobertura de código, testes de unidade, remoção de código comentado, métricas, comentários suficientes, qualidade de construção, princípios do SOLID, DRY, KISS etc.

Quanto a incentivar revisões de código, o código de qualidade é a recompensa. Temos certeza de que trabalhamos em bases de código abaixo do ideal, em que a dor poderia ter diminuído consideravelmente se outro desenvolvedor tivesse dado o código uma vez desde o início e sugerido mudanças construtivas.

Robbie Dee
fonte
0

Parece que a equipe carece de um processo formal para revisões de código.

Não estou falando de criar um documento do Word com 350 páginas, mas apenas alguns pontos simples sobre o que o processo implica.

Os bits importantes:

  1. Defina um conjunto principal de revisores. Nenhuma declaração geral. Nomeie pessoas.

    Esses devem ser seus desenvolvedores sênior.

  2. Exija que mais de um revisor principal assine a revisão.

  3. Identifique pelo menos 1 outro revisor que não seja o núcleo, a cada sprint ou versão, que seja um revisor temporário. Exija sua aprovação em todas as revisões de código durante esse período.

O item 3 permite que os outros desenvolvedores alternem para o grupo principal de revisores. Algumas semanas eles gastam mais tempo com críticas do que outras. É um ato de equilíbrio.

Quanto a recompensar as pessoas? Muitas vezes, reconhecer o esforço que uma pessoa está fazendo durante a revisão de código na frente de toda a equipe pode funcionar, mas não se estresse com isso.

Em caso de dúvida, defina o processo e diga à equipe que eles precisam cumpri-lo.

E há uma última coisa que você pode tentar - por mais controverso que seja: deixe o @ # $% atingir o ventilador, se eu puder usar um idioma.

Deixe a equipe falhar, porque o processo de revisão de código não está sendo seguido. A gerência se envolverá e as pessoas mudarão. Essa é realmente apenas uma boa ideia nos casos mais extremos em que você já definiu um processo e a equipe se recusou a cumpri-lo. Se você não tem autoridade para demitir pessoas ou discipliná-las (como a maioria dos desenvolvedores líderes não ), precisa envolver alguém que possa fazer essas coisas.

E não há nada como falha em fazer as coisas mudarem. Apesar do que as pessoas possam dizer, você pode dirigir o Titanic - mas não antes que ele atinja o burg de gelo.

Às vezes, você só precisa deixar o Titanic acertar no gelo.

Greg Burghardt
fonte