GIT / Autres VCS - À quelle fréquence commettre?
Je suis un programmeur depuis plus de 11 ans depuis plus de 11 ans et je commence juste à entrer dans la version de la version pour de vrai. Les endroits où j'ai travaillé pour n'avoir jamais vraiment utilisé la version de la version (une commis à la fin de chaque journée, les autres n'ont tout simplement pas pris la peine).
Je ne suis pas content de la façon dont j'ai été enseigné au contrôle de la version (programmé.js, programmé.js.bak, programme.js.bak.20110901, etc.) et je m'enseigne pour utiliser Git.
Je l'utilise actuellement avec GitHub pour garder mon fichier de fichier .VIMRC sur 4 machines, mais je ne suis jamais sûr quand je devrais envisager un changement de commit, et quand il s'agit simplement d'un changement qui devrait être inclus avec un autre commit. J'ai commencé à l'utiliser pour le développement JavaScript aussi et je le trouve utile :)
Ma question est la suivante: à quel point les changements deviennent-ils un engagement? Comme je l'ai dit, la seule société que j'ai travaille pour l'OMS utilisée le contrôle de la version l'a fait à la fin de la journée - cela ne me semble pas sensé. Je pense qu'ils devraient être plus atomiques. Mais ma question est comment atomique?
Est une solution de bogue pour une fonction assez pour un commit? Devrais-je réparer trois fonctions (non liées) et les engager tous à la fois? Devrais-je vous engager après avoir changé la condition dans une déclaration if?
Sur des projets personnels, je vous engageons après tout changement. Je trouve personnellement cela utile, mais je ne sais pas si c'est une mauvaise pratique ou ennuyeuse.
Comment faites-vous cela, comment l'industrie le fait-elle et quelles sont les meilleures pratiques?
(Je suis un développeur Web, alors travaillez sur des projets courts - peut-être un mois)
Chaque changement individuel devrait être un commettras. Quelques choses à considérer:
- Choses ayant commis des moyens que vous pouvez rouler en arrière. Supposons que vous avez une plus grande tâche à accomplir. Vous avez 50% fait, cette partie semble bon jusqu'à présent. Ensuite, vous continuez et cassez quelque chose massivement par une erreur. Avoir la commettras entre les moyens que vous pouvez aller là-bas et ne pas perdre tout le travail.
- Le contrôle de version est pas un endroit pour déverser des données et d'oublier. Le contrôle de version fournit une histoire. Lateron vous pouvez utiliser l'histoire, y compris ma fonction préférée annoter, de comprendre pourquoi un changement a été fait (et qui est responsable) cela aide souvent. Mais fonctionne correctement, le changement doit être petit et autonome.
- Lorsque l'on travaille en équipe, il est bon d'avoir des gens qui l'examinent (en fait, même quand travailler seul ce serait génial ;-)), pour un examen, il est bon d'avoir de petites pièces qui peuvent être examinés sans être mélangés entre les changements non liés.
En regardant git spécifiquement: git permet commits locales, qui ne blessent pas d'autres, il peut même être acceptable pour commettre un code cassé localement et de fixation qui avec un commettras plus tard avant de pousser. Les développeurs git sont fiers de la rapidité commettras travaux d'exploitation, donc il suffit de commettre localement ne pas interrompre vraiment le processus de développement. Git permet également la réécriture commits, de sorte que ces deux (ou plus) commits pourraient être réécrite en un seul avant d'être poussé, ce qui pourrait faciliter la révision - tout réécritures sont dangereux et doivent se faire avec soin (ne réécrit pas après push, etc.)
En ce qui concerne Git, je crois que l'on devrait s'engager aussi souvent que possible - certaines personnes commettent chaque compilation réussie. Ne confondez pas les engagements avec des pousses - un commit local ne doit pas nécessairement être poussé (et avec GIT, vous devez utiliser de nombreuses branches car elles sont bon marché).
Cela devrait être la règle tout autour, mais certains SCM sont trop lents pour une telle règle.
Personnellement, lorsque vous utilisez SVN, j'essaie de vous engager plusieurs fois par jour et seulement lorsque je suis certain que le code est en bon état (c'est-à-dire compiler et transmettre tous ses tests).
Vous vous engagez quand vous pouvez écrire un message de validation (vous écrivez ceux-ci ... :) Cela décrit clairement la nouvelle fonctionnalité/fonction/bugfix/amélioration/amélioration incluse dans la validation.
Si vous corrigez des bugs indépendants, ils devraient être des engagements séparés. La raison étant, si vous trouvez plus tard un problème avec vous, corrigez-le pour bug A, il est beaucoup plus facile de l'inverser s'il n'est pas combiné avec des bugs B et C. Surtout s'il y a eu du code supplémentaire commis avant de trouver le problème. La même logique s'applique également aux fonctionnalités. Fondamentalement, la plus petite unité de code de travail que quelqu'un d'autre peut commander et utiliser. Même si quelqu'un est vous sur une autre machine.
Les petits commits ne sont pas exactement si mauvais quand ils sont clairement sur la réparation de choses spécifiques. Il est compréhensible que l'histoire de la révision puisse être encombrée, mais elle peut également fournir des informations intéressantes sur le style de développement de l'équipe de projet. Lorsque le nouveau développeur rejoint le projet, il peut être utile pour lui de lire une liste d'historique de révision si les modifications sont décrites assez clairement.
Pourtant, il y a quelques directives qui varient de projet par projet. Certains ont un ensemble de tests qui doivent être exécutés avec succès avant que le code ne puisse être engagé, d'autres sont configurés pour exécuter des tests automatiquement Après Engage (exemple utile de service de test d'intégration continue public est Travis CI).
La réponse variera également par le type de système de gestion de version utilisé dans le projet. Avoir principalement utilisé des outils de type DVCS, je pense que cela peut être un rappel utile pour moi-même de faire de petits commits car cela fonctionne également comme une documentation partielle. Une quantité trop importante de petits commits peut être confondre au début, mais selon recherche , la plupart des commits dans des projets open source sont petits. Il pourrait y avoir une variance dans la manière dont le développement interne fonctionne, mais souvent, ce sont les petites choses qui commencent à ennuyer dans des outils et de petits changements suffisent souvent pour résoudre des problèmes spécifiques.
Certains des raisons possibles de la garder petite:
"Vous devriez essayer de scinder vos changements en petites étapes logiques et de commettre chacun d'eux. Ils devraient être cohérents, travaillant indépendamment de tout engagement ultérieur, passez la suite de tests, etc."
Ont trouvé des alias utiles pour voir la liste des commits GIT dans la console. lg a vraiment aidé à voir des changements plus rapides et plus clairement que diverses autres vues de la liste de validations:
# Show history in short format with colors
alias lg="git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr)%Creset' --abbrev-commit --date=relative"
Je cherchais toujours à avoir mon journal de validation ressemblant à la changelog pour mon programme. Ce n'est pas un objectif réalisable, mais quelque chose à efforcer. Il définit à peu près que je veux un commit séparé pour chaque nouvelle fonctionnalité et chaque bugfix, mais pas trop.
De plus, lorsque vous travaillez dans une équipe, je pense à une lettre comme une lettre à un autre développeur, décrivant le changement que j'ai fait. Je ne veux pas spamer mon homme avec chaque petit commettre, je fais lorsque vous développez une nouvelle fonctionnalité. Cela laissera beaucoup mieux impression si je viens de produire un commettre plus important, comme si j'avais écrit la fonctionnalité sans faille lors de ma première tentative.
Mais d'autre part, je ne veux pas tomber dans l'obscurité solitaire ... Passer un mois en train de créer un énorme commit parfait. Je veux garder mes collègues développeurs au courant de mes progrès. Toute grande fonctionnalité peut généralement être divisée en morceaux significatifs. Donc, en règle générale, une commission publique par jour devrait être le minimum.