Meilleure pratique: Versionnage du logiciel

Existe-t-il des directives ou des meilleures pratiques standard pour mettre à jour un logiciel que vous développez dans votre temps libre, mais qui sera néanmoins utilisé par certaines personnes? Je pense qu’il est nécessaire de mettre à jour ce type de logiciel pour en savoir plus sur la version dont il est question (par exemple pour la correction de bogues, le support, etc.).

Mais où est-ce que je commence la gestion des versions? 0.0.0? ou 0.0? Et puis comment augmenter les nombres? changement majeur release.minor? et ne devrait-on pas engager un système de contrôle de version dans une autre version? ou est-ce seulement pour les versions qui sont utilisées de manière productive?

Vous devriez commencer avec la version 1, à moins que vous ne sachiez que la première version que vous “lancez” est incomplète.

En ce qui concerne la manière dont vous incrémentez les versions, c’est à vous de décider, mais utilisez la numérotation majeure, mineure, comme guide.

Il n’est pas nécessaire que chaque version que vous engagez au contrôle de code source soit une autre version – vous aurez bientôt un très grand numéro de version. Vous devez uniquement incrémenter le numéro de version (d’une manière ou d’une autre) lorsque vous publiez une nouvelle version sur le monde extérieur.

Donc, si vous effectuez un changement majeur, passez de la version 1.0.0.0 à la version 2.0.0.0 (vous êtes passé de WinForms à WPF par exemple). Si vous faites un changement plus petit, passez de 1.0.0.0 à 1.1.0.0 (vous avez ajouté le support des fichiers png). Si vous apportez une modification mineure, passez de 1.0.0.0 à 1.0.1.0 (vous avez corrigé certains bogues).

Si vous voulez vraiment obtenir des détails, utilisez le numéro final comme numéro de compilation, ce qui augmente pour chaque enregistrement / validation (mais je pense que cela va trop loin).

Je voudrais utiliser le type de version de xyz

x – version majeure
y – version mineure
z – numéro de build

Je suis essentiellement ce modèle:

  • partir de 0.1.0

  • quand il est prêt je twig le code dans le repo source, tag 0.1.0 et crée la twig 0.1.0, le head / trunk devient 0.2.0-snapshot ou quelque chose de similaire

  • J’ajoute de nouvelles fonctionnalités uniquement au tronc, mais les corrections de backport à la twig et au moment de sa sortie 0.1.1, 0.1.2, …

  • Je déclare la version 1.0.0 lorsque le produit est considéré comme complet et ne présente pas de défauts majeurs

  • à partir de là – tout le monde peut décider quand incrémenter la version majeure …

J’utilise cette règle pour mes applications:

xyz

Où:

  • x = numéro de version principale, 1- ~.
  • y = numéro de fonction, 0-9. Augmentez ce nombre si le changement contient de nouvelles fonctionnalités avec ou sans corrections de bogues.
  • z = numéro de correctif, 0- ~. Augmentez ce nombre si le changement ne contient que des corrections de bogues.

Exemple:

  • Pour les nouvelles applications, le numéro de version commence par 1.0.0.
  • Si la nouvelle version ne contient que des correctifs de bogues, augmentez le numéro de correctif pour que le numéro de version soit 1.0.1.
  • Si la nouvelle version contient de nouvelles fonctionnalités avec ou sans correctifs, augmentez le numéro de la fonctionnalité et réinitialisez le numéro de correctif à zéro pour que le numéro de version soit 1.1.0. Si le numéro de fonctionnalité atteint 9, augmentez le numéro de version principal et réinitialisez le numéro de fonctionnalité et de correctif à zéro (2.0.0, etc.)

Nous utilisons abcd où

  • a – majeure (à la livraison au client)
  • b – mineur (incrémenté à la livraison au client)
  • c – révision (incrémentée sur les versions internes)
  • d – build (incrémenté par le régulateur de vitesse)

Un autre exemple de l’approche ABC est la gestion des versions d’Eclipse . Les faisceaux Eclipse ont plutôt un quasortingème segment:

