Seus melhores programadores devem verificar o código de todos os outros no controle de origem?

Uma das diferenças entre svn e git é a capacidade de controlar o acesso ao repositório. É difícil comparar os dois, porque há uma diferença de perspectiva sobre quem deve ter permissão para cometer mudanças!

Esta pergunta é sobre o uso do git como repositório centralizado para uma equipe em uma empresa em algum lugar. Suponha que os membros da equipe tenham diferentes níveis de habilidade, da mesma forma que na maioria das empresas.

O Git parece assumir que apenas seus melhores programadores (mais produtivos, mais experientes) são confiáveis ​​para verificar o código. Se for esse o caso, você está dispensando o tempo de realmente escrever o código para revisar o código de outras pessoas para fazer o check-in. Isso vale a pena? Eu realmente quero focar essa pergunta no melhor uso do tempo do seu melhor programador, não nas melhores práticas de controle de versão em geral . Um corolário pode ser: bons programadores param de trabalhar se uma parte significativa de seu trabalho é revisar o código de outras pessoas? Penso que ambas as questões se resumem a: a revisão vale a pena a produtividade atingida?

Como não está claro em sua pergunta, quero apenas salientar que um fluxo de trabalho de gatekeeper não é de forma alguma necessário com o git. É popular em projetos de código aberto por causa do grande número de colaboradores não confiáveis, mas não faz tanto sentido dentro de uma organização. Você tem a opção de dar a todos acesso por push, se quiser.

O que as pessoas estão negligenciando nessa análise é que bons programadores passam muito tempo lidando com o código quebrado de outros programadores de qualquer maneira. Se todos tiverem acesso por push, a compilação será interrompida e os melhores programadores tendem a integrar e rastrear com frequência os culpados quando as coisas acontecem.

O fato de todo mundo ter acesso por push é que, quando algo quebra, todo mundo que recebe recebe uma compilação quebrada até que a confirmação incorreta seja revertida ou corrigida. Com um fluxo de trabalho do gatekeeper, apenas o gatekeeper é afetado. Em outras palavras, você está afetando apenas um dos seus melhores programadores, em vez de todos eles.

Pode acontecer que a qualidade do seu código seja razoavelmente alta e a relação custo-benefício de um gatekeeper ainda não valha a pena, mas não negligencie os custos familiares. Só porque você está acostumado a essa perda de produtividade não significa que não ocorra.

Além disso, não se esqueça de explorar as opções híbridas. É muito fácil, com o git, configurar um repositório para o qual qualquer pessoa possa enviar mensagens e, em seguida, um gatekeeper como desenvolvedor sênior, testador ou até mesmo um servidor de integração contínua automatizado decide se e quando uma alteração o torna em um segundo repositório mais estável. Dessa forma, você pode obter o melhor dos dois mundos.

Eu trabalhei em um trabalho em que os check-ins eram limitados apenas aos líderes de equipe (e os líderes de equipe não podiam fazer check-in em seu próprio código). Isso serviu como nosso mecanismo para impor revisões de código, principalmente devido a vários incidentes em que as confirmações ruins entraram na base de código, mesmo em torno de check-ins fechados e análises estáticas.

Por um lado, fez o seu trabalho. Várias confirmações ruins foram encontradas antes de entrarem na base de código (e prontamente esquecidas por uma semana ou mais, até que alguém as encontrasse). Isso causou menos interrupções na base de código. Além disso, eu poderia adiar algumas coisas de formatação / estrutura antes que elas se tornassem dívida tecnológica; pegar alguns bugs antes que eles se tornassem bugs. E isso me deu uma ótima sensação do que minha equipe estava fazendo.

Por outro lado, isso me levou a entrar espontaneamente em fúria assassina quando minha mudança de três linhas levou 4 horas para ser comprometida por ter que localizar outra pista e levá-las a fazer a confirmação. Isso me levou a fazer confirmações muito menos freqüentes do que as práticas recomendadas e, ocasionalmente, levava a problemas tentando rastrear alterações no desenvolvedor que as fazia.

Geralmente, eu não recomendaria, exceto nos ambientes mais necessitados. Fazer as revisões e confirmações não foi tão ruim, na verdade. Ter meu próprio processo dependente dos caprichos dos outros era irritante. Se você não pode confiar em seus desenvolvedores para verificar o código, obtenha desenvolvedores melhores.

Não. Qualquer pessoa deve poder se comprometer.

Se você tiver problemas com erros cometidos, não é a política de controle de origem que está errada. São os desenvolvedores que não conseguem garantir que o que ele / ela comete funcione. Então, o que você precisa fazer é definir diretrizes claras sobre o que comprometer e quando.

Outra grande coisa é chamada de testes de unidade;)

Existe uma alternativa embora.

a) Se você usar o controle de versão distribuído, poderá criar um repositório principal para o qual apenas solicitações pull podem ser feitas. Dessa forma, todos os desenvolvedores podem obter o controle de versão de seu próprio código enquanto você controla o ramo principal.

