Qual será a melhor prática para ter 'revisado' o código fonte em um repositório de controle de origem?

Qual será a melhor maneira de gerenciar o código fonte revisado em um repositório de controle de origem? O código-fonte deve passar por um processo de revisão antes de fazer o check-in ou deve ocorrer após a confirmação do código? Se a revisão ocorrer após o check-in do código no repositório, como isso deve ser rastreado?

O Google tem as melhores práticas de revisão de código de qualquer lugar que eu já vi. Todos os que conheci estão de pleno acordo sobre como fazer revisões de código. O mantra é "revise cedo e frequentemente".

Suponha que você use um processo parecido com o que Graham Lee sugeriu. (Que é um processo que eu já havia usado anteriormente.) O problema é que os revisores estão sendo solicitados a examinar grandes pedaços de código. Isso é muito mais esforço, e é mais difícil conseguir que os revisores o façam. E quando eles fazem isso, é mais difícil fazê-los fazer um trabalho completo. Além disso, quando eles percebem problemas de design, é mais difícil fazer com que os desenvolvedores voltem e refizem todo o código de trabalho para torná-lo melhor. Você ainda captura coisas e ainda é valioso, mas não notará que está perdendo mais de 90% do benefício.

Por outro lado, o Google tem uma revisão de código em cada confirmação antes de poder entrar no controle de origem. Ingenuamente, muitas pessoas pensam que este seria um processo pesado. Mas isso não funciona dessa maneira na prática. É extremamente mais fácil revisar pequenos pedaços de código isoladamente. Quando são encontrados problemas, é muito menos trabalhoso alterar o design, porque você ainda não escreveu um monte de código em torno desse design. O resultado é que é muito mais fácil fazer uma revisão completa do código e muito mais fácil corrigir os problemas alterados.

Se você deseja fazer uma revisão de código como o Google (o que eu realmente recomendo), existe um software para ajudá-lo. O Google lançou sua ferramenta integrada ao Subversion como Rietveld . O Go (o idioma) é desenvolvido com uma versão do Rietveld modificada para uso com o Mercurial. Há uma reescrita para pessoas que usam o git chamado Gerrit . Também vi duas ferramentas comerciais recomendadas para isso, o Crisol e o Review Board .

O único que eu usei é a versão interna do Google do Rietveld, e fiquei muito satisfeito com isso.

Uma técnica que usei em várias equipes é a seguinte:

• os desenvolvedores podem integrar a fonte em sua própria filial ou repositório local sem revisar
• desenvolvedores podem integrar-se ao tronco / mestre sem revisar
• o código deve ser revisado e os comentários da revisão endereçados, antes de poder ser integrado do tronco / mestre em uma ramificação candidata à liberação

É responsabilidade do autor do código buscar a revisão, e a responsabilidade do mantenedor do ramo de lançamento garantir que apenas o código revisado seja mesclado.

Existem ferramentas que suportam a revisão de código, mas nunca as usei. O rastreamento de quem fez a revisão para qualquer mesclagem pode ser feito dentro do repo. Eu usei propriedades svn e forforce jobs anexados a commits para mostrar quem revisou o que.

Nunca separei o código para revisão por critérios confirmados / não confirmados - o único critério encontrado foi que os testes de unidade e de integração são verdes.

Quanto ao rastreamento, recomendo atualizar o fluxo no seu rastreador de problemas favorito. Por exemplo, em vez de:

• Proprietário do produto -> Analista -> Desenvolvedor -> Controle de qualidade -> Engenheiro de liberação

Você pode querer apresentar mais uma etapa (revisão):

• Proprietário do produto -> Analista -> Desenvolvedor -> Revisor -> QA -> Engenheiro de liberação

Portanto, para cada bilhete em Implementado estado, você pode atribuir um revisor e apenas Avaliado bilhetes vai avançar para QA.

Eu tenho apenas uma experiência de revisões de código, então não posso dizer como é bom.

Eu estava trabalhando com um pequeno (~ 10-15) grupo de codificadores e estávamos usando o VS Team Foundation Studio. Nos pediram para confirmar o código uma vez por dia, e antes que cada código de confirmação fosse revisado por outra pessoa do grupo (esperançosamente por alguém também envolvido no projeto). Durante a confirmação, o nome da pessoa também foi incluído em um campo.

Trabalhei em uma equipe que codificou o conteúdo de tudo que foi verificado, uma após a outra, durante algumas revisões por semana. Isso significava que nem sempre estávamos atualizados com as revisões de código, mas alcançávamos o que pretendíamos alcançar.

Então, primeiro, pergunte o que você deseja alcançar revisando o código. No nosso caso, não era para pegar desenvolvedores idiotas, havia uma suposição de competência, e não uma suposição de incompetência. Isso permitiu que a equipe obtivesse uma visão geral de outras áreas do sistema e permitia que algumas decisões questionáveis ​​de projeto fossem corrigidas antes de serem gravadas. Por questionável, quero dizer, sempre há mais de uma maneira de esfolar um gato, e nem todo mundo sabe que já existe uma faca de esfolar na caixa de ferramentas, por assim dizer.

A maneira como lidamos com as revisões de código foi que todas as tarefas do nosso software de rastreamento de projetos foram revisadas. Na época, estávamos usando o Mantis e o SVN. As confirmações do nosso projeto foram vinculadas aos dois sistemas. Todo commit tinha que estar vinculado a uma tarefa no mantis. Depois que a tarefa foi concluída, um status de "Pronto para revisão" foi atribuído a ela.

Os itens de RFR foram apanhados por qualquer pessoa que tivesse algum tempo livre para revisões ou foi atribuída a uma pessoa específica para revisão. Às sextas-feiras, todos os itens de RFR tinham que ser revisados ​​antes do final do dia, para que não houvesse transferência para a semana seguinte.

Os únicos problemas que encontramos com esse processo foram itens grandes que tinham uma tonelada de arquivos. Para lidar com isso, o codificador e o revisor se reuniam e o codificador executava as alterações até que o revisor as entendesse. Eles fariam a revisão do código juntos.

Esse processo foi interrompido quando o gerenciamento determinou que, se a programação por pares fosse realizada, uma revisão de código separada seria desnecessária. Os desenvolvedores ficaram relaxados com o processo e pequenos erros estúpidos começaram a ser introduzidos. Eventualmente, voltamos ao processo original e as coisas voltaram juntas.

Na minha equipe, estamos usando uma prática há mais ou menos um ano que parece funcionar muito bem.

Nossa organização usa o Perforce para controle de versão. O Perforce (a partir de um ano atrás) inclui um recurso chamado Shelving. Com as prateleiras, posso "arquivar" minhas alterações para um problema específico. Eles são armazenados no sistema de controle de versão, mas não são registrados. Depois, peço a outro desenvolvedor da minha equipe que revise o código.

O outro desenvolvedor pode visualizar minhas alterações pendentes no Perforce em seu próprio computador e comparar as alterações com as revisões mais recentes. Ele também pode "desmontar" sua máquina local, se ele quiser experimentar minhas alterações. Quando ele termina a revisão, ele me avisa. Em seguida, verifico meu código com "Avaliado por Bob" no final do comentário.

Isso funcionou muito bem para nós. Primeiro de tudo, as revisões de código em geral provaram ser extremamente úteis. Além disso, o recurso de prateleira do Perforce nos permite fazer as revisões sem fazer check-in ou qualquer grande dificuldade, mesmo que nossa equipe seja geograficamente difundida - isso é muito importante. E funciona muito bem.