¿Cómo hacer los números de versión?

Mi empresa está construyendo un producto. Será versionado por SVN. Es una aplicación web, así que básicamente nunca habrá una versión que no tenga algunas características y, por lo tanto, siempre podría etiquetarse como beta. Pero dado que va a ser un producto corporativo, realmente no quiero que haya una "vigilancia inestable". Entonces, ¿cómo harías para versionar? ¿1.0 es estable? ¿La fecha de compilación debe estar en el número de versión? ¡Dime qué piensan ustedes!

[ mayor ]. [ menor ]. [ lanzamiento ]. [ compilación ]

importante : Realmente una decisión de marketing. ¿Estás listo para llamar a la versión 1.0? ¿La compañía considera que esta es una versión principal por la cual los clientes podrían tener que pagar más, o es una actualización de la versión principal actual que puede ser gratuita? Menos de una decisión de I + D y más una decisión de producto.

menor : Comienza desde 0 cada vez mayor se incrementa. +1 por cada versión que se haga pública.

lanzamiento : cada vez que alcanza un hito de desarrollo y lanza el producto, incluso internamente (p. ej., QA), incremente esto. Esto es especialmente importante para la comunicación entre los equipos de la organización. No hace falta decir que nunca lance la misma 'liberación' dos veces (incluso internamente). Restablecer a 0 en menor ++ o mayor ++.

build : puede ser una revisión SVN, creo que funciona mejor.

Ejemplos
Mi cromo actual: 83.0.4103.61

xyzg

los incrementos en g son inestables. (o RC) los incrementos en z son estables y significan correcciones de errores.
los incrementos en y son estables y significan nuevas características.
los incrementos en x son estables, versión principal sin 100% de compatibilidad con versiones anteriores.

Una vez escribí una elaborada "guía de estilo de versiones" para un gran proyecto mío. El proyecto no se materializó, pero la guía de estilo todavía está disponible en línea . Es mi opinión personal, quizás sea útil (o inspirador) para usted.

Cuidado, es un texto largo, y se dirige a las versiones de componentes versus versiones de productos y cosas así. También expresa fuertes opiniones sobre algunos esquemas de versiones populares en la comunidad OSS, pero los tengo, así que los expreso. ;-)

No estoy de acuerdo con el uso del número de revisión de Subversion, por ejemplo. Es posible que desee mantener una versión lanzada mientras continúa el desarrollo en TRUNK, por lo que configurará una rama de mantenimiento, y su versión del número de revisión se va por el desagüe.

Editar: Como resumen, distingue entre versiones de archivos fuente, componentes y el producto en general. Utiliza un sistema de versión xy separada para los componentes y el producto, con una buena interdependencia entre los dos que hace que el rastreo de qué versión de componente pertenece a qué versión de producto sea trivial. También habla sobre cómo manejar los ciclos alfa / beta / lanzamiento / parche sin romper el sistema. En realidad, es un modus operandi para todo el ciclo de desarrollo, por lo que es posible que desee elegir. ;-)

Edición 2: como suficientes personas encontraron mi artículo útil para hacer de esto una "Buena respuesta", comencé a trabajar en el artículo nuevamente. Las versiones PDF y LaTeX ya están disponibles, una reescritura completa que incluye un mejor lenguaje y gráficos explicativos seguirá tan pronto como pueda encontrar el tiempo. ¡Gracias por tus votos!

Inspírate en Wikipedia: "Versiones de software"

Otra opción "nueva" y "relativamente popular" es el control de versiones semántico

Resumen:

Dado un número de versión MAJOR.MINOR.PATCH, incremente el:

1. Versión PRINCIPAL cuando realiza cambios de API incompatibles,
2. Versión MENOR cuando agrega funcionalidad de una manera compatible con versiones anteriores, y
3. Versión PATCH cuando realiza correcciones de errores compatibles con versiones anteriores.

Las etiquetas adicionales para los metadatos previos al lanzamiento y de compilación están disponibles como extensiones del formato MAJOR.MINOR.PATCH.

a B C D

Incrementos: cuando
- d : correcciones de errores
- c : mantenimiento, por ejemplo, mejora del rendimiento
- b : nuevas características
- a : cambio de arquitectura

El obligatorio es el que queda más a la izquierda, por ejemplo, si hay, por ejemplo, una nueva característica y un error corregido, entonces solo tiene que incrementar b .