b) No subversion e similares, você pode usar branches onde cada desenvolvedor deve criar patches para inseri-lo no branch principal.

Você deve dar uma olhada em projetos como o Gerrit, que permite que todos os desenvolvedores enviem seu código para o ramo 'review' e, assim que os desenvolvedores sênior / principais estiverem satisfeitos com essas mudanças, eles poderão enviá-los para o master / release.

Se não estiverem satisfeitos, podem deixar comentários ao lado de uma linha de código, solicitar um patch atualizado etc.

Dessa forma, qualquer pessoa com uma alteração pendente pode obtê-la assim que estiver pronta e apenas pessoas qualificadas (com os privilégios de +2 certos na Gerrit) poderão enviar esse código para teste e posteriormente para produção.

Não, é um mau uso dos seus melhores talentos. Imagine uma editora pegando seus autores de maior sucesso e obrigando-os a editar; péssima ideia.

Deveria haver revisões de código, mas isso não significa que é sempre um Sr. verificando o código de um jr. Eventualmente, é esperado que todos na equipe cheguem ao nível em que possam contribuir com código com o mínimo de orientação. Eles passam pelos três níveis de confiança:

1. Nenhum - quero ver todas as linhas de código antes de fazer o check-in.
2. Alguns - Deixe-me saber o que você está fazendo e eu fornecerei feedback
3. A maioria - Vá fazer o seu trabalho e só peça ajuda quando necessário.

Vantagens de liberar seu talento:

• foco no design
• envolvimento na criação de padrões de codificação e estratégias de aplicação (sem fazer tudo manualmente)
• resolver os difíceis problemas de codificação
• fornecer orientação (sem ter aprovado todas as linhas de código)

Existem desenvolvedores interessados ​​em um caminho de gerenciamento que podem preferir não codificar o dia inteiro; deixe os outros em paz.

a revisão vale o impacto da produtividade?

Depende do "equilíbrio" da equipe e de como as revisões são configuradas. Ambas são questões de gerenciamento e trabalho em equipe, nenhuma quantidade de magia tecnológica de controle de versão (centralizada ou distribuída) pode ter uma influência substancial nisso.

Se feito errado , a queda na produtividade certamente matará quaisquer benefícios da revisão; a resposta é, no entanto, para não deixar de lado as opiniões, mas descobrir como fazê-lo corretamente .

Uma abordagem para descobrir se suas revisões são válidas é usar a ferramenta de rastreamento de problemas para rastrear o tempo gasto nas revisões (algumas ferramentas de revisão de código também permitem isso). Se você descobrir que as revisões estão demorando bastante, invista algum esforço para descobrir as razões e maneiras de melhorar as coisas. Além disso, não faria mal ter 1: 1s regulares com os membros da equipe para descobrir possíveis problemas com as revisões de código.

Se os "melhores" programadores da equipe são forçados a passar horas vasculhando lixo incompreensível produzido por codificadores ruins, a solução é despedir os fabricantes de lixo, não apelar para a tecnologia VCS.

• ^{Em um dos projetos anteriores, fui designado para revisar as alterações de código feitas por um membro da equipe com desempenho permanente baixo, em um componente que levou quase uma hora para apenas criar e executar testes. Comecei a ler as diferenças e, quando notei uma mudança indescritível, simplesmente concluí a revisão, publiquei os comentários necessários e pedi à gerência para garantir que as solicitações de revisão adicionais viessem com confirmação por escrito de que o código é compilado. Não houve "pedidos de revisão" desde então e logo o cara saiu.}

Por outro lado, quando a equipe está razoavelmente equilibrada, as revisões de código são divertidas e educativas. No meu projeto anterior, tínhamos um requisito para 100% de revisão de código e isso não levou muito tempo nem foi perturbador. Houve erros descobertos através da revisão e houve debates sobre o estilo de codificação e as opções de design, mas isso pareceu ... normal .

Se as alterações de código estiverem bloqueadas por dias ... semanas após o controle de qualidade para testes "por causa de revisões", estudar os truques do VCS seria a maneira menos provável de resolver esse problema. Em vez disso, seria melhor concentrar seus esforços na descoberta de problemas na maneira como o processo de revisão é organizado.

• <sup>- Oh, a integração dessa mudança foi muito atrasada porque o revisor ficou repentinamente doente, que infortúnio.
  - Olá! Caramba, você já pensou em ter revisores de backup para lidar com casos como esse?</sup>

Sim. Mas apenas se você estiver falando sobre controle de fonte distribuído. Com centralizado - depende.

Se houver apenas alguns programadores, leva pouco tempo. Certamente menos do que as correções necessárias para remover erros e dívidas técnicas posteriormente.

Se houver muitos programadores, você poderá delegar a tarefa de revisão de código real aos tenentes e pedir ao desenvolvedor principal que faça suas alterações (quase) inquestionavelmente. Funciona para o kernel Linux, não acho que haja projetos de software maiores ...