Dans Eclipse, les numéros de version sont composés de quatre (4) segments: 3 entiers et une chaîne respectivement nommée major.minor.service.qualifier . Chaque segment capture une intention différente:

  • le segment majeur indique une rupture dans l’API
  • le segment mineur indique les modifications “visibles de l’extérieur”
  • le segment de service indique les corrections de bogues et le stream de changement de développement
  • le segment qualificatif indique une construction particulière

Il existe également le système de gestion des versions de date , par exemple: YYYY.MM , YY.MM , YYYYMMDD

C’est très instructif car un premier regard donne une impression sur la date de sortie. Mais je préfère le schéma xyz, car je veux toujours connaître le point exact d’un produit dans son cycle de vie (Major.minor.release)

La réponse de base est “Cela dépend”.

Quel est votre objective dans la gestion des versions? Beaucoup de gens utilisent version.revision.build et ne publient que version.revision dans le monde comme version de publication plutôt que comme version de développement. Si vous utilisez la version «check-in», vous constaterez rapidement que vos numéros de version deviennent volumineux.

Si vous planifiez votre projet, j’augmente la révision des versions avec des modifications mineures et incrémente la version des versions avec des modifications majeures, des corrections de bogues ou des fonctionnalités / fonctionnalités. Si vous proposez des versions de type bêta ou nocturne, étendez le contrôle de version pour inclure la génération et incrémentez-la à chaque version.

Cependant, à la fin de la journée, c’est à vous de décider et cela doit avoir du sens pour vous.

Comme Mahesh dit: j’utiliserais le type de version de xyz

x – version majeure y – version mineure z – numéro de build

vous voudrez peut-être append un datetime, peut-être au lieu de z.

Vous incrémentez la version mineure lorsque vous avez une autre version. La version majeure restra probablement 0 ou 1, vous changez cela lorsque vous effectuez des changements majeurs (souvent lorsque votre logiciel n’est pas compatible avec les versions précédentes, ou que vous avez modifié l’intégralité de votre infrastructure)

Vous savez que vous pouvez toujours vérifier pour voir ce que font les autres. Les logiciels open source ont tendance à permettre l’access à leurs référentiels. Par exemple, vous pouvez pointer votre navigateur SVN sur http://svn.docsortingne-project.org et regarder le système de gestion des versions utilisé par un projet réel.

Numéros de version, balises, tout est là.

Nous suivons l’approche abc comme:

L’incrémentation ‘a’ s’il y a des changements majeurs dans l’application. Comme nous mettons à jour l’application .NET 1.1 vers .NET 3.5

increament ‘b’ s’il y a des modifications mineures, comme tout nouveau CR ou Enhancement est implémenté.

increament ‘c’ s’il y a des correctifs dans le code.

Je lance le contrôle de version au niveau le plus bas (pas de correctif). Je ne limite pas ce segment à 10. À moins que vous ne suiviez des builds, vous devez simplement décider quand vous voulez appliquer un incrément. Si vous avez une phase d’assurance qualité, cela peut être le cas lorsque vous appliquez un incrément au segment le plus bas, puis le segment suivant lorsqu il passe le contrôle qualité et est libéré. Laissez le segment le plus élevé pour les changements de comportement majeur / interface utilisateur.

Si vous êtes comme moi, vous en ferez un hybride afin de suivre le rythme de progression de votre logiciel.

Je pense que le modèle le plus accepté est abc ou abcd surtout si vous avez QA / Compliance dans le mix. J’ai eu tellement de flous autour de la date étant une partie régulière des versions que j’ai abandonné pour le grand public.

Je ne surveille pas les versions, donc j’aime utiliser le modèle abc à moins qu’un correctif ne soit impliqué. Lorsque je dois appliquer un correctif, j’applique le paramètre d comme date avec heure. J’ai adopté le paramètre de temps comme d car il y a toujours le potentiel de plusieurs dans une journée où les choses explosent vraiment dans la production. Je n’applique que le segment d (AAAAMMJJHHNN) lorsque je divergent pour un correctif de production.

Personnellement, je ne serais pas opposé à un schéma logiciel de va.b revc où c est AAAAMMJJHHMM ou AAAAMMJJ.

Tout cela dit. Si vous pouvez simplement récupérer un outil pour le configurer, vous éviterez les problèmes liés à la gestion des versions et vous pourrez simplement dire “utiliser l’outil” … car tout le monde dans le processus de développement est généralement si conforme. .