Comment faire les numéros de version?

Mon entreprise construit un produit. Il va être versionné par SVN. C'est une application Web, donc en gros, il n'y aura jamais de version qui ne contient pas de fonctionnalités et qui pourrait donc toujours être étiquetée comme bêta. Mais puisque ce sera un produit d'entreprise, je ne veux vraiment pas la "surveillance instable" là-bas. Alors, comment feriez-vous le contrôle des versions? La 1.0 est-elle stable? La date de construction doit-elle être dans le numéro de version? Dites-moi ce que vous en pensez!

[ majeur ]. [ mineur ]. [ release ]. [ build ]

major : Vraiment une décision marketing. Êtes-vous prêt à appeler la version 1.0? L'entreprise considère-t-elle qu'il s'agit d'une version majeure pour laquelle les clients pourraient devoir payer plus, ou s'agit-il d'une mise à jour de la version majeure actuelle qui peut être gratuite? Moins une décision de R&D et plus une décision de produit.

minor : commence à 0 chaque fois que majeur est incrémenté. +1 pour chaque version rendue publique.

release : chaque fois que vous atteignez un jalon de développement et que vous publiez le produit, même en interne (par exemple pour le contrôle qualité), incrémentez-le. Ceci est particulièrement important pour la communication entre les équipes de l'organisation. Inutile de dire que ne publiez jamais deux fois la même «version» (même en interne). Remettez à 0 sur mineur ++ ou majeur ++.

build : Peut être une révision SVN, je trouve que cela fonctionne le mieux.

Exemples
Mon chrome actuel: 83.0.4103.61

xyzg

les incréments de g sont instables. (ou RC) les incréments de z sont stables et signifient des corrections de bogues.
les incréments de y sont stables et signifient de nouvelles fonctionnalités.
les incréments de x sont stables, version majeure sans compatibilité descendante à 100%.

J'ai écrit une fois un "guide de style de versioning" élaboré pour un de mes grands projets. Le projet ne s'est pas concrétisé, mais le guide de style est toujours disponible en ligne . C'est mon opinion personnelle, peut-être que cela vous est utile (ou inspirant).

Méfiez-vous, c'est un long texte, et va dans la gestion des versions des composants par rapport à la gestion des versions des produits et des trucs comme ça. Il exprime également des opinions bien arrêtées sur certains schémas de versions populaires dans la communauté OSS, mais je les ai, alors je les exprime. ;-)

Je ne suis pas d'accord avec l'utilisation du numéro de révision Subversion, par exemple. Vous voudrez peut-être maintenir une version publiée tout en poursuivant le développement dans TRUNK, vous allez donc créer une branche de maintenance - et le contrôle des versions de votre numéro de révision sera perdu.

Modifier: en résumé, il fait la distinction entre les fichiers source de contrôle de version, les composants et le produit global. Il utilise un système de versoning xy séparé pour les composants et le produit, avec une belle interdépendance entre les deux qui rend le traçage de quelle version de composant appartient à quelle version de produit trivial. Il explique également comment gérer les cycles alpha / bêta / version / patch sans casser le système. En fait, c'est un modus operandi pour tout le cycle de développement, donc vous voudrez peut-être faire un tri sélectif. ;-)

Edit 2: Comme suffisamment de personnes ont trouvé mon article utile pour en faire une "bonne réponse", j'ai recommencé à travailler sur l'article. Les versions PDF et LaTeX sont maintenant disponibles, une réécriture complète comprenant un meilleur langage et des graphiques explicatifs suivra dès que je pourrai trouver le temps. Merci pour vos votes!

Inspirez-vous de Wikipédia: "Versionnage des logiciels"

Une autre option "nouvelle" et "relativement populaire" est la gestion des versions sémantiques.

Résumé:

Étant donné un numéro de version MAJOR.MINOR.PATCH, incrémentez:

1. Version MAJEURE lorsque vous apportez des modifications d'API incompatibles,
2. Version MINEURE lorsque vous ajoutez des fonctionnalités de manière rétrocompatible, et
3. Version PATCH lorsque vous effectuez des corrections de bogues rétrocompatibles.

Des étiquettes supplémentaires pour les métadonnées de pré-version et de build sont disponibles sous forme d'extensions au format MAJOR.MINOR.PATCH.

a B c d

Incréments: quand
- d : corrections de bogues
- c : maintenance, par exemple amélioration des performances
- b : nouvelles fonctionnalités
- a : changement d'architecture

L'obligation est la plus à gauche, par exemple s'il y a par exemple une nouvelle fonctionnalité et un bug corrigé, il suffit d'incrémenter b .