Novamente, se o projeto for pequeno, o líder verá rapidamente quem fornece um bom código e quem produz um código incorreto. Ele verá rapidamente que J.Random escreve código bom que precisa apenas verificar decisões de arquitetura, enquanto o estagiário escreve código ruim que precisa ser revisado linha por linha antes da mesclagem. O feedback gerado dessa maneira reduzirá a carga de manutenção na linha e proporcionará uma experiência em primeira mão sobre o que o estagiário realmente aprender e deve ser mantido na empresa. Obter e mesclar ramificações de outros gitrepositórios leva literalmente uma dúzia de segundos, geralmente a leitura dos títulos das mensagens de confirmação levará mais tempo; portanto, depois de saber quem é confiável escrever um bom código mesclando o código de outras pessoas, isso não é problema.

A revisão de código não requer necessariamente a atenção apenas dos seus melhores programadores. IMO, deve ser uma coisa informal. Apenas uma segunda opinião ou um segundo par de olhos em um pedaço de código de um não novato antes de ser verificado na produção. Isso ajuda a atenuar grandes descuidos e, ao mesmo tempo, ajuda as pessoas a melhorar a codificação como um ofício ao serem expostas a outras perspectivas de desenvolvimento.

Uma espécie de programação de pares menos desagradável. Em outras palavras, não deve demorar muito e você não precisa esperar alguém por horas. Qualquer coisa em seu processo de desenvolvimento que envolva pessoas esperando por coisas é um desperdício de dinheiro e prejudicial ao momento / moral, IMO.

Se a revisão de código visava parar 99,5% dos bugs antes que eles entrassem na sua base de código, não haveria razão real para o sofisticado controle de versão. Dito isso, o git é intimidador no início, mas o uso geral básico não é tão complicado e é altamente configurável. Você deve poder parar por algumas horas para ensinar a todos como usá-lo. Todo mundo comete. Todos, exceto os novatos mais nobres, revisam até que demonstrem conhecimento em alguma coisa.

Desde que as alterações submetidas tenham sido revisadas pelos 'melhores programadores', qualquer pessoa deve ter permissão para enviar código. A única pessoa que deve ter a capacidade de impor o controle em um repositório é o Engenheiro de Liberação, se essa pessoa existir.

Pessoalmente, eu ficaria muito chateado se tivesse que verificar o código de outras pessoas.

Algumas informações sobre sua edição: não, não deveriam. Comentários são um mal necessário, eles fazem mais bem do que mal e bons programadores apreciarão isso. Talvez haja relutância em participar das revisões, porque elas não gostam da ideia de 'programadores menores' criticando seu código. Isso é muito ruim. Eles seriam muito mais propensos a desistir se a linha de código estiver constantemente com erros e, em vez disso, gastam seu tempo limpando as submissões de outras pessoas pela metade.

Sim, a revisão vale a pena. Não tenho certeza se há um impacto na produtividade se o processo de revisão for proporcional pelos seguintes motivos:

• Mantém os programadores honestos - se você souber que será revisado, as pessoas usarão menos atalhos
• Ajuda novos programadores a aprender com mais programadores experientes
• Ajuda a transferir conhecimentos específicos de domínio
• A revisão é outro portal em que erros e possíveis problemas podem ser encontrados e corrigidos

Ao não permitir que todos os programadores usem o controle de origem, eles perdem a capacidade de rastrear alterações, desfazer erros e ver um histórico razoável de alterações. Não sei se você gostaria que apenas seus "melhores" programadores pudessem fazer check-in no git.

Dito isto, acho razoável que você tenha alguém encarregado de certas ramificações importantes, como uma ramificação de lançamento. Nesse caso, eu imagino que todos possam usar o repositório git, mas apenas algumas pessoas se fundem no ramo de lançamento. Não tenho certeza de que haja uma maneira de aplicar isso no git, mas deve ser possível fazer isso por processo e apenas verificar se ninguém mais fez check-in.

A fusão no ramo de lançamento pode ser feita pelos "melhores" programadores, ou mais provavelmente por pessoas competentes, após uma revisão suficiente.

bons programadores param se uma parte significativa de seu trabalho é revisar o código de outras pessoas?

Se eles não estiverem gostando do trabalho e forçados a fazer essa atividade, então SIM. É muito provável que isso aconteça. Encontrar o próximo trabalho interessante para um bom desenvolvedor não é um grande desafio hoje em dia.

Seus melhores programadores devem verificar o código de todos os outros no controle de origem?

Absolutamente não. Com certeza é perda de tempo, exceto por alguma lógica crítica que precisa estar em estado sólido .

No entanto, os desenvolvedores juniores ou experientes provavelmente devem estar em período probatório para obter a qualidade do código , apenas para garantir um código seguro e garantir que o código siga as diretrizes de desenvolvimento da equipe, pelo menos por algumas semanas antes de obter o privilégio de se comprometer.