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

29

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?

GlenPeterson
fonte
5
Definir "melhor programador"? Melhor em quê? Seguindo regras arbitrárias? Código de ativação? Escrevendo código com defeito zero?
Timo Geusch
3
Desculpe, ainda estou tentando entender o conceito de revisar código descontrolado (ou seja, sem check-in) ... certamente um dos principais benefícios do uso de um SCS é que a revisão pode ser feita contra um controle conhecido / controlado iteração do código?
Andrew
2
@ Andrew com gitqualquer desenvolvedor pode ter seu próprio repositório (em seu computador pessoal) e um repositório pessoal público (aquele em um servidor, atrás apache) ao qual ele só pode adicionar alterações. A diferença é que apenas o principal representante do desenvolvedor é o "abençoado", aquele em que todos deveriam fazer o checkout. O código de checkouts de chumbo dos repositórios públicos do desenvolvedor e os mescla ao seu repositório público. Vocês dois têm iteração conhecida / controlada, bem como controle de origem o tempo todo.
quer
32
"O Git parece assumir que apenas seus melhores programadores (mais produtivos, mais experientes) são confiáveis ​​para verificar o código" é uma presunção incorreta. O Git pode ser configurado como você deseja. O modelo "solicitação de recebimento" é apenas uma maneira - ideal para projetos de código aberto com um grande número potencial de colaboradores desconhecidos. Na maioria dos ambientes comerciais, o modelo de "solicitação de recebimento" seria uma bandeira vermelha, indicando processos e procedimentos ruins de SDLC e QC.
mattnz
4
Acredito que @mattnz está correto aqui. Isso é apenas o resultado de uma forte influência de código aberto no git, onde há uma equipe de desenvolvimento principal que controla o estado do repositório, mas outros também podem contribuir.
Steven Evers

Respostas:

53

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.

Karl Bielefeldt
fonte
10
+1: Para ... Bons programadores passam muito tempo lidando com o código quebrado de outros programadores de qualquer maneira.
Jim G.
3
+1 Melhor resposta. Especialmente salientando que um desenvolvedor que cometeu um bug de quebra de construção afeta negativamente todos.
Evan Solha
Nessa situação, os dois melhores programadores foram usados ​​em tempo integral para revisar e corrigir o código de outras pessoas. Certamente, a qualidade do código no VCS era boa, mas o moral desses dois diminuía mais rapidamente do que um vaso sanitário. O que começou como uma idéia aparentemente boa se transformou em pesadelo quando esses dois correram para os lugares onde poderiam obter, digamos, tarefas mais criativas.
Newtopian 9/09/16
1
Esse é um bom argumento, @ Newtopian. Os lugares em que eu vi isso ter sucesso têm mais um modelo de microsserviço, e apenas uma equipe de scrum tem acesso a qualquer microsserviço, mas a responsabilidade é espalhada pelo sistema como um todo. Se você não tem pelo menos alguns programadores experientes por equipe scrum, suas práticas de contratação precisam melhorar.
Karl Bielefeldt
40

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.

Telastyn
fonte
8
@HubertKario - Se seus melhores desenvolvedores estão gastando tempo revisando códigos e o restante é efetivamente bloqueado até a conclusão, não vejo muita diferença prática.
precisa saber é o seguinte
6
Como eles estão bloqueados? Você cria um patch (confirmado localmente), envia-o a montante e continua trabalhando no novo widget (cria novos comprometimentos locais). Se sua alteração for aplicada literalmente, você só precisa fazer o checkout e mesclar o repo do lead. Se não foi aplicado literalmente, você ainda poderá refazer o seu trabalho posterior. Se a mudança for realmente crítica, você poderá publicá-la em seu próprio repositório público e solicitar às pessoas que façam check-out a partir daí ou apenas enviem patches. Nesse caso, gitele detectará que uma alteração já foi feita e pulará a aplicação do patch upstream específico.
Hubert Kario
9
A última linha nesta pergunta é realmente o ponto principal aos meus olhos. Um desenvolvedor não confiável será, na melhor das hipóteses, ineficaz e detestável de seu trabalho. Não contrate pessoas em quem você não confiará. É inútil desperdiçar dinheiro com pessoas pelas quais você não permitirá o trabalho pelo qual está pagando.
Jimmy Hoffa
1
@HubertKario - você sabe melhor que eu. O ambiente em que eu estava tornou irritante para manipular os diferentes ramos / conjuntos de alterações.
Telastyn
5
@ Telastyn Eu não sei se devo interpretar sua resposta tão literalmente quanto eu fiz, mas outra desvantagem seria a anotação / histórico de culpa. Se você encontrasse algum código que não entendia, acabaria perguntando ao revisor que o comprometeu, não ao programador que o escreveu.
Daniel Kaplan
28

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.

jgauffin
fonte
1
Este. Se você está comprometendo sem testes de unidade e construção, ter um requisito de revisão de código é um curativo imperfeito.
precisa saber é o seguinte
sim. Por isso mencionei as alternativas. Revisões de código são melhores que nada. Não poder versão do código é uma dor à qual nenhum desenvolvedor deve ser exposto.
jgauffin
2
Os testes de unidade não ajudam se forem escritos pelo mesmo <insira suas 4 letras favoritas aqui> que o código da unidade.
ott--
@BrianKnoblauch: pode-se argumentar que o oposto também é verdadeiro. Idealmente, você deve ter os dois.
Doc Brown
@ ott-- Acabei de ouvir uma história sobre um desenvolvedor que foi embora depois de cometer uma confusão horrível de uma correção e comentar todos os Asserts em seus testes de unidade. Os testes são bem-sucedidos por padrão, então demorou um pouco para perceber o problema!
8283 Alex
8

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.

rochal
fonte
2
Usamos o gerrit com grande sucesso. Resolve todos os problemas com os quais o OP tem um problema e até alguns que ele não sabe que tem.
mattnz
8

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.

JeffO
fonte
1
+1. Deixe a equipe revisar a equipe - tanto o revisor quanto o revisado podem lucrar, mesmo que o revisor seja menos experiente que o revisado. E você pode fazer toda a revisão APÓS o check-in. Na IMO, se você impedir que as pessoas façam check-in, sua produtividade diminuirá (apesar da motivação).
Andy
5

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.

  • - 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?
mosquito
fonte
4

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.

Hubert Kario
fonte
2

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.

Erik Reppen
fonte
0

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.

James
fonte
0

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.

Steve
fonte
1
-1: mantém os programadores honestos - se você souber que será revisado, as pessoas terão menos atalhos. - Hmm ... eu ficaria preocupado com a introdução de risco moral. Ou seja, os desenvolvedores podem ficar preguiçosos ou desleixados porque sabem que um desenvolvedor mais sênior sempre assumirá a responsabilidade pelo código na forma de uma revisão de código.
Jim G.
1
O revisor não se responsabiliza pelo código, mas fornece conselhos e instruções sobre problemas com o código. O desenvolvedor original deve corrigir os problemas e ainda é responsável pelo código.
Steve
-1

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.

EL Yusubov
fonte