Meilleure pratique: versionnage de logiciels [fermé]

Existe-t-il des directives ou des meilleures pratiques standard sur la façon de mettre à jour un logiciel que vous développez pendant votre temps libre pour le plaisir, mais qui sera néanmoins utilisé par certaines personnes? Je pense qu'il est nécessaire de mettre à jour un tel logiciel pour que vous en sachiez avec la première version (par exemple pour la correction de bogues, le support, etc.).

Mais par où commencer le versioning? 0.0.0? ou 0,0? Et puis comment incrémenter les nombres? changement majeur de release.minor? et ne devrait-on pas s'engager dans un système de contrôle de version comme une autre version? ou est-ce uniquement pour les versions qui sont utilisées de manière productive?

Vous devriez commencer par la version 1, sauf si vous savez que la première version que vous "publiez" est incomplète d'une manière ou d'une autre.

Quant à la façon dont vous incrémentez les versions, cela ne dépend que de vous, mais utilisez la numérotation de construction majeure, mineure comme guide.

Il n'est pas nécessaire d'avoir toutes les versions que vous vous engagez à contrôler comme un 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 dans 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 effectuez une modification plus petite, passez de 1.0.0.0 à 1.1.0.0 (vous avez ajouté la prise en charge des fichiers png). Si vous apportez une modification mineure, passez de 1.0.0.0 à 1.0.1.0 (vous avez corrigé quelques bugs).

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

J'utiliserais une x.y.zsorte de versioning

x- version majeure - version
ymineure
z- numéro de build

Je suis fondamentalement ce schéma:

• partir de 0.1.0

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

• J'ajoute de nouvelles fonctionnalités uniquement au tronc, mais le backport corrige la branche et avec le temps j'en libère 0.1.1, 0.1.2, ...

• Je déclare la version 1.0.0 lorsque le produit est considéré comme une fonctionnalité complète et ne présente pas de défauts majeurs

• à partir de là - tout le monde peut décider quand incrémenter la version principale ...

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 la modification contient de nouvelles fonctionnalités avec ou sans correction de bogues.
• z = numéro de correctif, 0- ~. Augmentez ce nombre si la modification ne contient que des corrections de bogues.

Exemple:

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

Nous utilisons abcd où

• a - majeur (incrémenté à 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 cette A.B.Capproche est la version de bundle Eclipse . Les bundles Eclipse ont plutôt un quatrième segment:

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

• le segment principal indique une rupture dans l'API
• le segment mineur indique des changements "visibles de l'extérieur"
• le segment de service indique les corrections de bugs et le changement de flux de développement
• le segment qualificatif indique une construction particulière

Il y a aussi le système de date versioning , par exemple: YYYY.MM, YY.MM,YYYYMMDD

C'est assez informatif 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 objectif dans le versioning? Beaucoup de gens utilisent version.revision.build et annoncent uniquement version.revision au monde entier car c'est une version de sortie plutôt qu'une version de développement. Si vous utilisez la «version» de l'enregistrement, vous constaterez rapidement que vos numéros de version deviennent volumineux.

Si vous planifiez votre projet, j'incrémenterais la révision pour les versions avec des changements mineurs et la version incrémentée pour les versions avec des changements majeurs, des corrections de bogues ou des fonctionnalités / fonctionnalités. Si vous proposez des versions de versions bêta ou nocturnes, étendez le versioning pour inclure la version et l'incrémenter à chaque version.

Pourtant, à la fin de la journée, cela dépend de vous et cela doit avoir un sens pour vous.

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

x - version majeure y - version mineure z - numéro de version

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

Vous incrémentez la version mineure lorsque vous en avez une autre. La version majeure restera probablement 0 ou 1, vous changez cela lorsque vous effectuez vraiment des modifications majeures (souvent lorsque votre logiciel est à un point où il n'est pas rétrocompatible avec les versions précédentes, ou que vous avez changé votre cadre entier)

Vous savez que vous pouvez toujours vérifier ce que font les autres. Les logiciels libres ont tendance à autoriser l'accès à leurs référentiels. Par exemple, vous pouvez pointer votre navigateur SVN vers http://svn.doctrine-project.org et jeter un œil au système de version utilisé par un vrai projet.

Numéros de version, balises, tout y est.

Nous suivons l'approche abc comme:

incrémenter «a» s'il y a des changements majeurs dans l'application. Comme nous mettons à niveau l'application .NET 1.1 vers .NET 3.5

incrémenter «b» s'il y a des changements mineurs comme tout nouveau CR ou amélioration est implémenté.

incrémenter «c» s'il y a quelques défauts corrigés dans le code.

Je commence le versioning au segment le plus bas (non hotfix). Je ne limite pas ce segment à 10. À moins que vous ne suiviez des builds, il vous suffit de décider quand vous souhaitez appliquer un incrément. Si vous avez une phase d'assurance qualité, c'est peut-être là que vous appliquez un incrément au segment le plus bas, puis le segment suivant vers le haut lorsqu'il passe l'AQ et est libéré. Laissez le segment le plus haut pour les changements majeurs de comportement / interface utilisateur.

Si vous êtes comme moi, vous en ferez un hybride des méthodes pour correspondre au rythme de progression de votre logiciel.

Je pense que le modèle abc ou abcd le plus accepté, surtout si vous avez QA / Compliance dans le mélange. J'ai eu tellement de problèmes avec la date étant une partie régulière des versions que je l'ai abandonnée pour le grand public.

Je ne fais pas le suivi des builds, donc j'aime utiliser le modèle abc sauf si un correctif est impliqué. Lorsque je dois appliquer un correctif, j'applique le paramètre d comme date avec heure. J'ai adopté le paramètre temps comme d car il y a toujours le potentiel de plusieurs dans une journée quand les choses explosent vraiment en production. J'applique uniquement le segment d (YYYYMMDDHHNN) lorsque je diverge pour un correctif de production.

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

Cela dit. Si vous pouvez simplement accrocher un outil pour le configurer et l'exécuter, cela vous évitera le mal de tête d'avoir à rassembler la facette d'opinion du versioning et vous pouvez simplement dire "utiliser l'outil" ... parce que tout le monde dans le processus de développement est généralement si conforme .