¿Es una buena práctica usar sucursales para mantener diferentes ediciones del mismo software?

Tenemos un producto que tiene algunas ediciones diferentes. Las diferencias son menores: diferentes cadenas aquí y allá, muy poca lógica adicional en una, muy poca diferencia en lógica en la otra. Cuando se desarrolla el software, la mayoría de los cambios deben agregarse a cada edición; Sin embargo, hay algunos que no lo hacen y algunos que necesitan diferir. ¿Es un uso válido de sucursales si tengo sucursales release-editionA y release-editionB (..etc)? ¿Hay alguna trampa? ¿Buenas practicas?

Actualización: Gracias por la comprensión de todos, muchas buenas respuestas aquí. El consenso general parece ser que es una mala idea usar sucursales para este propósito. Para cualquiera que se pregunte, mi solución final al problema es externalizar las cadenas como configuración y externalizar la lógica diferente como complementos o scripts.

Esto depende de la magnitud del cambio, pero no lo consideraría una buena práctica por las diferencias que describió.

En general, desea que una rama de Git sea algo que se fusionará en el futuro o se almacenará como solo lectura para referencia. Las ramas de Git que coexisten indefinidamente significan trabajo para todos: los cambios deben propagarse y fusionarse, resolverse conflictos, toda la diversión. Por lo menos, cada desarrollador debe recordar empujar los cambios a cinco repositorios en lugar de uno.

Si tiene pequeños cambios, todo el esfuerzo de fusión y mantenimiento de sucursales parece excesivo en comparación con el problema. Use su preprocesador o sistema de compilación para diferenciar entre versiones. ¿Un simple #ifdefhace el truco? Entonces no resuelvas problemas con git, es exagerado.

Para eso no son realmente las ramas. Se supone que las ramas son rutas laterales de corto a medio plazo hacia su línea de desarrollo, no versiones paralelas a largo plazo del mismo código.

Pondría todas las diferentes versiones en la misma rama, con subdirectorios para las partes que son diferentes entre las ediciones, y configuraría su proceso de compilación (tiene una compilación automatizada, ¿verdad?) Para que pueda publicar cualquiera de las ediciones bajo demanda (o todos a la vez).

Después de todo, desea mantener una "fuente única de verdad"; con ramas, duplicará algunos códigos, pero no todos, y ciertas fusiones de hecho romperían su configuración.

Una solución, como han señalado las personas, es configurar el sistema de compilación para admitir diferentes ediciones.

También consideraría implementarlo como alternar características y usar un archivo de configuración. Cuanto menos tenga que construir, mejor.

Echa un vistazo a esta página.

Creo que es una buena idea siempre que no pueda hacerlo dentro de una rama sin agrupar demasiado el código.
Preferiría poder mantenerlo en una rama y usar archivos localizados y de configuración, especialmente si dice que las diferencias son menores.
Otra forma podría ser diferentes compilaciones, por ejemplo, su archivo de compilación empaqueta diferentes archivos para diferentes clientes, pero también puedo ver la herramienta de compilación revisando diferentes ramas. Como usas git, diría que no hay trucos reales. Una estrategia de ramificación podría ser desarrollar en diferentes ramas para diferentes tareas, registrarse en la rama maestra y fusionar de maestra a ediciónX e Y.

Esto suena más como un trabajo para diferentes configuraciones de compilación. La respuesta de thiton va en esta dirección, pero lo llevaría mucho más lejos que #ifdef:

Utilice diferentes objetivos de compilación para compilar diferentes ediciones del software. Los objetivos pueden diferir según

• la configuración que incluyen,
• el objeto o los archivos fuente que incluyen, o
• El preprocesamiento del código fuente.

Obviamente, este preprocesamiento puede incluir el preprocesador C clásico, pero también podría implicar el uso de un preprocesador personalizado, un motor de plantillas para crear vistas personalizadas, ...

De esta manera, evita tener que empujar activamente cada cambio a varias ramas, lo que viola DRY (por supuesto, eso también puede automatizarse, pero no veo la ventaja).

Usaría ramas solo para cambios significativos, de lo contrario, terminará agregando cada pequeño cambio a numerosas ramas, lo que no es divertido y es muy propenso a errores, especialmente si está trabajando con más personas.

Si los está lanzando todos como productos diferentes, se recomienda tener múltiples sucursales. De lo contrario, aún se recomienda usar algo como un tronco o una rama maestra.

Además, creo que esto dependerá del proceso de desarrollo que tenga, particularmente la implementación. Si tiene un proceso que solo permite que una rama se extienda a producción y las ramas se traten como "compilaciones incrementales", lo que significa que la versión B no se puede extender a producción a menos que la versión A se haya implementado primero, dado que todos los cambios de A ya están en B, entonces tener múltiples ramas es el camino a seguir. Esto funcionará si tiene equipos dispersos por todo el mundo y generalmente tiene cambios ordenados por prioridad.

La solución con las tres ramas diferentes (para producción, desarrollo y características) funciona muy bien. Digamos que descubres algún error en tu código de producción, luego puedes aplicar un parche para luego liberarlo. Solo asegúrese de no hacer ninguna adición de características a la rama de producción o cualquier cambio importante en la rama de producción. Usted y su equipo tendrán que autodisciplinar para no agregar cambios importantes en las características de su rama de producción. La rama de producción debe ser solo para correcciones de errores menores que no garantizan un cambio importante en su base de código de producción.