En base a mi experiencia con la gestión de dependencias de nivel de plataforma empresarial compleja y el control de versiones de versiones, he venido a recomendar un enfoque que me gusta llamar Control de versiones semántico .

Básicamente se basa en Semantic Versioning 2.0 pero no es tan estricto.

Segmentos de versión semántica:

<primary.release.segment>[-<pre.release.segment>][+<post.release.segment>]

Formato del segmento de lanzamiento primario:

MARKETTING.MAJOR.MINOR.PATCH

Cada segmento debe permitir alfanuméricos, pero se recomiendan números puros para los cambios incrementales lógicos.

Al igual que SemVer, recomiendo los componentes Major, Minor y Patch para representar niveles de compatibilidad inversa, pero también recomiendo anteponer un componente de Marketing . Esto permite a los propietarios de productos, las epopeyas / grupos de características y las inquietudes comerciales a superar el componente primario independientemente de las inquietudes de compatibilidad técnica.

A diferencia de otras respuestas, no recomendé agregar un número de compilación al segmento primario. En su lugar, agregue un segmento posterior al lanzamiento después de un '+' (por ejemplo: 1.1.0.0 + build.42). SemVer llama a esto metadatos de compilación, pero creo que el segmento posterior al lanzamiento es más claro. Este segmento es excelente para declarar los datos del sufijo como no relacionados con la información de compatibilidad en el segmento de lanzamiento primario. Sus compilaciones de integración continua pueden recibir el número de versión anterior junto con un número de compilación incremental que se restablece después de cada versión principal (por ejemplo: 1.1.0.0 -> 1.1.0.0 + build.1 -> 1.1.0.0 + build.2 -> 1.1.0.1). A algunas personas les gusta poner el número de revisión svn aquí o el git commit sha para facilitar el enlace al repositorio de código. Otra opción es usar el segmento posterior al lanzamiento para revisiones y parches, aunque puede valer la pena considerar agregar un nuevo componente de lanzamiento primario para eso. Siempre se puede descartar cuando se incrementa el componente del parche, ya que las versiones están efectivamente alineadas a la izquierda y ordenadas.

Además de los segmentos de lanzamiento y post-lanzamiento, las personas a menudo quieren usar un segmento de pre-lanzamiento para indicar pre-lanzamientos casi estables como alphas, betas y candidatos de lanzamiento. El enfoque de SemVer para esto funciona bien, pero recomiendo separar los componentes numéricos de los clasificadores alfanuméricos (por ejemplo: 1.2.0.0 + alpha.2 o 1.2.0.0 + RC.2). Normalmente, se toparía con el segmento de lanzamiento al mismo tiempo que se agrega el segmento posterior al lanzamiento y luego se soltaría el segmento de prelanzamiento la próxima vez que se tope con el segmento de lanzamiento primario (ej: 1.0.1.2 -> 1.2.0.0-RC.1 - > 1.2.0.0). Los segmentos de prelanzamiento se agregan para indicar que la versión de lanzamiento está llegando, generalmente solo un conjunto fijo de características para pruebas y compartimientos más profundos que no cambian minuto a minuto en función de más confirmaciones.

La belleza de tener todo esto definido semánticamente de una manera que cubre casi todos los casos de uso es que puede analizarlos, clasificarlos, compararlos e incrementarlos de manera estándar. Esto es especialmente importante cuando se utilizan sistemas CI para aplicaciones complejas con muchos componentes pequeños con versiones independientes (como microservicios), cada uno con sus propias dependencias administradas.

Si te interesa, escribí un analizador semántico semántico en rubí . No solo necesitaba usar este patrón, sino también poder administrar otras aplicaciones que lo usaban.

Los "números de versión" son un asunto para su sistema interno de control de versiones. Los números de versión son un asunto diferente (y deberían ser KEPT diferentes).

Apéguese a un sistema de lanzamiento simple MAJOR.MINOR (como v1.27), donde MAJOR es el nivel de compatibilidad (la versión 2.x es incompatible o al menos muy diferente de la versión 1.x) y MINOR son sus versiones de corrección de errores o mejoras menores . Siempre que siga el formato XY, también puede usar otros sistemas como YEAR.MONTH (2009.12) o YEAR.RELEASE (2009.3). Pero realmente es mejor que te quedes con MAJOR.MINOR a menos que tengas una buena razón para no hacerlo.

