Quand valider le code?
Lorsque vous travaillez sur un projet, le code peut être développé assez rapidement en une seule journée ou bit par bit pour une période prolongée de quelques semaines/mois/années. Comme les validations de code deviennent de plus en plus considérées comme une mesure du développement de projet, cela ne signifie pas vraiment qu'il a plus de code écrit qu'un projet qui a moins de validations.
La question est donc de savoir quand vraiment faire un commit dans le référentiel pour que le commit soit justifiable?
En complément: est-ce une pratique correcte de mesurer le développement d'un projet en fonction de ses engagements?
Vous vous engagez lorsque vous avez atteint un état de base de code dont vous souhaitez vous souvenir. Il y a beaucoup de raisons pour lesquelles vous voudrez peut-être vous souvenir d'un état de base de code particulier, il ne peut donc pas y avoir de règles strictes sur le moment de la validation. Cependant, le nombre de commits n'est certainement pas une mesure de la qualité ou du progrès.
J'aime penser au codage comme à l'escalade dans ce contexte. Vous grimpez un peu, puis vous mettez une ancre dans le rocher. Si jamais vous tombiez, la dernière ancre que vous avez plantée est le point qui vous sécurise, vous ne tomberez donc jamais plus de quelques mètres. Idem avec le contrôle de source; vous codez un peu et lorsque vous atteignez une position quelque peu stable, vous validez une révision. Si jamais vous échouiez horriblement, vous pouvez toujours revenir à cette dernière révision, et vous savez qu'elle est stable.
Cela dit, si vous travaillez en équipe, il est de coutume de vous assurer que tout ce que vous engagez est complet, logique, construit proprement et ne casse personne. Si vous devez apporter des modifications plus importantes qui pourraient interférer avec le travail des autres, créez une branche afin de pouvoir vous engager sans déranger personne.
Cela dépend également du système SCM que vous utilisez. Les systèmes distribués rendent généralement la fusion et la fourche indolores et rapides, et vous pouvez vous engager localement; cela signifie que vous devez vous engager beaucoup et pousser/fusionner lorsque vous avez effectué une quantité substantielle de travail. Avec des systèmes centralisés tels que svn ou cvs, la validation est plus coûteuse et affecte tout le monde. Le branchement résout partiellement ce problème, mais comme il se produit sur le serveur, il peut être extrêmement lent et la fusion peut être fastidieuse. Ainsi, avec les SCM centralisés, il existe souvent une culture plus prudente, où vous ne vous engagez qu'une fois que vous avez effectué une quantité importante de travail.
Quant à l'add-on: s'il vous plaît, ne faites pas ça. Les lignes de code, le nombre de validations, le nombre de bogues trouvés/résolus, etc., sont tous de très mauvaises mesures de qualité ou même de quantité.
Si vous utilisez DVCS comme Mercurial ou Git, vous devez vous engager dans votre référentiel local chaque fois que vous avez effectué une quantité importante de travail. Cependant, ne le poussez vers le référentiel partagé qu'après que cela fonctionne, un changement autonome qui a été testé.
Pour les VCS non distribués (comme par exemple SVN), la même logique s'applique, au lieu du référentiel local, utilisez la branche privée, au lieu de Push - fusionnez avec la branche principale.
Vous devez vous engager tôt et souvent.
Je connais des gens qui commettent aussi souvent que toutes les 90 secondes. Sérieusement. Cela semble fonctionner pour eux. J'ai expérimenté la validation chaque fois que j'enregistre un fichier, ce qui est probablement plus souvent que 90 secondes. Aujourd'hui, je m'engage probablement toutes les 15 minutes environ. Un VCS qui vous permet d'écraser plusieurs validations en une seule et qui permet des validations locales (comme git) rend cela beaucoup plus facile.
À quelle fréquence devez-vous vous engager? Difficile à dire, mais probablement plus souvent que maintenant. Continuez à vous engager de plus en plus souvent, trouvez un point qui vous semble trop souvent absurde, puis reculez un peu. Il y a de fortes chances que vous vous retrouviez avec quelque chose de raisonnable.
Vous mesurez le développement d'un produit en fonction de la valeur fournie à ses utilisateurs. Il n'y a pas d'autre mesure précise.
Les validations sont les éléments constitutifs de toute donnée/code contrôlé par version. Chaque commit doit effectuer exactement l'une des actions suivantes:
- Ajouter une nouvelle donnée ou fonction
- Corrigez un ou plusieurs bugs (un commit pour chaque correctif si possible) où le correctif peut être:
- Amélioration des performances
- Corriger le mauvais comportement du code
- Suppression des erreurs typographiques
- Refactorisation de code ou de données sans changer la sémantique. Ceci comprend:
- Réécriture d'un code identique à l'original
- Modification de la représentation des données dans un format différent
- Formatage du code ou des données pour répondre aux directives de mise en forme du projet
- Fusionner les modifications d'une autre branche (en amont/en aval)
De plus, lorsque vous travaillez dans des branches, les validations doivent aller dans une branche plus appropriée. Deux validations ne devraient pas avoir le même message de validation (impliquant des changements similaires) mais dans des branches différentes car cela déroute les collaborateurs. Une meilleure façon est de valider la branche principale et de fusionner avec la branche de fonctionnalité.
Si les committers suivent la règle ci-dessus, il devient trivial de:
- Inverser un changement particulier sans effets secondaires
- Identifier le comportement modifiant le changement de code à partir des changements de formatage du code
- Fusionner entre différentes branches évitant la plupart des conflits
- Collaborez avec d'autres développeurs qui peuvent tirer votre changement en toute simplicité
En ce qui concerne la mesure de l'avancement du projet en fonction des validations, il est possible que les validations de refactorisation et les corrections de bogues ne soient pas prises en compte.
Ne vous engagez que lorsque vous avez testé avec succès la fonction/module/fonctionnalité donnée et que vous êtes raisonnablement assuré qu'elle est prête pour l'intégration ou les tests du système.
Et pour répondre à vos questions complémentaires - NON !! la mesure de l'emplacement du projet ne doit jamais être déterminée par le nombre de validations ... qui sait ce qui a réellement été engagé? At-il été testé avec succès sur le système ou même testé à l'unité? Ce n'est pas parce qu'il est engagé - cela ne signifie pas qu'il est prêt pour la production.
En complément: est-ce une pratique correcte de mesurer le développement d'un projet en fonction de ses engagements?
Non. c'était un WTF quotidien pourquoi c'est une idée horrible.
Ma règle générale sur la validation du code consiste à m'enregistrer lorsque j'ai terminé un morceau de code et qu'il se compile. Chunk n'est pas vraiment défini. Si c'est une petite tâche, je ne pourrais pas m'enregistrer avant d'avoir terminé. S'il est plus grand, je pourrais m'enregistrer une fois chaque partie logique terminée.
Mais ne vérifiez jamais s'il ne compile pas. Je sais que cela semble stupide de dire à haute voix, mais j'ai déjà dû l'expliquer aux gens.
Engagez chaque changement significatif qui, selon vous, ne rompt pas quelque chose. Les seules choses que vous ne devriez pas valider sont les changements de style car ils n'incarnent pas de changement de logique. Mais sinon, plus les modifications que vous effectuez sont petites, mieux c'est.
Plus les validations sont petites, plus vous pouvez documenter le processus de réflexion, ce qui est un aspect d'un bon journal de validation. Un bon examen du code ne devrait pas seulement porter sur le résultat du code mais aussi sur le processus de réflexion.
En outre, avoir de nombreux petits commits facilite la bissect, une fonctionnalité beaucoup trop peu utilisée du contrôle de version, qui m'a épargné de nombreuses heures de recherche de bugs d'aiguille dans des bases de code de meules de foin.
Bisection en bref; Découvrez un problème dans la base de code actuelle. Ensuite, choisissez un commit dans le changelog où vous êtes sûr que le problème spécifique n'existait pas. Commencez par vérifier le commit en plein milieu entre la "bonne" et la "mauvaise" version. Testez pour voir si le problème est toujours présent. Si c'est le cas, vous devez regarder plus loin en arrière, au milieu du "bon" et du commit précédemment testé. Si le problème a disparu, il a été introduit après ce changement spécifique, vous devez donc vérifier le milieu entre le "mauvais" et le commit précédemment testé. Répéter. Finalement, vous vous retrouverez avec le commit qui a introduit le problème. Mais seulement si vous avez de petits commits, sinon vous saurez simplement dans quel grand tas de changements le problème est apparu.
Ici est comment cela fonctionne avec Git mais le principe s'applique à tout contrôle de version.
Faites un commit lorsque le code est prêt à être partagé avec d'autres utilisateurs du code - lorsqu'il est relativement stable, sûr et correctement testé.
Et non, je ne pense pas que les commits soient une bonne métrique pour le développement d'un projet, car je connais certains développeurs qui commettront chaque petite et petite modification, et d'autres qui n'engageront que d'énormes changements majeurs dans la fonctionnalité. Comment mesurez-vous quantitativement la valeur d'un engagement par rapport à un autre?
Dès que la tâche correspondante est terminée . Une tâche fait partie d'une histoire utilisateur .
Une tâche est effectuée lorsque:
- les tests unitaires correspondants passent,
- le code est correctement documenté et
- le code est validé.
Vous pouvez avoir une définition de done différente.
Je ne vois pas l'intérêt de mesurer le nombre de commits. Cependant, si vous voyez quelqu'un travailler pendant une longue période sur la même user story (ou pire, des stories), c'est une odeur.