Je lisais la note de Martin Fowler sur l’ intégration continue et il cite comme un impératif «Tout le monde s’engage pour le réseau principal tous les jours».
Je n'aime pas engager de code tant que la section sur laquelle je travaille n'est pas complète et qu'en pratique, j'engage mon code tous les trois jours: un jour pour analyser / reproduire la tâche et apporter des modifications préliminaires, un deuxième jour pour terminer les modifications. et un troisième jour pour écrire les tests et le nettoyer ^ pour le soumettre. Je ne serais pas à l'aise de soumettre le code plus tôt.
Maintenant, je tire les modifications du référentiel et les intègre localement généralement deux fois par jour, mais je ne m'engage pas souvent, à moins de pouvoir effectuer un travail moins important.
Question: s'engager au quotidien est-il une si bonne pratique que je devrais modifier mon flux de travail pour l'adapter, ou ce n'est pas souhaitable?
Edit: J'imagine que j'aurais dû préciser que je voulais dire "commit" dans le sens de CVS (alias "push") puisque c'est probablement ce que Fowler aurait voulu dire en 2006 quand il a écrit ceci.
^ L'ordre est plus arbitraire et dépend de la tâche. Mon but était d'illustrer la durée et les activités, et non la séquence exacte.
la source
Réponses:
Je ne suis pas d'accord avec cette règle et je souscris à ce qu'a dit Mason Wheeler . Je voudrais ajouter quelques idées.
J'essaie de m'engager à chaque changement significatif: cela peut être plusieurs fois par jour si je corrige plusieurs petits bugs, ou une fois par semaine si je travaille sur un logiciel plus volumineux qui ne peut pas être utilisé par le reste du monde. le code de manière significative jusqu'à ce qu'il atteigne un état cohérent.
En outre, j'interprète committing comme la publication d'une révision significative qui apporte de nouvelles fonctionnalités à la base de code. Je pense que l’on devrait essayer de nettoyer le code avant de s’engager afin que les autres développeurs puissent comprendre le sens et le but du changement quand ils consultent l’historique des révisions. Moins il y a de changements dans l'historique des autres développeurs, mieux c'est: quand je regarde l'historique des révisions, je veux voir les incréments qui ajoutent des fonctionnalités significatives; Je ne suis pas intéressé par toutes les petites idées que chaque développeur avait et voulait tester avant de parvenir à la solution.
De plus, je ne pense pas que ce soit une bonne idée d'utiliser le serveur SVN (ou tout système de contrôle de version) comme une installation de sauvegarde sur laquelle l'instantané actuel du code est validé (à condition qu'il soit compilé): vous pouvez utiliser une clé USB ou un lecteur USB externe ou un disque réseau pour refléter votre code actuel afin qu'il ne soit pas perdu si votre ordinateur tombe en panne. Le contrôle des révisions et la sauvegarde des données sont deux choses différentes. La publication d'une révision n'est pas la même chose que l' enregistrement d'un instantané de votre code.
Enfin, je pense qu’il ne devrait pas être problématique de s’engager de temps en temps (c’est-à-dire uniquement lorsque l’on est vraiment satisfait de l’état actuel du code) et qu’éviter les conflits de fusion n’est pas une bonne justification pour commettre (trop) souvent. De nombreux conflits de fusion se produisent lorsque différentes personnes travaillent sur les mêmes fichiers en même temps, ce qui est une mauvaise pratique (voir par exemple le présent article , point 7). Les conflits de fusion doivent être réduits en scindant un projet en modules avec des interfaces claires et le moins de dépendances possibles, et en coordonnant le travail des développeurs afin que le code sur lequel ils travaillent se chevauche le moins possible.
Juste mes 2 cents.
MODIFIER
Une autre raison contre les commissions prématurées qui m'est venue à l'esprit est qu'une version (très) boguée ne peut pas être testée. Si vous vous engagez dans le coffre et que votre équipe de test teste tous les jours, il est possible qu’elle n’ait pas de version testable pendant quelques heures (ou un jour). Même si vous n'essayez pas de corriger le bogue et de simplement annuler vos modifications, une reconstruction peut prendre quelques heures. Avec, par exemple, cinq testeurs travaillant dans votre équipe, vous avez perdu 5 x 2 = 10 heures de temps par équipe en raison de l'inactivité. C'est ce qui m'est arrivé une fois, alors j'essaie vraiment d'éviter les commits prématurés au nom de commit le plus tôt possible .
la source
Revision control and data backup are two different thingsOui, je me sens vraiment comme ça.Je commets du code plusieurs fois par jour . Chaque fois que je parviens à un point où le code est suffisamment complet pour être compilé et ne casse pas autre chose, il entre.
Vous devriez envisager de rompre votre travail pour pouvoir vous enregistrer en toute sécurité quelques fois par jour.
Les raisons pour cela sont deux:
la source
Adhérer à une méthodologie ou à une pratique sans comprendre les raisons qui la sous-tendent n'est jamais une bonne idée. C'est de là que provient la programmation culte du cargo.
Par conséquent, "je devrais m'engager tous les jours parce que Martin Fowler l'a dit" est tout simplement stupide. Et parfois, ce n'est pas pratique aussi. Si vous travaillez sur une nouvelle fonctionnalité compliquée, vous ne pourrez peut-être pas en arriver à une vérification tant que vous n'y avez pas déjà travaillé pendant quelques jours.
Cela ne signifie pas que vous devez vous assurer que tout est parfait avant de l'enregistrer. C'est un bon moyen de perdre du travail en cas de problème. La bonne chose à faire est de développer et d’utiliser un bon jugement en la matière. Les règles de base ne peuvent que vous aider beaucoup.
la source
Oded a donné deux raisons importantes pour engager le code aussi souvent que possible. J'ajouterai quelques autres:
Pendant que vous travaillez sur votre morceau de code, d’autres peuvent avoir besoin de fonctions sur ce code. Ils ne devraient pas attendre 6 jours pour l'obtenir. Dans ce cas, mes collègues créent généralement un prototype dans mon morceau de code, le commettent, j'ajoute le corps et le commets à nouveau. Et cela se fait généralement en quelques heures.
Le code «commun» vise à ce que tout le monde voie chaque changement le plus rapidement possible. Si le morceau de code sur lequel vous travaillez est totalement séparé du travail des autres et que vous ne les faites pas attendre, il est recommandé de créer une branche sur laquelle travailler, puis, si tout réussit, de le fusionner. la ligne principale.
la source
Je crois fermement en l'engagement de tous les changements logiques qui méritent d'être conservés. Engagez-vous souvent, et si le code ne vaut pas la peine d'être gardé, revenez-le à l'état pur. Plus vous attendez pour remettre / publier votre code, plus il est difficile à implémenter et plus vous rencontrerez de problèmes. Vous obtiendrez également des commentaires sur vos contributions beaucoup plus rapidement:
Les petits changements sont beaucoup plus faciles à gérer.
En outre, il convient de noter la différence entre différents systèmes de contrôle de version. Certains, tels que Git (distribué), vous permettront de valider et de contrôler l’ensemble de votre historique localement, en appuyant uniquement lorsque vous êtes prêt à publier. D'autres, comme SVN (centralisé), combinent les deux étapes, ce qui rend les petits commits très inefficaces.
N'oubliez pas que vos commits sont essentiellement des documents de modification. Lorsque les choses vont mal, vous serez heureux d'avoir plus d'histoire que pas assez. Un seul engagement pour une semaine de travail me semble inutile. Je finirais par lire chaque ligne de code modifiée plutôt que le résumé de chaque bloc logique.
la source
Je pense que la plupart des réponses ici manquent l’un des points principaux de la déclaration de Martin Fowlers. Ceci est lié à l' intégration continue . Le code qui n'est pas archivé (poussé / publié / fusionné) dans la ligne principale n'est pas testé.
Cela ne doit pas être lu comme un encouragement à valider le code que vous avez sur votre machine locale chaque fois qu'il est temps de quitter le bureau. Comme l'ont souligné plusieurs autres personnes ici, ce serait mauvais, cela casserait la construction et causerait une ligne principale instable.
Cependant, il est encourageant d'essayer d'apporter vos modifications par petites étapes qui peuvent être archivées dans la ligne principale sans causer de problèmes. Ceci encourage l'évolution du code au lieu de tout déchirer et de réécrire.
Maintenant, qu'est-ce qui est bien avec cette façon de travailler?
Bien sûr, tous les changements ne se prêtent pas à cette approche. Comme d'autres l'ont souligné, aucune règle n'est absolue. Toutefois, pour les modifications qui devraient rester longtemps en dehors de la ligne principale, configurez une ligne principale alternative avec son propre système d'intégration continue et suivez la même approche. Avec les VCS distribués d'aujourd'hui, c'est une chose assez facile à faire.
la source
Arguments pour vérifier chaque jour:
Arguments contre l’enregistrement quotidien:
Je ne crois pas qu'il y ait de bonne raison de s'enregistrer moins de jour en jour en dehors de la paresse ou de la désorganisation. Rien de pire que de voir que le code exécuté dans l'environnement de développement ne correspond pas à celui de la branche de développement, car quelqu'un "n'a pas encore fini" et ne s'est donc pas enregistré.
J'adorerais me tromper, merci de me faire savoir tout argument légitime contre l'enregistrement quotidien.
la source
Si vous voulez dire «commettre» par «fusionner dans le réseau principal», vous ne devriez certainement pas le faire tous les jours dans un projet de logiciel diffusé aux clients. Vous devez fusionner les modifications effectuées et testées pour que la ligne principale soit toujours opérationnelle et libérable, et non dans un état de rupture avec des fonctionnalités à moitié terminées.
Cependant, le luxe de pouvoir utiliser le contrôle de version distribuée actuel est que vous pouvez à la fois garder la ligne principale stable et faire votre travail à
git/hg/whatever commitchaque fois que vous souhaitez préserver l'état de choses. Je le fais une fois toutes les quelques heures et certainement à la fin de chaque journée.Avec DVCS, vous pouvez publier votre travail, collaborer avec d’autres membres de votre équipe et le tenir au courant des modifications apportées à la branche principale. Vous pouvez faire tout cela sans nuire à la stabilité du code dont dépendent vos clients et / ou d’autres équipes.
À une époque où Subversion était la technologie la plus récente et où il était impossible de créer des fourchettes de fonctions sans trop de difficultés, il aurait peut-être été préférable d'avoir une ligne principale dans laquelle plusieurs fonctions étaient en construction simultanée. Mais cette supériorité ne dépasse pas 2010.
la source
Dans Team Foundation Server, vous pouvez «Shelve», ce qui n’est pas la même chose qu’un enregistrement, mais vous permet simplement de sauvegarder votre code afin que, si votre machine meurt, vous n’ayez pas perdu les modifications.
J'ai également vu des éditeurs de logiciels qui ont une "ligne de développement" et une "ligne principale". Les développeurs sont libres de se connecter à la ligne de développement dès qu'ils le jugent utile et seul le chef d'équipe a accès à la ligne principale. Ils sont donc responsables de la copie du code de dev à main quand il est prêt pour la production.
la source