À quelle fréquence valider les modifications du contrôle de code source?
À quelle fréquence dois-je valider les modifications apportées au contrôle de code source? Après chaque petite fonctionnalité, ou uniquement pour les grandes fonctionnalités?
Je travaille sur un projet et j'ai une fonctionnalité à long terme à mettre en œuvre. Actuellement, je m'engage après chaque morceau de travail, c'est-à-dire chaque sous-fonctionnalité implémentée et bug corrigé. Je m'engage même après avoir ajouté un nouveau bloc de tests pour une fonctionnalité après avoir découvert un bug.
Cependant, je suis préoccupé par ce modèle. Dans une journée de travail productive, je pourrais faire 10 commits. Étant donné que j'utilise Subversion, ces commits affectent l'ensemble du référentiel, donc je me demande si c'est vraiment une bonne pratique d'en faire autant?
Chaque fois que je termine une "réflexion complète" sur le code qui se compile et s'exécute, je m'enregistre. Cela se termine généralement entre 15 et 60 minutes. Parfois, cela peut être plus long, mais j'essaie toujours de vérifier si j'ai beaucoup de changements de code que je ne voudrais pas réécrire en cas d'échec. Je m'assure également généralement de la compilation de mon code et je m'enregistre à la fin de la journée de travail avant de rentrer chez moi.
Je ne m'inquiéterais pas de faire "trop" de validations/enregistrements. C'est vraiment nul quand vous devez réécrire quelque chose, et c'est bien de pouvoir revenir en arrière par petits incréments au cas où.
Lorsque vous dites que vous craignez que vos "validations affectent l'ensemble du référentiel" --- faites-vous référence au fait que le numéro de révision de l'ensemble du référentiel augmente? Je ne sais pas combien de bits Subversion utilise pour le stocker, mais je suis sûr que vous ne manquerez pas de numéros de révision! Beaucoup de commits ne sont pas un problème. Vous pouvez vous engager dix fois plus souvent que le gars d'à côté et vous n'augmenterez pas du tout votre empreinte carbone.
Une seule fonction ou méthode doit être nommée pour ce qu'elle fait, et si le nom est trop long, cela fait trop. J'essaie d'appliquer la même règle aux check-ins: le commentaire de check-in doit décrire exactement ce que le changement accomplit, et si le commentaire est trop long, je change probablement trop à la fois.
J'aime ce petit article de Jeff Atwood: Arrivée tôt, arrivée souvent
Personnellement, je valide chaque groupe logique de code terminé/stable/compile et j'essaie de ne pas quitter la journée sans commettre ce que j'ai fait ce jour-là.
Si vous apportez des modifications majeures et que vous craignez d'affecter les autres personnes travaillant sur le code, vous pouvez créer une nouvelle branche, puis fusionner à nouveau dans le tronc une fois vos modifications terminées.
Je m'engage chaque fois que j'ai terminé une tâche. Cela prend généralement 30 minutes à 1 heure.
Si votre commentaire de contrôle de version dépasse une ou deux phrases, vous ne vous engagez probablement pas assez souvent.
Ne commettez pas de code qui ne fonctionne pas réellement. N'utilisez pas votre référentiel comme solution de sauvegarde.
Au lieu de cela, sauvegardez votre code incomplet localement de manière automatisée. Time Machine prend soin de moi, et il existe de nombreux programmes gratuits pour d'autres plateformes.
Je suis le mantra open-source (paraphrasé) - engagez-vous tôt, engagez-vous souvent.
Fondamentalement, chaque fois que je pense avoir ajouté des fonctionnalités utiles (même petites) sans introduire de problèmes pour les autres membres de l'équipe.
Cette stratégie de validation fréquente est particulièrement utile dans les environnements d'intégration continue car elle permet des tests d'intégration par rapport à d'autres efforts de développement, permettant une détection précoce des problèmes.
La règle de base, que j'utilise, est l'archivage lorsque le groupe de fichiers en cours d'archivage peut être couvert par un seul commentaire d'archivage.
Il s'agit généralement de s'assurer que les enregistrements sont atomiques et que les commentaires peuvent être facilement digérés par d'autres développeurs.
Cela est particulièrement vrai lorsque vos modifications affectent un fichier de configuration (tel qu'un fichier de contexte Spring ou un fichier de configuration Struts) qui a une portée étendue à l'application. Si vous effectuez plusieurs "groupes" de modifications avant l'archivage, leur impact se chevauche dans le fichier de configuration, entraînant la fusion des 2 groupes.
Je ne pense pas que vous devriez vous soucier autant de la fréquence. L'important ici est de savoir quoi, quand et pourquoi. Dire que vous devez vous engager toutes les 3 heures ou toutes les 24 heures n'a vraiment aucun sens. Engagez-vous lorsque vous avez quelque chose à engager, ne le faites pas si vous ne le faites pas.
Voici un extrait de mes meilleures pratiques recommandées pour le contrôle de version :
[...] Si vous apportez plusieurs modifications à un projet en même temps, divisez-les en parties logiques et validez-les en plusieurs sessions. Cela facilite beaucoup le suivi de l'historique des modifications individuelles, ce qui vous fera gagner beaucoup de temps lors de la recherche et de la correction de bogues ultérieurement. Par exemple, si vous implémentez les fonctionnalités A, B et C et corrigez les bogues 1, 2 et 3, cela devrait entraîner un total d'au moins six validations, une pour chaque fonctionnalité et une pour chaque bogue. Si vous travaillez sur une grande fonctionnalité ou effectuez une refactorisation approfondie, envisagez de diviser votre travail en parties encore plus petites et effectuez un commit après la fin de chaque partie. En outre, lors de l'implémentation de modifications indépendantes sur plusieurs modules logiques, validez les modifications séparément pour chaque module, même si elles font partie d'une modification plus importante.
Idéalement, vous ne devriez jamais quitter votre bureau avec des modifications non validées sur votre disque dur. Si vous travaillez sur des projets où les modifications affecteront d'autres personnes, envisagez d'utiliser une branche pour implémenter vos modifications et les fusionner à nouveau dans le tronc lorsque vous avez terminé. Lorsque vous validez des modifications dans des bibliothèques ou des projets dont dépendent d'autres projets, et donc d'autres personnes, assurez-vous de ne pas casser leurs versions en validant du code qui ne sera pas compilé. Cependant, avoir du code qui ne compile pas n'est pas une excuse pour éviter de commettre. Utilisez plutôt des branches. [...]
Votre modèle actuel est logique. Gardez à l'esprit comment vous tilisez ce contrôle de source: que faire si vous devez revenir en arrière ou si vous voulez faire un diff? Les morceaux que vous décrivez semblent être exactement le bon différentiel dans ces cas: le diff vous montrera exactement ce qui a changé dans l'implémentation du bogue # (spécifié dans le journal de connexion), ou exactement ce que le nouveau code était pour implémenter une fonctionnalité. De même, le retour en arrière ne touchera qu'une chose à la fois.
J'aime aussi m'engager après avoir fini un gros morceau de travail, qui est souvent plusieurs fois par jour. Je pense qu'il est plus facile de voir ce qui se passe dans les petits commits que dans les grands. Si vous vous inquiétez d'un trop grand nombre de validations, vous pouvez envisager de créer une branche et de la fusionner à nouveau dans le tronc lorsque l'ensemble de la fonctionnalité est terminée.
Voici un article de blog connexe: Coding Horror: Check In Early, Check In souvent
Comme d'autres l'ont déclaré, essayez de valider un bloc logique suffisamment "complet" pour qu'il ne gêne pas les autres développeurs (par exemple, il construit et passe des tests automatisés).
Chaque équipe de développement/entreprise doit définir ce qui est "suffisamment complet" pour chaque branche. Par exemple, vous pouvez avoir des branches de fonctionnalités qui nécessitent uniquement le code pour être construites, un tronc qui nécessite également du code pour passer des tests automatisés et des étiquettes indiquant que quelque chose a passé les tests de QA ... ou quelque chose comme ça.
Je ne dis pas que c'est un bon schéma à suivre; Je souligne seulement que la façon dont "se fait" dépend des politiques de votre équipe/entreprise.
Le moment où vous y pensez.
(tant que ce que vous enregistrez est sûr)
Cela dépend de votre système de code source et de ce que vous avez d'autre en place. Si vous utilisez Git, validez chaque fois que vous terminez une étape. J'utilise SVN et j'aime m'engager lorsque je termine une fonctionnalité entière, donc toutes les une à cinq heures. Si j'utilisais CVS, je ferais de même.
J'aime aussi vérifier régulièrement. C'est à chaque fois que j'ai franchi une étape vers mon objectif.
C'est généralement toutes les deux heures.
Ma difficulté est de trouver quelqu'un désireux et capable de effectuer autant de révisions de code.
Notre politique d'entreprise est que nous devons avoir un examen du code avant de pouvoir enregistrer quoi que ce soit, ce qui est logique, mais il n'y a pas toujours quelqu'un dans le département qui a le temps d'effectuer immédiatement un examen du code. Solutions possibles:
- Plus de travail par enregistrement; moins de checkins == moins d'avis.
- Modifiez la politique d'enregistrement de l'entreprise. Si je viens de faire un refactoring et que les tests unitaires sont tous verts, je peux peut-être assouplir la règle?
- Modifiez le changement jusqu'à ce que quelqu'un puisse effectuer la révision et continuer à travailler. Cela peut être problématique si le réviseur n'aime pas votre code et que vous devez le repenser. Jongler avec les différentes étapes d'une tâche en "mettant en suspens" les changements peut devenir compliqué.
Je suis d'accord avec plusieurs des réponses: ne pas archiver le code qui ne sera pas compilé; utiliser une branche ou un référentiel personnel si votre souci est d'avoir une "sauvegarde" du code ou de ses modifications; archiver lorsque les unités logiques sont terminées.
Une autre chose que j'ajouterais est qu'en fonction de votre environnement, le taux d'enregistrement peut varier avec le temps. Par exemple, au début d'un projet, l'enregistrement après que chaque élément fonctionnel d'un composant est terminé est logique à la fois pour la sécurité et pour avoir un historique de révision (je pense aux cas où les bits antérieurs sont refactorisés au fur et à mesure que des bits plus récents sont en cours de développement). Plus tard dans le projet, en revanche, une fonctionnalité entièrement complète devient plus importante, en particulier pendant le développement/test d'intégration. Une demi-intégration ou une demi-correction n'aide personne.
Quant à l'enregistrement après chaque correction de bogue: à moins que la correction ne soit triviale, absolument! Rien n'est plus pénible que de constater qu'un enregistrement contient trois correctifs et que l'un d'eux doit être annulé. Plus souvent qu'autrement, il semble que dans cette situation, le développeur a corrigé trois bogues dans une zone et décompose quel changement va à quelle correction de bogue est un cauchemar.
J'aime commettre des changements toutes les 30 à 60 minutes, tant qu'il compile proprement et qu'il n'y a pas de régression dans les tests unitaires.
Si vous travaillez sur une branche qui ne sera pas publiée, un commit est toujours sûr.
Cependant, si vous le partagez avec d'autres développeurs, la validation de code non fonctionnel risque d'être un peu ennuyeuse (en particulier si elle se trouve dans un endroit important). Normalement, je ne valide que du code qui "fonctionne" effectivement - non pas qu'il ait été entièrement testé, mais que je me suis assuré qu'il compile et n'échoue pas immédiatement.
Si vous utilisez un outil de suivi des bogues intégré, il peut être utile de faire des validations distinctes si vous avez corrigé deux bogues, afin que le journal de validation puisse aller à l'encontre des bons bogues. Mais là encore, parfois, un changement de code corrige deux bogues, alors il vous suffit de choisir celui contre lequel le mettre (à moins que votre système n'autorise un commit à être associé à plusieurs bogues)
Eh bien, vous pouvez avoir votre propre branche dans laquelle vous pouvez vous engager aussi souvent que vous le souhaitez, et lorsque vous avez terminé avec votre fonctionnalité, vous pouvez la fusionner dans le tronc principal.
En ce qui concerne la fréquence des validations, j'y pense de cette façon, quelle douleur cela me ferait si mon disque dur tombait en panne et que je n'avais pas commis quelque chose - le quantum de ce quelque chose pour moi est d'environ 2 heures de travail.
Bien sûr, je ne commets jamais quelque chose qui ne se compile pas.
Au moins une fois par jour.
Je n'ai pas de limite de temps spécifique par commit, j'ai tendance à commettre une fois un test réussi et je suis satisfait du code. Je ne commettrais pas de code qui ne se compile pas ou se trouve dans un état dans lequel je ne me sentirais pas bien de revenir en cas d'échec
Je crois toujours à l'expression "engagez-vous souvent, engagez-vous tôt". Je préfère les VCS décentralisés comme Mercurial et il n'y a aucun problème à valider plusieurs choses et à le pousser en amont plus tard.
C'est vraiment une question courante, mais la vraie question est: pouvez-vous valider du code inachevé?
Vous devez trouver un équilibre entre la sécurité et la récupérabilité d'une part et la facilité de gestion du changement pour l'ensemble du projet, d'autre part.
Le meilleur schéma que j'ai utilisé a eu deux réponses à cette question.
Nous avons utilisé 2 référentiels complètement séparés: l'un était le référentiel à l'échelle du projet et l'autre était notre propre référentiel personnel (nous utilisions rcs à l'époque).
Nous vérifierions dans notre référentiel personnel très régulièrement, à peu près chaque fois que vous enregistrez vos fichiers ouverts. En tant que tel, le référentiel personnel était essentiellement un grand tampon d'annulation à longue portée.
Une fois que nous avons eu un morceau de code qui serait compilé, testé ok et accepté comme étant prêt pour une utilisation générale, il a été archivé dans le référentiel du projet.
Malheureusement, ce système reposait sur l'utilisation de différentes technologies VCS pour fonctionner. Je n'ai trouvé aucune méthode satisfaisante pour obtenir les mêmes résultats en utilisant deux VCS du même type (par exemple, deux référentiels Subversion)
Cependant, j'ai obtenu des résultats acceptables en créant des branches de développement "personnelles" dans un référentiel Subversion - en vérifiant régulièrement la branche puis en fusionnant dans le tronc une fois terminé.
Chaque fois que vous terminez du code qui fonctionne et que vous ne foirez personne d'autre s'il l'obtient dans une mise à jour.
Et assurez-vous de bien commenter.