Quais são as vantagens de usar a ramificação como desenvolvedor solo?

Primeiro, estou ciente de que muitas perguntas foram feitas sobre o VCS como desenvolvedor solo, mas elas geralmente são muito amplas. Isso se refere apenas à ramificação, e ainda assim foi marcado como duplicado ... o suposto duplicado é novamente marcado como outra duplicata de outra pergunta que é muito ampla e não se refere especificamente à ramificação. É assim que a minha pergunta é única.

Quais são as vantagens, se houver, de usar a ramificação como desenvolvedor solo? Eu sempre o vi recomendado mesmo em um contexto solo-dev, mas, tanto quanto eu posso ver, além de usar um tronco 'master' para desenvolvimento e ramificar-se para trabalhar com código pronto para lançamento, não vejo como Eu poderia aproveitar o poder da ramificação (por exemplo, para compartimentar novos recursos) sem complicar demais todo o processo de desenvolvimento.

As vantagens são basicamente as mesmas que para grupos de desenvolvedores. Ao usar uma ramificação mestre sempre pronta para liberação e ramificações de recursos para desenvolver novos recursos, você sempre pode liberar a master. Encontrou um bug importante ao trabalhar em um recurso? Alterne ramificação, conserte, libere, retorne e continue desenvolvendo.

Ou talvez este seja um projeto de hobby e você goste de poder trabalhar um pouco nesse recurso e um pouco disso, conforme o clima o impressionar. Basicamente, você está imitando uma equipe de várias pessoas cortando o tempo.

A ramificação implícita que os DVCSs fazem nos clones significa que as ramificações formais no repositório autoritativo têm menos a ver com a coordenação de pessoas e mais com a coordenação de direções de desenvolvimento, e mesmo uma única pessoa pode fazer várias delas.

Desenvolvimento de longa duração

A ramificação de uma equipe para uma única pessoa seria útil para um recurso de desenvolvimento de longa duração que, de outra forma, não se encaixa no seu ciclo de lançamento.

Você pode escolher uma ramificação para sua alteração de abrangência de vários meses e ainda poder enviar as correções ou alterações diárias de erros da ramificação principal em intervalos regulares.

Isso tem a vantagem sobre os 'switches' em uma única ramificação, pois sua ramificação principal está sempre em um estado implementável e você tem a garantia de que nada no recurso de longo prazo teve impacto em outro código testado anteriormente.

Recursos experimentais

Uma ramificação também pode ser útil para os recursos que você deseja criar um protótipo, mas que nunca podem ser inseridos no código implantado. Completá-las em um ramo que, em última análise, será jogado fora significa que você nunca polui sua base de código principal desnecessariamente.

Eu o uso para manutenção crítica de sites. Sou o único desenvolvedor, mas tenho um mestre, desenvolvo e emito ramos.

Meu processo de trabalho para a configuração do site é semelhante a este:

1. Tornar o ramo mestre viável. Faça o commit inicial.

2. Caixa desenvolver filial. Não faça nada, desenvolva funções como um buffer de teste para mesclar no master.

3. Ramo de emissão do Google Checkout. Codifique seu problema, quando estiver pronto, desenvolva-o, veja se há algum problema, mescla conflitos etc ... conserte-os.

Quando problemas suficientes são mesclados no desenvolvimento para uma liberação e o desenvolvimento foi testado quanto à estabilidade, puxe o item para o mestre.

   Master
     |
   Develop  - E
   / |  \  \
 A   B   C  D

Dessa forma, você obtém uma coleção completa de testes em desenvolvimento, onde é possível testar a estabilidade, os problemas, etc ... sem correr o risco de prejudicar o Master e reverter os commits se eles forem prejudiciais.

Além disso, usando ramificações individuais para confirmação, você pode "deixar" o trabalho que já fez, começar de novo em outra coisa para corrigir um problema mais urgente e distribuí-lo mais cedo.

Na vida real, normalmente tenho um ramo de questões, e puxo esse para o desenvolvimento e depois para o mestre. Às vezes é entediante, mas a cada dois meses pelo menos eu tenho que largar o trabalho com um chapéu, porque alguém teve uma idéia de que eu tenho que criar o RightNow ™ e dessa maneira eu posso voltar rapidamente ao estado base, fazer a coisa e depois continuar onde eu estava. Especialmente em grandes projetos que levam várias semanas, esse é um grande incentivo para que eu possa trocar rapidamente de ramo.

Considere este cenário: Você sempre trabalhar em um ramo principal e você tem AwesomeCodeThing ™ nas obras que deixa o seu ramo Mestre em cirurgia de coração aberto e uma YugeBug ™ aparece que precisa de conserto urgente de outra forma milhares de usuários vai reclamar com você sobre BigProblems ™
A única maneira de resolver rapidamente seu problema nesse cenário,

1. verifique suas confirmações anteriores,
2. ver quando foi o seu último commit estável (a maldição é opcional)
3. reverter para esse commit
4. fazer reparo, enviar reparo para produção
5. resolva todos os conflitos e problemas que você está tentando recuperar ao status AwesomeCodeThing ™
6. desistir, chorar e começar a trabalhar. (opcional)

Se você usar ramos:

1. Mestre do Google Checkout
2. criar ramo UrgentFix ™ e consertar coisas
3. puxe o UrgentFix ™ para o mestre
4. empurrar para a produção
5. Mesclar mestre para desenvolver
6. Mesclar o desenvolvimento no AwesomeCodeThing ™
7. pegue uma cerveja e continue trabalhando.

As ramificações facilitam o trabalho em vários recursos ao mesmo tempo, o que pode ser bastante útil quando as prioridades mudam durante o andamento de um projeto.

Digamos que você decida que um recurso é mais importante agora. Talvez você precise urgentemente corrigir um bug crítico em um sistema ativo. Você pode estar trabalhando com um cliente em vários recursos por um longo período e pode demonstrar o progresso de cada recurso separadamente. Talvez você tenha acabado de ler sobre uma exploração desagradável do dia zero e queira entrar nela antes que o cliente leia sobre ela.

Se você estiver usando ramificações para cada recurso / hotfix, normalmente será mais fácil, mais limpo e mais rápido isolar e implantar essas modificações, em vez de usar uma única ramificação para tudo. Isso vale se você é um desenvolvedor único ou faz parte de uma equipe.

Quanto a um processo real, acho que o fluxo git funciona bem. A folha de dicas do Daniel Kummer é um ótimo recurso, vale a pena olhar mesmo que você não esteja usando o git.

Como mencionado em outros pôsteres, as vantagens são substancialmente semelhantes ao trabalho em equipe: a capacidade de desenvolver e testar recursos de forma independente, manter um ramo mestre separado para hotfixes / implantações de produção, experimentar.

Para mim, em geral, geralmente trabalho como mestre se conheço muito bem a área em que estou trabalhando, isso apenas acrescenta sobrecarga à ramificação, porque eu as fundirei de qualquer maneira.

No entanto, se eu tiver alguma dúvida sobre as alterações que estou fazendo, vou ramificar e somente PR / mesclar depois que o ramo se comportar conforme o esperado e geralmente for totalmente testado. Dessa forma, se eu descobrir um problema para o qual reverter é o melhor curso de ação, é um único commit em vez de uma série inteira (nunca me lembro da sintaxe de reverter uma série de commits, mas um único é fácil).