À quelle fréquence dois-je / fais-tu des commits?
Je suis un récent diplômé universitaire (depuis hier) - BS en informatique. Je suis un grand fan du contrôle de version depuis que je me suis fâché contre une mission sur laquelle je travaillais et que je suis reparti de zéro, en effaçant quelques heures de travail vraiment bon. Oups!
Depuis lors, j'ai utilisé Bazaar et Git (et SVN quand je devais le faire pour une classe de génie logiciel), bien que principalement Git pour faire le contrôle de version sur tous mes projets. Habituellement, je suis assez fidèle à la fréquence à laquelle je commets, mais à l'occasion, j'y vais pendant un certain temps (plusieurs fonctions, etc.) avant d'écrire un nouveau commit.
Donc, ma question est la suivante: à quelle fréquence devez-vous faire des commits? Je suis sûr qu'il n'y a pas de règle stricte et rapide, mais quelle ligne directrice suivez-vous (essayez-vous)?
Chaque fois que j'ai quelque chose qui fonctionne (c'est-à-dire qui ne casse rien pour personne d'autre), je fais un enregistrement J'écris d'abord la plupart de mes tests, ce qui signifie que chaque fois que je passe un nouveau test, je m'enregistre.
En pratique, cela signifie quelques fois par heure. Au moins deux fois par heure, 5 étant un peu.
Vous ne devriez pas vous engager en fonction du temps, mais en fonction des fonctionnalités. Chaque fois que vous ajoutez une nouvelle fonctionnalité qui mérite d'être validée, validez. Vous avez ajouté une méthode de travail? Commettre. Vous avez corrigé une faute de frappe? Commettre. Vous avez corrigé une indentation de fichier incorrecte? Commettre. Il n'y a rien de mal à valider de petits changements, dès que la validation est pertinente.
Ce qui ne va pas, c'est de commettre un grand nombre de changements, sans relations les uns avec les autres. Cela rend très difficile la détection de la source de validation d'une régression donnée.
Parfois, je fais vingt commits en une heure, et parfois je fais une fois par jour, selon la quantité de code qui a été modifiée.
Faire de petits commits vous permet d'utiliser des outils très puissants comme git-bissect.
N'oubliez pas la règle n ° 1 du commiter: ne jamais casser le coffre. Si vous devez effectuer plusieurs validations susceptibles de casser le tronc, créez plutôt une branche.
Cela dépend un peu de l'environnement de développement.
Si vous êtes le seul à contribuer à une base de code, un commit différé ne sera pas crucial. Cependant, si vous êtes dans une équipe de plusieurs développeurs, et que tout le monde pense "eh bien, j'attendrai un peu avec le commit", alors vous finirez souvent par gérer beaucoup de conflits et perdre beaucoup de temps.
La règle générale (pour les deux scénarios) serait: Engagez-vous aussi souvent que possible. Si vous pensez que "ce n'est pas encore prêt" (car cela cassera la construction ou n'est tout simplement pas encore fait), créez une branche et validez-la, mais assurez-vous de la valider.
Au moins une fois par jour, généralement trois ou quatre car j'ai tendance à m'engager chaque fois que je prends une pause. Je travaille seul, je n'ai donc pas à me soucier de gâcher quelqu'un d'autre, et je peux toujours revenir sur un fichier si je pense que je me suis trompé de chemin.
J'ai eu une mauvaise expérience une fois quand je ne faisais pas de commits régulièrement et mon disque dur s'est écrasé et j'ai perdu quelques heures de travail. Étant donné que mon référentiel se trouve sur une autre machine et est sauvegardé régulièrement, il n'y a aucune raison que j'aurais dû perdre quoi que ce soit.
Grâce aux branches git et à leur facilité de gestion, je m'engage très souvent. Je dirais que chaque fois que vous ajoutez quelque chose que vous jugez important et qui pourrait vous aider à construire quelque chose plus tard, vous devez vous engager.
De plus, je me retrouve souvent à refactoriser et à ajouter de nouveaux tests avant le nouveau code, donc dans ce cas, je m'engage à chaque fois que je lance le test, le regarde échouer, le refaire passer et refactoriser.
En outre, après toute correction de bogue, aussi minime ou insignifiant qu'il puisse paraître.
Il m'arrive aussi de suivre la voie "engagez-le dès qu'il compile".
Sur DVCS, je m'engage à chaque fois que je commence un changement qui serait vraiment ennuyeux si je ne pouvais pas annuler, à chaque fois que je devais partager avec d'autres, ou à tout moment, il serait vraiment utile de voir ce que j'avais changé depuis ce moment. Cela varie de plusieurs fois par heure à quelques fois par jour. De plus, je m'engage très rarement lorsque ma build ne compile pas et ne s'exécute pas sans défauts de segmentation immédiats, bien que cela puisse aussi être utile si vous voulez être en mesure d'isoler et de partager uniquement le correctif pour ce bogue particulier.
Notez qu'avec le contrôle de version centralisé, que vous devrez probablement utiliser au travail, vous ne vous engagez généralement pas tant que vous n'êtes pas sûr de ne pas recevoir une tempête de courriels en colère pour le faire. Selon le degré d'indépendance des changements que vous apportez et le niveau d'adhésion de votre entreprise au dogme de l'intégration continue, cela ressemble plus à une fois par jour à peut-être une fois par mois pour une grande nouvelle fonctionnalité.
Cette différence de fréquence est l'une des principales raisons pour lesquelles j'utilise git en plus du VCS centralisé officiel de mon entreprise.
Si vous travaillez dans un environnement d'équipe avec un serveur de build, vous ne voudrez vous engager que lorsque vous avez quelque chose qui se construit. C'est très ennuyeux pour le reste de l'équipe sinon :)
J'ai regardé cette présentation Joel On Software - FogBugz/Kiln récemment et je pense que cela correspond bien à votre question.
Alors que dans certains contrôles de version, "commit" est synonyme de "publier" (ou "faire souffrir les autres") dans les VCS distribués, ils sont souvent séparés.
Le moment de la validation peut donc dépendre du VCS que vous utilisez.
Validez automatiquement après chaque build réussi.
Je suppose que si vous souhaitez revenir à une version antérieure et que vous vous souvenez de l'heure approximative de l'horloge murale du point auquel vous souhaitez revenir, vous pouvez simplement consulter cette révision.
Bien sûr, si vous utilisez TDD, il existe de meilleures solutions intégrées.
Chaque soir, quand je rentre chez moi, j'ai un script qui passera automatiquement par toutes mes branches et fera un commit (notez que tous les développeurs ne reçoivent pas ces changements. C'est juste ma branche personnelle). De cette façon, je n'ai pas à y penser.
J'ai également un script qui exécutera automatiquement une mise à jour le matin. J'utilise celui-ci pour que si je travaille depuis mon ordinateur portable la nuit, mes changements sont automatiquement là le matin.
En ce qui concerne l'annulation des modifications que je fais pendant la journée, mon éditeur a un historique de toutes les modifications et est beaucoup plus rapide que de faire un commit à chaque sauvegarde/compilation.
Je travaille seule. Mon environnement de développement est mon ordinateur portable. L'environnement de validation est un serveur sur le Web.
Si le client utilise le serveur Web pour suivre la progression. Donc, presque tous les jours, je fais un téléchargement avec un e-mail disant ce qui est nouveau.
Si l'environnement de validation est un environnement de production, je dois faire plus attention à chaque modification testée avant toute validation. Mais encore, semble souvent mieux, car personne ne doute que la nouvelle fonctionnalité soit déjà planifiée ou déjà effectuée; ils obtiennent ce qu'ils demandent dès que possible.