É uma boa prática usar ramificações para manter edições diferentes do mesmo software?

Temos um produto que possui algumas edições diferentes. As diferenças são mínimas: cadeias diferentes aqui e ali, muito pouca lógica adicional em uma, muito pouca diferença na lógica na outra. Quando o software está sendo desenvolvido, a maioria das alterações precisa ser adicionada a cada edição; no entanto, existem alguns que não o fazem e outros que precisam diferir. É um uso válido de ramificações se eu tiver ramificações release-editionA e release-editionB (..etc)? Existem truques? Boas práticas?

Atualização: Obrigado pela compreensão de todos, muitas boas respostas aqui. O consenso geral parece ser que é uma má idéia usar ramificações para esse fim. Para quem se pergunta, minha solução final para o problema é externalizar seqüências de caracteres como configuração e externalizar a lógica diferente como plugins ou scripts.

Isso depende da magnitude da mudança, mas eu não consideraria uma boa prática para as diferenças que você descreveu.

Geralmente, você deseja que uma ramificação Git seja algo que será mesclado no futuro ou armazenado como somente leitura para referência. Os ramos Git que coexistem indefinidamente significam trabalho para todos: as mudanças precisam ser propagadas e mescladas, os conflitos resolvidos, toda a diversão. Se nada mais, todo desenvolvedor deve se lembrar de enviar alterações para cinco repositórios em vez de um.

Se houver pequenas alterações, todo o esforço de fusão e manutenção de ramificações parecerá um exagero quando comparado ao problema. Use seu pré-processador ou sistema de construção para diferenciar entre versões. Um simples #ifdeffaz o truque? Então não resolva problemas com o git, é um exagero.

Não é para isso que servem os galhos. As ramificações devem ser caminhos secundários de curto a médio prazo para sua linha de desenvolvimento, e não versões paralelas de longo prazo do mesmo código.

Eu colocaria todas as versões diferentes na mesma ramificação, com subdiretórios para as partes que são diferentes entre as edições e configurava seu processo de criação (você tem uma construção automatizada, certo?) Para que ele possa produzir qualquer edição sob demanda (ou todos eles de uma vez).

Afinal, você quer manter uma "única fonte de verdade"; com ramificações, você duplicará algum código, mas não todos, e certas mesclas de fato interromperiam sua configuração.

Uma solução - como as pessoas apontaram - é configurar o sistema de compilação para suportar diferentes edições.

Eu também consideraria implementá-lo como recurso alterna e usar um arquivo de configuração. Quanto menos você precisar construir, melhor.

Dê uma olhada neste site.

Eu acho que é uma boa ideia, desde que você não possa fazê-lo em uma ramificação sem agrupar muito o código.
Eu preferiria poder mantê-lo em uma ramificação e usar arquivos localizados e de configuração, especialmente se você disser que as diferenças são pequenas.
Outra maneira poderia ser compilações diferentes, por exemplo, seu arquivo de compilação empacota arquivos diferentes para clientes diferentes, mas também vejo a ferramenta de compilação verificando diferentes ramificações. Como você usa git, eu diria que não há truques reais. Uma estratégia de ramificação poderia ser desenvolver em diferentes ramificações para diferentes tarefas, fazer check-in na ramificação principal e mesclar do mestre para a edição X e Y.

Isso parece mais um trabalho para diferentes configurações de compilação. A resposta de thiton vai nessa direção, mas eu levaria muito mais longe do que #ifdef:

Use destinos de construção diferentes para criar edições diferentes do software. As metas podem diferir por

• a configuração que eles incluem,
• o objeto ou os arquivos de origem que eles incluem, ou
• o pré-processamento do código fonte.

Esse pré-processamento pode obviamente incluir o pré-processador C clássico, mas também pode envolver o uso de um pré-processador personalizado, um mecanismo de modelo para criar visualizações personalizadas,…

Dessa forma, você evita ter que enviar ativamente todas as alterações para várias ramificações, o que viola o DRY (é claro que isso também pode ser automatizado, mas não vejo a vantagem).

Eu usaria ramificações apenas para alterações significativas, caso contrário, você acaba adicionando todas as pequenas alterações a numerosas ramificações, o que não é nada divertido e é muito propenso a erros, especialmente se você estiver trabalhando com mais pessoas.

Se você estiver lançando todos eles como produtos diferentes, é recomendável ter várias filiais. Caso contrário, ainda é recomendável usar algo como um tronco ou uma ramificação principal.

Além disso, acho que isso dependeria do processo de desenvolvimento que você possui, principalmente da implantação. Se você tiver um processo que permita apenas uma ramificação ser lançada para produção e as ramificações estiverem sendo tratadas como "construções incrementais", o que significa que a liberação B não poderá ser lançada para produção, a menos que a liberação A tenha sido lançada primeiro, uma vez que todas as alterações de A já está em B, então ter vários ramos é o caminho a percorrer. Isso funcionará se você tiver equipes espalhadas por todo o mundo e normalmente tiver alterações ordenadas por prioridade.

A solução com os três ramos diferentes (para produção, desenvolvimento e recursos) funciona muito bem. Digamos que você descubra algum bug no seu código de produção e, em seguida, aplique um patch nele e depois o libere. Apenas certifique-se de não fazer acréscimos de recursos ao ramo de produção ou quaisquer alterações importantes no ramo de produção. Você e sua equipe terão que se autodisciplinar para não adicionar nenhuma alteração importante nos recursos ao seu ramo de produção. O ramo de produção deve ser apenas para pequenas correções de erros que não garantem uma grande alteração na sua base de códigos de produção.