Sur la base de mon expérience de la gestion des dépendances au niveau de la plate-forme d'entreprise complexe et du contrôle de version des versions, je suis venu pour recommander une approche que j'aime appeler le contrôle de version semi-sémantique .

Fondamentalement, il repose sur Semantic Versioning 2.0 mais n'est pas aussi strict.

Segments de version semi-sémantique:

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

Format du segment de lancement principal:

MARKETTING.MAJOR.MINOR.PATCH

Chaque segment doit autoriser les caractères alphanumériques, mais des valeurs numériques pures sont recommandées pour les changements incrémentiels logiques.

Comme SemVer, je recommande les composants Major, Minor et Patch pour représenter les niveaux de compatibilité inverse, mais je recommande également d'ajouter un composant Marketing . Cela permet aux propriétaires de produits, aux épopées / groupes de fonctionnalités et aux préoccupations commerciales de remplacer le composant principal indépendamment des problèmes de compatibilité technique.

Contrairement à d'autres réponses, je ne recommande pas d'ajouter un numéro de build au segment principal. Au lieu de cela, ajoutez un segment post-version après un «+» (ex: 1.1.0.0 + build.42). SemVer appelle ces métadonnées de construction, mais je pense que le segment post-publication est plus clair. Ce segment est idéal pour déclarer les données de suffixe comme non liées aux informations de compatibilité dans le segment de version principal. Vos builds d'intégration continue peuvent alors recevoir le numéro de version précédente ajouté avec un numéro de build incrémentiel qui se réinitialise après chaque version principale (ex: 1.1.0.0 -> 1.1.0.0 + build.1 -> 1.1.0.0 + build.2 -> 1.1.0.1). Certaines personnes aiment mettre le numéro de révision svn ici ou le git commit sha pour faciliter le lien avec le référentiel de code. Une autre option consiste à utiliser le segment post-version pour les correctifs et les correctifs, bien qu'il puisse être intéressant d'envisager d'ajouter un nouveau composant de version principale pour cela. Il peut toujours être supprimé lorsque le composant de correctif est incrémenté, car les versions sont effectivement alignées à gauche et triées.

En plus des segments de publication et de post-publication, les gens souhaitent souvent utiliser un segment de pré-publication pour indiquer des pré-versions presque stables telles que les alphas, les bêtas et les versions candidates. L'approche SemVer fonctionne bien, mais je recommande de séparer les composants numériques des classificateurs alphanumériques (ex: 1.2.0.0 + alpha.2 ou 1.2.0.0 + RC.2). Normalement, vous augmentez le segment de version en même temps que l'ajout du segment de post-version, puis supprimez le segment de pré-version lorsque vous le prochain segment de version principale (ex: 1.0.1.2 -> 1.2.0.0-RC.1 - > 1.2.0.0). Des segments de pré-version sont ajoutés pour indiquer que la version de sortie est à venir, généralement juste un ensemble fixe de fonctionnalités pour des tests et un partage plus approfondis qui ne changent pas de minute en minute en fonction de plus de commits.

La beauté d'avoir tout cela défini sémantiquement d'une manière qui couvre presque tous les cas d'utilisation est que vous pouvez les analyser, les trier, les comparer et les incrémenter de manière standard. Ceci est particulièrement important lorsque vous utilisez des systèmes CI pour des applications complexes avec de nombreux petits composants versionnés indépendamment (comme des micro-services), chacun avec ses propres dépendances gérées.

Si vous êtes intéressé, j'ai écrit un analyseur semi-sémantique en ruby . J'avais besoin non seulement d'utiliser ce modèle, mais aussi de pouvoir gérer d'autres applications qui l'utilisaient.

Les «numéros de version» relèvent de votre système de contrôle de version interne. Les numéros de version sont une question différente (et devraient être KEPT différents).

Tenez-vous en à un système de version MAJOR.MINOR simple (comme la v1.27), où MAJOR est le niveau de compatibilité (la version 2.x est incompatible avec ou au moins largement différente de la version 1.x) et MINOR correspond à vos versions de correction de bogues ou améliorations mineures . Tant que vous suivez le format XY, vous pouvez également utiliser d'autres systèmes comme YEAR.MONTH (2009.12) ou YEAR.RELEASE (2009.3). Mais vraiment, vous feriez mieux de vous en tenir à MAJOR.MINOR à moins que vous n'ayez une bonne raison de ne pas le faire.

