La version sémantique autorise-t-elle 4 composants dans les numéros de version?

16

Tous les exemples de versioning sémantique que j'ai vus montrent 3 composants en cours d'utilisation. Pas plus de 2 caractères de période. Chez $DAYJOB, nous utilisons 4 composants dans nos numéros de version:

5.0.1.2

Le versionnage sémantique le permet-il?

Et en tant que question secondaire de niveau supérieur et plus discutable, est-ce vraiment important? J'ai commencé à penser que ce pourrait être une bonne idée d'appliquer le contrôle de version sémantique, mais finalement des entités comme PCI le remplacent.

J'aurais dû clarifier mon commentaire PCI. Le problème est que les audits et leur coût influencent lorsque les composants majeurs et mineurs changent, pas nécessairement une véritable nouvelle fonctionnalité. Par exemple, si une fonctionnalité liée aux paiements est introduite, nous augmentons le numéro mineur pour PCI. Mais si nous ajoutons une toute nouvelle fonctionnalité liée à quelque chose dans l'interface graphique, ce n'est pas le cas. Seul le patch change. Donc, dans ce cas, nous n'avons pas vraiment notre mot à dire en tant que développeurs, car quelqu'un d'autre prend ces décisions.

void.pointer
la source
Le versioning sémantique est une ligne directrice. Où PCI indique-t-il quelque chose sur la façon dont les choses doivent être versionnées?
J'aurais dû clarifier mon commentaire PCI. Le problème est que les audits et leur coût influencent lorsque les composants majeurs et mineurs changent, pas nécessairement une véritable nouvelle fonctionnalité. Par exemple, si une fonctionnalité liée aux paiements est introduite, nous augmentons le numéro mineur pour PCI. Mais si nous ajoutons une toute nouvelle fonctionnalité liée à quelque chose dans l'interface graphique, ce n'est pas le cas. Seul le patch change. Donc, dans ce cas, nous n'avons pas vraiment notre mot à dire en tant que développeurs, car quelqu'un d'autre prend ces décisions.
void.pointer
@ void.pointer pouvez-vous donner un exemple de la raison pour laquelle vous utilisez le quatrième composant? L'utilisez-vous pour contourner fondamentalement les structures de coûts et de comptabilité internes - permettant à votre équipe de suivre les nouvelles fonctionnalités sans augmenter le nombre de correctifs?
enderland
@enderland Oui, fondamentalement. MAJOR(PCI).MINOR(PCI).FEATURE.HOTFIX+BUILD. Nous ne sommes fondamentalement autorisés qu'à modifier les 3e et 4e composants sans impliquer PCI (et par la suite les suzerains PCI de l'entreprise). Pour moi, cela semble un peu artificiel, je ne suis pas sûr qu'ils soient justifiés dans la façon dont ils gèrent le numéro de version, mais je ne connais pas suffisamment le PCI et le processus d'audit pour dire le contraire.
void.pointer
4
Nous utilisons également 4 groupes, et non 3. Pourquoi? Parce que C ++. C ++ a une compatibilité descendante binaire et une compatibilité descendante source : la première implique la seconde, mais la relation n'est pas symétrique. Ainsi, nous utilisons le 4ème groupe pour la compatibilité binaire (vous pouvez patcher le système à chaud) et le 3ème pour la compatibilité source (vous devez recompiler, mais vous ne devriez pas avoir à modifier votre propre code). Et vous savez quoi, ça marche pour nous!
Matthieu M.

Réponses:

21

Il semble que vous contourniez les conventions normales juste pour éviter les frais généraux / audits de processus. Cela ... me semble inquiétant.

Ce que vous faites est effectivement faire un numéro de version supplémentaire (votre chiffre PCI mineur) un peu intentionnellement afin de déplacer votre fonction / petits numéros de version dos un endroit, pour ne plus déclencher vos critères de vérification interne.


Quoi qu'il en soit, pour en venir à votre question sur le contrôle de version sémantique, la spécification pour le contrôle de version sémantique indique:

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

  • Version MAJEURE lorsque vous apportez des modifications d'API incompatibles,
  • Version MINEURE lorsque vous ajoutez des fonctionnalités d'une manière rétrocompatible, et
  • 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 génération sont disponibles en tant qu'extensions au format MAJOR.MINOR.PATCH .

Je souligne.

La question est donc la suivante: utilisez-vous le quatrième caractère pour les métadonnées de pré-version / génération? Ou est-ce essentiellement une autre indication de version que vous publiez?

Si "oui", alors la spécification du versioning sémantique le permet. Si «non», vous ne suivez techniquement pas le versioning sémantique.

Et en tant que question secondaire de niveau supérieur et plus discutable, est-ce vraiment important?

Que vous souhaitiez le suivre de manière rigide ou non est une décision que vous et votre équipe devez prendre. Le but du versioning sémantique est d'aider à la compatibilité des API:

Les corrections de bogues n'affectant pas l'incrémentation de l'API de la version du correctif, les ajouts / modifications d'API rétrocompatibles incrémentent la version mineure et les modifications d'API incompatibles en arrière incrémentent la version principale.

J'appelle ce système «Versioning sémantique». Dans ce schéma, les numéros de version et la façon dont ils changent donnent une signification au code sous-jacent et à ce qui a été modifié d'une version à la suivante.

C'est un système qui permet de rendre plus clair lorsque le contrôle de version affecte les utilisateurs en aval de l'API.

Tant que votre API est tout aussi claire, ce n'est pas une grosse affaire que vous choisissez. Le versioning sémantique se trouve être simple, par exemple si j'utilise 3.4.2 et que je dois passer à 3.4.10, je sais que je peux le faire sans rien casser. Si la nouvelle version est la 3.5.1, je sais qu'elle est rétrocompatible. Et je sais que la version 4.0.1 serait un changement de rupture.

