O git "Regra de Ouro da Remasterização" é tão essencial?

Recentemente, tive uma discussão com pessoas absolutamente opostas a uma estratégia de rebase de ramos de recursos no GIT. Parece ser um padrão aceito usar rebase apenas para ramificações locais e privadas, mas nunca usá-lo quando há várias pessoas trabalhando em um mesmo recurso e ramificação, conforme a chamada "Regra de Ouro da Rebasagem" (como explicado aqui: https : //www.atlassian.com/git/tutorials/merging-vs-rebasing/conceptual-overview )

Estou surpreso que haja um consenso sobre isso. Trabalhei 3 anos com uma estratégia de rebaseamento completa, com cerca de 20 desenvolvedores trabalhando juntos e, adivinhem, funcionou.

O processo é basicamente:

• Você cria seu ramo de recursos, vamos chamá-lo de "myfeature" e empurrá-lo para origin / myfeature
• Outras pessoas podem conferir e trabalhar nele
• Às vezes, você pode refazê-lo do master: de "myfeature", git rebase origin / master ; e então, sim, você precisa forçá-lo.
• O que acontece quando outras pessoas querem pressionar seus commits? Eles apenas o refazem: git rebase origin / myfeature . Portanto, eles estão agora avançando rapidamente e podem pressioná-lo sem forçar.

O único princípio a respeitar é que o ramo de recursos pertence a alguém . O proprietário é o único que pode forçar.

Então, admito: assim que houver uma força de empurrão, há o risco de cometer erros. Isso é verdade. Mas também existem muitas maneiras de se recuperar de erros e, realmente, em 3 anos de desenvolvimento, eu não vi muitos erros de força e, quando isso aconteceu, sempre encontramos uma maneira de se recuperar adequadamente.

Então, por que essa "Regra de Ouro da Rebase" está sendo tão amplamente aceita? Há algo mais que eu perdi com isso? Entendo que requer um mínimo de organização (toda estratégia requer alguma organização), mas funciona.

O problema com o envio forçado não é sobre o ramo de recursos e o mestre, mas sobre o envio do mestre ao mestre de outra pessoa - que a sincronização substituirá o mestre com as alterações, ignorando o que estiver na dica.

Considerando esse perigo, há uma razão pela qual você não deve usá-lo, a menos que as coisas tenham estragado tudo e você precise absolutamente, totalmente, usá-lo para efetuar reparos. Um sistema SCM nem sempre precisa ser forçado assim, se isso acontecer porque algo deu muito errado (e minha primeira abordagem nesses casos seria restaurar backups e repetir as operações para manter o histórico intacto).

Então, talvez a questão seja: por que você está se rebaixando? Para uma história 'limpa' ao trazer os recursos de volta ao mestre? Nesse caso, você está jogando fora toda a boa história relativa à ramificação por razões puramente de estilo. A mesclagem rápida de IMHO também não é uma prática recomendada. Você deve manter toda a história para poder ver o que realmente fez, e não uma versão higienizada posteriormente.

Rebase não é essencial, como você diz, é principalmente cosmético. Às vezes é muito mais simples que uma mesclagem. Portanto, ele pode ter algum valor "real", mas apenas "às vezes"

O uso inadequado de rebase pode ser caro. É improvável que você perca dados se você souber o suficiente para não entrar em pânico e procurar procedimentos de recuperação, mas "ei, ninguém pressiona por um tempo, preciso corrigir ..." não é ótimo. Tampouco alguém está gastando tempo na recuperação e teste de pesquisas quando poderia estar adicionando recursos ou esmagando bugs (ou em casa com a família).

Com essa troca, os resultados de "muito poucas pessoas fazem um rebase e um empurrão forçado" não são muito surpreendentes.

Alguns fluxos de trabalho podem reduzir o risco, por exemplo, reduzi-lo para "zero, desde que você lembre quais ramificações você pode forçar e quais não pode". Na realidade, eles podem ser seguros o suficiente para justificar o risco, mas as pessoas freqüentemente fazem escolhas baseadas em folclore maior. Então, novamente, na realidade, os benefícios são bem pequenos, então, quão pequeno é realmente o risco?

Para adicionar uma voz diferente:

Sim, se você trabalha como você descreve, não há problema em usar rebasee pressionar com força. O ponto crítico é: você tem um acordo em sua equipe.

Os avisos rebasee amigos são para o caso em que não há acordo especial. Normalmente, o git protege você automaticamente, por exemplo, não permitindo um push não-rápido. O uso rebasee a pressão forçada substituem essa segurança. Tudo bem se você tiver algo mais no lugar.

Na minha equipe, às vezes também refazemos as ramificações dos recursos se o histórico ficar confuso. Excluímos o ramo antigo e fazemos um novo com um novo nome, ou apenas coordenamos informalmente (o que é possível porque somos uma equipe pequena e ninguém mais trabalha em nosso repositório).

Observe que o próprio projeto git também faz algo semelhante: eles têm um ramo de integração que é recriado regularmente, chamado "pu" ("atualizações propostas"). Está documentado que esse ramo é recriado regularmente e que você não deve basear novos trabalhos nele.

Então, admito: assim que houver uma força de empurrão, há o risco de cometer erros. Isso é verdade. Mas também existem muitas maneiras de se recuperar de erros e, realmente, em 3 anos de desenvolvimento, eu não vi muitos erros de força e, quando isso aconteceu, sempre encontramos uma maneira de se recuperar adequadamente.

A razão pela qual os usuários do Git tendem a evitar o histórico mutável compartilhado é porque não há prevenção ou reparo automático desses problemas. Você precisa saber o que está fazendo e precisa consertar tudo manualmente, se errar. Permitindo exatamente um pessoa faça force-push não é intuitivo e contrário ao design distribuído do Git. O que acontece se essa pessoa sai de férias? Alguém possui temporariamente a filial? Como você sabe que eles não vão andar por tudo o que o proprietário original estava fazendo? E no mundo do código aberto, o que acontece se o proprietário da filial se afastar gradualmente da comunidade, sem sair oficialmente? Você pode perder muito tempo esperando para transferir a propriedade da filial para outra pessoa.

Mas o problema real é o seguinte: se você errar e não perceber imediatamente, os antigos commits desaparecerão depois que tiver decorrido tempo suficiente. Nesse ponto, o problema pode ser irrecuperável (ou pelo menos potencialmente muito difícil de recuperar, dependendo da aparência da sua história de backup - você faz backup de cópias antigas do seu repositório Git, ou seja, não apenas de clones?).

Compare isso com o trabalho de evolução do Changesur da Mercurial (que, devo observar, ainda não está concluído ou estável). Todos podem fazer as alterações desejadas no histórico, desde que os conjuntos de alterações não sejam marcados como públicos. Essas alterações e reparos podem ser empurrados e retirados com total impunidade, sem a necessidade de um proprietário de filial. Nenhum dado é excluído; todo o repositório local é apenas anexado. Os conjuntos de alterações que não são mais necessários são marcados como obsoletos, mas mantidos indefinidamente. Finalmente, quando você bagunça seu histórico (que é tratado como uma parte normal do seu fluxo de trabalho diário), há um comando bacana para limpá-lo automaticamente para você. Esse é o tipo de UX que as pessoas esperam antes de modificar o histórico compartilhado.