N'utilisez absolument rien qui ne correspond pas au format XY, car cela rendra difficile le travail des distributions, des sites Web d'annonces, etc. avec vous, et cela seul pourrait sérieusement affecter la popularité de votre projet.

Utilisez des branches et des balises dans votre système de contrôle de version (de préférence distribué) pour marquer les numéros de version internes spécifiques comme étant respectivement MAJORS et MINEURS.

Et oui, 1.0 devrait être stable. Toutes les versions doivent être stables, sauf si elles sont marquées alpha, bêta ou RC. Utilisez Alphas pour connu-cassé et incomplet. Betas pour connu-cassé. RC pour "essayez-le; vous verrez probablement des choses que nous avons manquées". Tout ce qui ne contient pas l'un de ces éléments doit (idéalement, bien sûr) être testé, reconnu comme bon, avoir un manuel à jour, etc.

Il est assez populaire ces jours-ci d'utiliser simplement le numéro de révision Subversion.

Si c'est dans SVN, pourquoi ne pas utiliser le numéro de révision SVN?

Si vous regardez en bas à droite de cette page Web, vous verrez le numéro de version de Stack Overflow qui est le numéro de révision SVN.

La gestion des versions dépend de vous; J'avais mis 1.0 sur la première version en laquelle j'avais confiance. Vous voudrez peut-être faire un suivi rapide avec d'autres versions, car certains éditeurs de logiciels ont donné à 1.0 une mauvaise réputation.

Vous voulez un moyen de lier le numéro de version à la version exacte utilisée, mais vous voulez probablement que ce soit simple et agréable pour vos utilisateurs finaux. Envisagez d'utiliser des numéros de version standard et de baliser le référentiel SVN avec le numéro de version inclus.

Bien qu'utiliser le numéro de révision de Subversion soit simple et agréable, cela supprime les informations du numéro de version. Les utilisateurs pourraient considérer cela comme une mauvaise chose.

Je suppose que votre application Web aura une sorte de procédure de déploiement, de sorte que chaque révision de Subversion ne soit pas réellement publiée. Puisqu'il est impossible de "l'extérieur" (du point de vue de l'utilisateur) de déterminer quand les versions sont en cours et combien de révisions le code va subir entre elles, cela rend les nombres presque aléatoires. Ils augmenteront, et je suppose qu'il est possible de supposer une certaine distance par rapport à la comparaison de deux révisions, mais pas beaucoup.

Les numéros de version classiques ont tendance à «dramatiser» les versions, de sorte que les utilisateurs peuvent créer une sorte d'attentes. Il est plus facile de penser "J'ai la version 1.0, maintenant la version 1.1 est en train d'ajouter ceci et cela, cela semble intéressant" que de penser "hier nous avons exécuté la révision SO 2587, aujourd'hui c'est 3233, ça doit être beaucoup mieux!".

Bien sûr, cette dramatisation peut également être gonflée, les entreprises choisissant des numéros de version censés sembler plus intéressants que ce qui est motivé par les différences réelles dans le produit, je suppose que le numéro de révision compense un peu cela.

Schéma de version: [majeur]. [Mineur]. [Devrel] [marque]
[majeur]: incrémentation si vous avez un changement radical dans le développement.
[mineur]: incrément si vous avez un changement mineur dans le développement.
[devrel]: incrémenter si vous avez une correction de bogue. Remise à zéro si majeur ++ ou mineur ++.
[marque]: a, b ou rc: a est une version alpha, b est une version bêta et rc est une version candidate. Notez que les versions comme 1.3.57a ou 1.3.57b ou 1.3.57rc sont antérieures à la version 1.3.57. Commencez à 0.0.0.

Nous avons passé beaucoup trop de temps à décider quand incrémenter la version majeure. Certains magasins le feraient rarement, donc vous auriez des versions comme la 1.25.3 et d'autres le feraient pour toujours une version vous donnant 15.0

J'en ai eu marre de cela et j'ai convaincu tout le monde que le numéro de sortie majeur n'est que l'année et que le mineur n'est qu'une sortie séquentielle dans l'année. Les utilisateurs ont semblé l'apprécier et c'est une évidence pour trouver le prochain numéro de version.

Year.Release.build

• année = année en cours
• release = numéro de séquence de versions publiques avec de nouvelles fonctionnalités - réinitialisé à 1 chaque année
• build = incrémenté pour les corrections de bogues et les versions internes

ÉDITER

** Maintenant, c'était pour une application interne qui était continuellement améliorée **

Cela ne fonctionnerait probablement pas pour les applications commerciales où il est important d'avoir des versions majeures à différents moments de l'année à des fins marketing et financières.