Definitivamente no use nada que no se ajuste al formato XY, ya que dificultará que las distribuciones, los sitios web de anuncios, etc. trabajen con usted, y eso solo podría afectar seriamente la popularidad de su proyecto.

Utilice ramas y etiquetas en su sistema de control de versiones (preferiblemente distribuido) para marcar números de versión internos específicos en relación con MAYORES y MENORES, respectivamente.

Y sí, 1.0 debería ser estable. Todas las versiones deben ser estables, a menos que estén marcadas como alfa, beta o RC. Use Alfa para lo conocido: roto e incompleto. Betas para conocido-roto. RC para "pruébalo; probablemente verás cosas que nos perdimos". Cualquier cosa sin uno de estos debe (idealmente, por supuesto) ser probado, conocido, tener un manual actualizado, etc.

Es bastante popular en estos días usar el número de revisión de Subversion.

Si está en SVN, ¿por qué no usar el número de revisión de SVN?

Si observa la parte inferior derecha de esta página web, verá el número de versión de Stack Overflow, que es el número de revisión SVN.

El control de versiones depende de usted; Puse 1.0 en la primera versión en la que confiaba. Es posible que desee seguirlo rápidamente con otras versiones, ya que algunos proveedores de software le han dado a 1.0 una mala reputación.

Desea alguna forma de vincular el número de versión con la compilación exacta utilizada, pero probablemente desee que sea agradable y simple para sus usuarios finales. Considere usar números de versión estándar y etiquetar el repositorio SVN con el número de versión incluido.

Si bien ir con el número de revisión de Subversion es agradable y simple, elimina la información del número de versión. Los usuarios pueden considerar esto como algo malo.

Supongo que su aplicación web tendrá algún tipo de procedimiento de implementación, por lo que no cada publicación en Subversion se publica realmente. Dado que es imposible desde el "exterior" (desde la perspectiva del usuario) determinar cuándo se realizarán los lanzamientos y cuántas revisiones sufrirá el código entre ellos, los números son casi aleatorios. Estarán aumentando, y supongo que es posible suponer algún tipo de distancia de la comparación de dos revisiones, pero no mucho.

Los números de versiones clásicas tienden a "dramatizar" los lanzamientos, por lo que los usuarios pueden construir algún tipo de expectativa. Es más fácil pensar "Tengo la versión 1.0, ahora la versión 1.1 está agregando esto y aquello, eso suena interesante" que pensar "ayer ejecutamos SO revisión 2587, hoy es 3233, ¡debe ser mucho mejor!".

Por supuesto, esta dramatización también se puede inflar, ya que las compañías eligen números de versión que sonarán más interesantes de lo que están motivados por las diferencias reales en el producto, supongo que ir un poco con los números de revisión.

Esquema de versión: [mayor]. [Menor]. [Devrel] [marca]
[mayor]: incremente si tiene un cambio drástico en el desarrollo.
[menor]: incremente si tiene un cambio menor en el desarrollo.
[devrel]: incremente si tiene una corrección de error. Restablezca a cero si es mayor ++ o menor ++.
[marca]: a, bo rc: a es una versión alfa, b es versión beta y rc es un candidato de versión. Tenga en cuenta que las versiones como 1.3.57a o 1.3.57b o 1.3.57rc son anteriores a la versión 1.3.57. Comience en 0.0.0.

Hemos pasado demasiado tiempo decidiendo cuándo incrementar la versión principal. Algunas tiendas rara vez lo harían, por lo que tendrías lanzamientos como 1.25.3 y otros lo harían para siempre lanzándote dando 15.0

Me cansé de eso y convencí a todos de que el número de lanzamiento principal es solo el año y el menor es solo un lanzamiento secuencial dentro del año. A los usuarios parecía gustarles y es obvio encontrar el siguiente número de versión.

Año.Release.build

• año = año actual
• lanzamiento = secuencia # de lanzamientos públicos con nueva funcionalidad - restablecer a 1 cada año
• build = incrementado para correcciones de errores y versiones internas

EDITAR

** Ahora esto era para una aplicación interna que se mejoraba continuamente **

Esto probablemente no funcionaría para aplicaciones comerciales donde es importante tener lanzamientos importantes en diferentes épocas del año con fines comerciales y financieros.