Cela fait partie de la signification des numéros de version.

@enderland Oui, fondamentalement. MAJOR (PCI) .MINOR (PCI) .FEATURE.HOTFIX + BUILD. Nous ne sommes fondamentalement autorisés qu'à modifier les 3e et 4e composants sans impliquer PCI (et par la suite les suzerains PCI de l'entreprise). Pour moi, cela semble un peu artificiel, je ne suis pas sûr qu'ils soient justifiés dans la façon dont ils gèrent le numéro de version, mais je ne connais pas suffisamment le PCI et le processus d'audit pour dire le contraire.

Ok, ça va. Vous avez un système qui fonctionne pour vous et répond à vos besoins. C'est le point du versioning.

Si votre API est privée (uniquement en interne), la façon dont vous versionnez n'a pas d'importance tant que cela a du sens pour vous et pour tous ceux qui l'utilisent. Lorsque le contrôle de version dans un format standard est important, c'est lorsque de nombreux autres utilisateurs de votre API ont besoin de savoir «que signifie cette version?

Le fait d'avoir un système de version arbitraire confondra les personnes habituées à d'autres systèmes, comme le versioning sémantique. Mais si personne n'utilise vraiment votre système de version, sauf les personnes qui le créent - cela n'a pas vraiment d'importance.

enderland
la source
Concernant votre montage en haut: laissez-moi jouer l'avocat du diable ici. Les audits PCI coûtent de l'argent à l'entreprise, et toutes les fonctionnalités implémentées ne les concernent pas. Alors pourquoi encourir des coûts et autres frais généraux uniquement sur des principes? Comment est-ce si préoccupant? Je me rends compte que la méthode de détermination des audits est probablement erronée, mais la séparation des préoccupations semble raisonnable. Les choses qui ne sont pas liées à distance au traitement des cartes ne sont pas pertinentes pour PCI.
void.pointer
@ void.pointer Je ne suis pas en mesure de juger pourquoi / comment vos audits sont déterminés. Mais quelqu'un a décidé de procéder à un audit sur la base de critères spécifiques. Ignorer intentionnellement ces critères d'audit semble préoccupant (quel que soit le montant que vous économisez en le faisant).
enderland
1
@ void.pointer, enderland a raison. Si un terroriste menace de tuer votre famille si vos versions ne sont pas entièrement composées de lettres alphabétiques, le vrai problème est le terroriste. N'hésitez pas à ne pas suivre le versioning sémantique pour le contourner (en fait, je le suggère fortement dans ce cas), mais c'est vraiment cela: une solution de contournement rendue nécessaire par un problème différent.
Paul Draper du
1
@PaulDraper Quand est-ce que semver est devenu la One True Way to version?
Andy
1
@Andy, ce n'est pas le cas. Le PO a posé des questions sur SemVer. IDK pourquoi, mais c'est ce qu'il a fait.
Paul Draper du
8

Dans la version actuelle de Semantic Versioning, qui est 2.0.0 , non. Il existe une exigence qui définit la version comme la forme XYZ où X, Y et Z sont des entiers non négatifs qui ne contiennent pas de 0 de début:

Un numéro de version normal DOIT prendre la forme XYZ où X, Y et Z sont des entiers non négatifs et NE DOIT PAS contenir de zéros de tête. X est la version majeure, Y est la version mineure et Z est la version patch. Chaque élément DOIT augmenter numériquement. Par exemple: 1.9.0 -> 1.10.0 -> 1.11.0.

Cependant, la possibilité d'ajouter des métadonnées est autorisée pour:

Les métadonnées de construction PEUVENT être indiquées en ajoutant un signe plus et une série d'identificateurs séparés par des points immédiatement après le correctif ou la version préliminaire. Les identificateurs DOIVENT comprendre uniquement des caractères alphanumériques ASCII et un trait d'union [0-9A-Za-z-]. Les identificateurs NE DOIVENT PAS être vides. Les métadonnées de construction DEVRAIENT être ignorées lors de la détermination de la priorité de la version. Ainsi, deux versions qui ne diffèrent que par les métadonnées de génération ont la même priorité. Exemples: 1.0.0-alpha + 001, 1.0.0 + 20130313144700, 1.0.0-beta + exp.sha.5114f85.

Cependant, il est important de noter que le versionnage sémantique est spécifiquement destiné aux logiciels qui déclarent une API publique:

Les logiciels utilisant la version sémantique DOIVENT déclarer une API publique. Cette API peut être déclarée dans le code lui-même ou exister strictement dans la documentation. Quoi qu'il en soit, il doit être précis et complet.

Cela tend à soutenir le développement de bibliothèques ou de services et non au niveau d'une application.

La chose importante à considérer est la signification de vos numéros de version, à la fois pour une utilisation interne et externe. Les versions ne sont que des identifiants qui vous permettent de parler des différences de logiciel à deux moments différents. Le versionnage sémantique est une méthode pour mettre des règles autour de cela, donc si vous savez qu'une application utilise le versionnage sémantique, vous pouvez plus facilement déterminer le niveau d'effort requis pour mettre à jour vos packages. Suivre une norme commune peut être une bonne chose, mais si vous ne le pouvez pour aucune raison, la documentation des règles pour vos utilisateurs devrait également suffire.

Thomas Owens
la source
+1 pour la note API publique. Nous n'avons pas d'API publique, mais nous avons la possibilité de briser la compatibilité descendante dans d'autres aspects, tels que les données. Il est possible que nous expédions une version qui est installée sur les anciennes versions, mais les données ne changent pas, et nous ne sommes plus en mesure de lire ces données (en général, nous prenons cependant en charge les anciens formats)
void.pointer