La raison pour laquelle cette question existe est que nous n'avons pas un seul moyen convenu de gérer la configuration.

La façon dont j'aime faire le numéro de version est simplement un entier incrémenté de 1. Je ne veux pas d'un numéro de version en plusieurs parties que je devrai expliquer ou documenter. Et je ne veux pas utiliser le numéro de révision SVN car cela nécessitera également des explications.

Vous auriez besoin de quelques scripts de publication au-dessus de SVN pour que cela se produise

J'ai très peu d'expérience dans le domaine. Cependant, voici ce que je ferais:

1. Choisissez un schéma de numérotation des révisions et respectez-le. Être cohérent.
2. Chaque changement de version doit représenter un changement significatif . La taille d'un changement est importante et les niveaux de changement reflétés dans le numéro de version dépendent de vous.

Bien sûr, vous pouvez simplement utiliser le numéro de révision svn --- comme beaucoup d'autres l'ont suggéré !!!

J'espère que ça aide.

Nous utilisons une syntaxe simple major.minor.julian_date.

Où;

• major - La première version est 1, puis lorsque nous introduisons de nouvelles fonctionnalités majeures ou des changements si importants qu'ils ne sont pas rétrocompatibles, augmentez ce nombre.
• minor - Les principales versions de jalons. Pour chaque build poussé par la production, ce nombre augmente.
• julian_date - Le jour julien, la compilation a été transférée au contrôle qualité.

L'exemple de la première version poussée vers QA le 1/15 est -> 1.0.015 L'
exemple de la première version poussée vers Production le 3/4 est -> 1.1.063

Ce n'est pas parfait, mais pratique car nous poussons les builds au contrôle qualité presque quotidiennement.

Quelques bonnes infos ici:

Quand changer les versions de fichier / d'assemblage

Tout d'abord, les versions de fichier et les versions d'assemblage ne doivent pas nécessairement coïncider les unes avec les autres. Je recommande que les versions de fichiers changent à chaque build. Mais, ne changez pas les versions d'assembly avec chaque build juste pour pouvoir faire la différence entre deux versions du même fichier; utilisez la version du fichier pour cela. Décider quand changer les versions d'assembly nécessite une discussion sur les types de builds à prendre en compte: expédition et non-expédition.

Constructions non expédiées En général, je recommande de conserver les mêmes versions d'assemblage non d'expédition entre les versions d'expédition. Cela évite les problèmes de chargement d'assembly fortement nommés dus à des incohérences de version. Certaines personnes préfèrent utiliser la stratégie des éditeurs pour rediriger de nouvelles versions d'assembly pour chaque build. Cependant, je déconseille cela pour les versions non expédiées: cela n'évite pas tous les problèmes de chargement. Par exemple, si un partenaire copie x votre application, il se peut qu'il ne sache pas qu'il faut installer la politique de l'éditeur. Ensuite, votre application sera cassée pour eux, même si cela fonctionne très bien sur votre machine.

Mais, s'il y a des cas où différentes applications sur la même machine doivent se lier à différentes versions de votre assembly, je recommande de donner à ces builds différentes versions d'assembly afin que la bonne pour chaque application puisse être utilisée sans avoir à utiliser LoadFrom / etc.

Builds d'expédition Quant à savoir si c'est une bonne idée de changer cette version pour les builds d'expédition, cela dépend de la façon dont vous voulez que la liaison fonctionne pour les utilisateurs finaux. Voulez-vous que ces versions soient côte à côte ou en place? Y a-t-il de nombreux changements entre les deux versions? Vont-ils briser certains clients? Vous souciez-vous que cela les casse (ou voulez-vous forcer les utilisateurs à utiliser vos mises à jour importantes)? Si oui, vous devez envisager d'incrémenter la version de l'assembly. Mais, là encore, considérez que faire cela trop souvent peut gâcher le disque de l'utilisateur avec des assemblages obsolètes.

Lorsque vous modifiez vos versions d'assemblage Pour remplacer les versions codées en dur par la nouvelle, je recommande de définir une variable sur la version dans un fichier d'en-tête et de remplacer le codage en dur dans les sources par la variable. Ensuite, exécutez un pré-processeur pendant la construction pour mettre la version correcte. Je recommande de changer de version juste après l'expédition, pas juste avant, afin d'avoir plus de temps pour attraper les bogues dus au changement.

Ou pour utiliser votre numéro de version «pensé» virgule numéro de subversion .. zB:

1.0.101 // révision 101, version

ou 1.0.101-090303 // avec la date de sortie, j'utilise ceci