La razón por la que existe esta pregunta es porque no tenemos una única forma acordada de hacer la gestión de la configuración.

La forma en que me gusta hacer el número de versión es simplemente incrementar el número entero desde 1. No quiero un número de versión de varias partes que deba explicar o documentar. Y no quiero usar el número de rev. SVN, ya que eso requerirá algunas explicaciones también.

Necesitaría algunos scripts de lanzamiento sobre SVN para que esto suceda

Tengo muy poca experiencia en el área. Sin embargo, esto es lo que haría:

1. Elija un esquema para numerar revisiones y manténgalo. Se consistente.
2. Cada cambio de versión debe representar un cambio significativo . Qué tan pequeño es un cambio significativo y los niveles de cambio que se reflejan en el número de versión dependen de usted.

Por supuesto, puede usar el número de revisión svn --- ¡como muchos otros han sugerido!

Espero que esto ayude.

Utilizamos una sintaxis simple major.minor.julian_date.

Dónde;

• major: la primera versión es 1 y luego, cuando presentamos nuevas características o cambios importantes, tan significativos que no son compatibles con versiones anteriores, aumentan este número.
• minor: los principales hitos de lanzamiento. Para cada compilación impulsada por la producción, este número aumenta.
• julian_date: el día juliano en el que la compilación se introdujo en QA

Ejemplo de la primera versión enviada a QA en 1/15 es -> 1.0.015
Ejemplo de la primera versión enviada a Producción en 3/4 es -> 1.1.063

No es perfecto, pero es útil a medida que avanzamos las construcciones para el control de calidad casi a diario.

Alguna buena información aquí:

Cuándo cambiar las versiones de archivo / ensamblaje

En primer lugar, las versiones de archivo y las versiones de ensamblaje no necesitan coincidir entre sí. Recomiendo que las versiones de archivo cambien con cada compilación. Pero, no cambie las versiones de ensamblaje con cada compilación solo para que pueda notar la diferencia entre dos versiones del mismo archivo; usa la versión del archivo para eso. Decidir cuándo cambiar las versiones de ensamblaje requiere una discusión sobre los tipos de compilaciones a considerar: envío y no envío.

Construcciones que no son de envío En general, recomiendo mantener las versiones de ensamblaje que no sean de envío iguales entre las construcciones de envío. Esto evita problemas de carga de ensamblados con nombres muy fuertes debido a desajustes de versión. Algunas personas prefieren usar la política del editor para redirigir nuevas versiones de ensamblaje para cada compilación. Sin embargo, lo recomiendo para las compilaciones que no son de envío: no evita todos los problemas de carga. Por ejemplo, si un socio copia x su aplicación, es posible que no sepa instalar la política del editor. Entonces, su aplicación se romperá para ellos, a pesar de que funciona bien en su máquina.

Pero, si hay casos en que diferentes aplicaciones en la misma máquina necesitan vincularse a diferentes versiones de su ensamblaje, recomiendo darles a esas compilaciones diferentes versiones de ensamblaje para que se pueda usar la correcta para cada aplicación sin tener que usar LoadFrom / etc.

Envío de compilaciones En cuanto a si es una buena idea cambiar esa versión para enviar compilaciones, depende de cómo desee que funcione el enlace para los usuarios finales. ¿Desea que estas compilaciones estén juntas o en su lugar? ¿Hay muchos cambios entre las dos compilaciones? ¿Van a romper algunos clientes? ¿Te importa que los rompa (o quieres obligar a los usuarios a usar tus actualizaciones importantes)? En caso afirmativo, debería considerar incrementar la versión del ensamblaje. Pero, de nuevo, considere que hacer eso muchas veces puede ensuciar el disco del usuario con ensamblajes obsoletos.

Cuando cambie las versiones de ensamblaje Para cambiar las versiones codificadas a la nueva, le recomiendo configurar una variable para la versión en un archivo de encabezado y reemplazar la codificación en fuentes con la variable. Luego, ejecute un preprocesador durante la compilación para colocar la versión correcta. Recomiendo cambiar las versiones justo después del envío, no justo antes, para que haya más tiempo para detectar errores debido al cambio.

O para usar su número de versión de "pensamiento" número de subversión de coma. ZB:

1.0.101 // revisión 101, lanzamiento

o 1.0.101-090303 // con fecha de lanzamiento, uso esto