Mon équipe utilise Team Foundation Server pour le contrôle de code source et, aujourd’hui, j’ai corrigé quelques bogues et une application de test de la fumée avant de l’enregistrer, mais j’ai oublié de commenter du code. (Ce code a rendu l'interface utilisateur un peu étrange.)
Je veux savoir quelles sont les bonnes pratiques avant de vérifier le code - je ne veux plus commettre ce genre d'erreur.
Vous ne devriez jamais enregistrer de code commenté. Si vous avez du code qui a besoin d'être commenté avant les enregistrements, vous le faites mal.
En ce qui concerne les règles:
Construire
3.1 Corriger les erreurs de construction
Exécuter des tests
4.1 Correction des tests cassés
Aller à 1 (jusqu'à ce qu'il n'y ait rien de nouveau à obtenir)
Ne vous enregistrez que lorsque toutes les étapes sont terminées.
Voir la danse d'enregistrement .
Autres bonnes pratiques:
la source
rebase -i
procéder au transfert vers le référentiel principal, vous devez nettoyer votre historique local en écrasant les validations si nécessaire.Je ne veux pas être trop d'un pantsweasel, mais l'hypothèse de cette question (et tout sauf une des réponses) concerne surtout les VCS centralisée, tels que TFS, SVN, Perforce, etc.
assez juste, il est ce que le PO utilise.
Cependant, lorsque vous utilisez DVCS (tels que Mercurial et Git), vous ne devriez généralement pas attendre pour enregistrer, et la plupart des choses mentionnées dans les réponses - telles que diff, obtenir les dernières nouvelles, fusionner, etc. - ne sont pas nécessaires. . Même des choses telles que des révisions de code et des tests sont préférables après l'enregistrement (bien que peut-être avant de pousser, cela dépend ...)
La seule exception que j'ai vue ici (jusqu'à présent) est l'association à un élément de travail. Bien sûr, commenter l'enregistrement est également bon ...
la source
Trois choses que je n'ai pas vues dans d'autres réponses:
Inclure les nouveaux fichiers
Rétablir les fichiers non modifiés
Vérifiez votre commit soumis
Deux choses quand j'utilise Git:
Atomic commet:
git add --patch
pour diviser mon changement en plusieurs parties si nécessaire.Voir les diffs en résumant
git commit --verbose
afin que je puisse voir un diff de mon changement pendant que je tape dans mon message de validation. (Ou j'utilise mon git-vim patché pour montrer le diff.)la source
Quelques éléments de «bonne pratique» que je mets en application sur les serveurs de mon équipe sont assez simples. Tout d'abord, avant de vous enregistrer, vous devez toujours obtenir les dernières informations et exécuter une construction locale, afin de vous assurer que personne d'autre n'a vérifié quoi que ce soit dans lequel votre code se heurtera. En outre, prenez soin de tout conflit de code sur votre ordinateur local, pas sur le serveur. Une fois que votre code, avec le dernier code téléchargé, a été confirmé pour se construire et fonctionner correctement, vous êtes prêt pour l'étape suivante. Exécutez tous les tests automatisés, puis commencez votre enregistrement pour vous assurer qu'ils fonctionnent toujours correctement. Ensuite, juste pour être sûr, soyez à nouveau au courant.
En tant qu'administrateur TFS, il est possible d'appliquer des commentaires à tous les enregistrements. Je recommanderais de toujours mettre des commentaires d’enregistrement pour votre travail, que celui-ci soit appliqué ou non. Si vous avez la possibilité de le faire, appliquez-le. Assurez-vous que les commentaires sont, au moins, un résumé général de ce que vous avez changé depuis la dernière fois que vous avez archivé votre code. changé dans cet enregistrement. Cela facilite beaucoup le débogage d'une construction cassée.
En outre, si vous disposez des privilèges d’administrateur TFS, appliquez des générations évolutives aux archivages (pour vous assurer que tous les autres savent immédiatement si leur enregistrement casse quelque chose), et vous pouvez configurer le serveur pour effectuer un archivage sécurisé ( si le code coché interrompt la construction, le serveur la rejette) ou vous pouvez simplement lui demander de créer un bogue et de l’affecter à celui qui a cassé la construction.
Il y a quelques autres options que vous pouvez activer ou désactiver pour que tout soit en ordre ou suggérer à votre administrateur TFS de l'activer pour garder les choses propres et propres ... mais elles sont largement préférables.
la source
Rechercher et remplacer les mots de malédiction ;-)
la source
Si vous vous enregistrez à partir de Windows, vérifiez si votre code ne contient pas ces caractères ^ M invisibles - les éditeurs sous UNIX donnent souvent des erreurs / avertissements à cause de cela.
Essayez également de remplacer les onglets - différents utilisateurs finiront par voir les arrêts de tabulation différemment, certains avec 4 espaces, certains 8 et ne seront pas bons pour la lisibilité du code.
La meilleure approche à mon humble avis consiste à faire en sorte qu'un script prédéfini vérifie votre code par rapport aux instructions de codage de votre organisation. Les charges des systèmes de contrôle de source ont cette fonctionnalité.
la source
Dans mon entreprise, nous utilisons des avis d’enregistrement. Celles-ci n'ont pas besoin d'être détaillées, mais montrer à quelqu'un les différences de votre liste de modifications et en tenir compte mettra parfois en évidence la mauvaise frappe que vous avez manquée lors des tests.
Notre serveur de contrôle de code source ne vous autorisera pas à enregistrer sauf si vous notez le nom du réviseur dans les commentaires (sous la forme! Initiales, par exemple! BW si Bruce Wayne a fait votre commentaire). L'examinateur reçoit un courrier électronique indiquant qu'il a contribué à la révision. Ceci est ouvert à une exploitation évidente mais semble fonctionner assez bien.
la source
Dans la mesure du possible, j'aime associer un enregistrement à un élément de travail. Cela vous donne des informations contextuelles sur POURQUOI cela a été changé, pas seulement sur QUOI a été changé. TFS a un système de suivi des éléments de travail assez décent, il est donc relativement facile de le faire au moment de l’enregistrement.
(ceci s'ajoute à l'examen des diffs de mes modifications)
la source
Une petite chose que je fais est de ne pas archiver les fichiers qui n’ont pas vraiment changé. Ces fichiers peuvent avoir été modifiés par inadvertance ou avoir été impliqués dans des refactorisations annulées ou rendues sans objet.
De cette façon, votre ensemble de modifications (associé à un élément de travail) contient exactement les fichiers nécessaires pour satisfaire l'élément de travail.
la source
Pour combiner toutes les réponses ici et donner une liste de contrôle complète
[check in / check out] vous ne devriez pas vous enregistrer directement dans le flux de travail des autres utilisateurs. Vous devriez avoir une stratégie de flux: par exemple, un flux dans lequel vous pouvez archiver et extraire les sorties de manière indépendante sans déranger les autres: votre travail soyez en sécurité, mais dans votre propre flux de développement, donc [uniquement dans votre propre flux de développement]. À chaque enregistrement, vous l'associez à un enregistrement de modification pour que vos modifications soient identiques à celles-ci (l'ensemble de modifications) (vous pouvez ainsi distribuer les bogues / bogues, etc. de rfc individuels, sans avoir à fournir «tout»).
[puis rebasez avec votre flux d'équipe] cela signifie que vous obtenez les modifications des autres dans votre propre flux. Au cours de cette opération, vous pouvez voir dans le dialogue de fusion tous les "diffs" et les parcourir ou ... s'il y en a des milliers et / ou si vous utilisez non pas du code, mais aussi, par exemple, des modèles de données / projets siebel, etc. les fusions manuelles non triviales, les fusions manuelles triviales-automatiques et triviales, la dernière catégorie contient les plus difficiles. Rappelez-vous que vous travaillez toujours dans votre propre flux.
[refonte complète] Si tout va bien, enregistrez toutes les modifications que vous venez de recevoir du flux d'équipe: votre propre flux est maintenant à jour.
[Livrer] maintenant livrer votre travail au flux d'équipe. SI vous ne voulez pas tout livrer, vous pouvez également sélectionner, par exemple, 1 RFC spécifique avec des versions de fichiers spécifiques ou un ensemble de RFC / défauts résolus.
[test deliver] ça devrait aller, mais comme il y a une chance que quelqu'un apporte entre-temps des modifications: vous pouvez tester si votre travail fonctionne avec les dernières modifications du flux d'équipe. Avec les mêmes boîtes de dialogue de fusion montrant des différences.
[complete deliver] terminez votre livraison et votre travail est maintenant dans le flux d'équipe.
Pour compliquer les choses: comme il est toujours possible que le travail que vous avez livré = ok MAIS vous travaillez déjà sur une version ultérieure, vous devez toujours baseline toujours après livrer et indiquer la base de référence sur laquelle elle est préférée par les autres utilisateurs. . Cela garantit que les autres développeurs obtiennent une version recommandée et non la dernière version du flux (si vous travaillez dans ce scénario). Il s’agit également d’une triple vérification. Même si les dernières versions du flux d’équipe sont "mauvaises", elles ne sont toujours pas celles sur lesquelles les autres se basent ou se regardent et votre gestionnaire de configuration peut fusionner la version précédente vers la version suivante pour annuler. votre livraison.
Dans votre exemple, vous indiquez que vous avez oublié de commenter du code. Des erreurs se produisent. Le système de gestion de la configuration autour de lui devrait s'en charger. Par exemple, il se peut que des milliers de modifications interviennent et que les "constructions" et les "intégrations" se déroulent dans une hiérarchie de flux sur différents serveurs chaînés et traités à temps. Ainsi, même si, au bout de 5 mois, votre code commenté est testé sur un serveur d'intégration, car votre code doit être intégré à d'autres codes et systèmes, il devrait toujours être possible de supprimer votre ensemble de modifications de manière atomique et de continuer. La meilleure pratique est donc plus ou moins à un niveau supérieur. La conception globale des flux de gestion de la configuration devrait en prendre soin. Pour les développeurs individuels, la meilleure pratique consiste bien entendu à valider / tester l’unité. Mais de la grande image à "
la source
Certains des éléments suivants s'appliquent plus que d'autres (ou sous différentes formes) en fonction de votre SCM, alors les voici:
REMARQUE : certains des éléments ci-dessus semblent plutôt évidents, mais vous ne pouvez pas croire combien de personnes travaillent réellement sur la branche principale ou apportent des modifications en production en premier , puis créent manuellement des deltas pour passer au contrôle de version ... directement sur la branche principale. .. et avec des étiquettes. Douce comme de la bile fermentée mélangée à du jus d'aisselle non lavé ... ouais, comme ça.
la source
Avoir une liste de contrôle personnelle. Commencez vide quand vous vous trompez, à une entrée. Quand il devient une seconde nature, retirez-le de la liste.
Exécutez les tests. Si elles réussissent, inscrivez-la. Si vous vous trompez et que quelque chose dépasse les tests, écrivez un test.
la source
Nous faisons ce qui suit ...
Test - Nous voulons nous assurer que cela fonctionne. À tout le moins, nous voulons savoir que cela ne casse rien.
Révision du code, ou du moins vérification par un ami - C’est un excellent moyen de s’assurer que les connaissances sont diffusées et que les personnes sont mises à jour. Cela aide aussi à attraper les bugs avant d’enregistrer les choses.
Envoyer un préavis - Un préavis est envoyé au groupe avant l'enregistrement. Le but n'est pas seulement de laisser savoir aux fichiers quels fichiers ou zones changent, mais cela leur donne un avertissement (au cas où ils choisiraient de prendre note) au cas où ces changements sont susceptibles de les affecter.
Quelques heures après l'envoi de la notification préalable, l'enregistrement est effectué et le groupe est informé par courrier électronique. Tout le monde dans le groupe peut savoir quand le travail sur un bogue ou une fonctionnalité est terminé.
Une copie de l’avis d’enregistrement est collée dans l’enregistrement de correctif associé au bogue ou à la fonction. Lors de la recherche dans les enregistrements, nous trouvons qu’il est très pratique d’avoir une idée de ce que le correctif / la fonctionnalité impliquait.
la source
Exécutez vos tests unitaires sur lesquels vous avez travaillé avec tant de diligence. Le vert c'est bien.
la source
Assurez-vous que votre code est correctement formaté (par exemple pour Java: sélectionnez votre code et appuyez sur Ctrl-Maj-F dans Eclipse). Mais faites attention à faire la même chose pour tout un document.
la source
Toujours, toujours, toujours , vérifiez que les changements que vous avez apportés ne brisent pas la construction. Surtout des changements mineurs qui peuvent sembler triviaux.
Une fois que j’ai fait un changement très mineur qui, à mon avis, ne poserait aucun problème juste avant de quitter le travail pour le week-end. Effectivement, ce petit changement a brisé la construction et aucun test nocturne n'a été exécuté pour notre projet. Le chef des questions-réponses n'était pas très content de cela, et à juste titre.
la source
Recherchez des parties de vos modifications pouvant constituer des unités autonomes.
Souvent, lorsque j'ai une solution de travail ou une amélioration au code, plusieurs modifications ont été apportées. Certaines d'entre elles sont spécifiques au changement de comportement que je vais obtenir; d'autres sont des refactorings que j'ai faits pour rendre ce changement plus propre.
Je préfère enregistrer chaque refactoring séparément, avec sa propre description de changement, comme ceci:
Ensuite, une fois que chaque refactoring correct est enregistré, le changement de comportement final est souvent anodin.
De plus, certaines modifications affectent de nombreuses lignes de code mais ne sont pas très intéressantes, tandis que d'autres sont très localisées mais ont un impact important. Si ces modifications sont enregistrées ensemble, il peut être difficile de lire les diffs. Donc, je les garde séparés.
Plus tard, lorsque quelqu'un lit l'historique des changements, il est évident que la situation actuelle en est devenue la raison et pourquoi. Il est également trivial d’annuler mon changement de comportement car il n’est pas mêlé à d’autres modifications.
la source
Faites ce que vous feriez en retournant quelque chose que vous avez emprunté à quelqu'un. Assurez-vous qu'il est propre et en bon état. Si vous avez causé des dégâts, assurez-vous de nettoyer avant de renvoyer le code à son propriétaire (dans la plupart des cas, votre employeur).
la source
Je garde un dépôt HG local pour mon travail.
Je ne prétends pas que ce sont les meilleurs, mais ils fonctionnent pour moi.
la source
Lorsque j'écris du code dont je sais qu'il n'est pas censé être archivé, j'ajoute une ligne avant celle-ci contenant "// TEMP:" et après celle-ci avec "// END TEMP.". Ceci, associé au fait que diff soit vérifié avant l'enregistrement, m'annonce que je ne vais pas enregistrer ce code par erreur.
la source
Testez minutieusement tout ce que vous avez ajouté ou modifié. Essayez tous les cas possibles auxquels vous pouvez penser. Ne laissez pas les tests à l'assurance qualité. Si je mangeais un sandwich à chaque fois que je faisais quelques changements mineurs, puis que j'essayais quelques essais, par souci de sécurité, et que je voyais immédiatement des problèmes, j'aurais beaucoup de sandwichs. Je me dis d'habitude à voix haute: "Je suis vraiment content d'avoir essayé ça ..."
Vous dites que l'interface utilisateur est devenue étrange après votre changement. Si vous aviez seulement exécuté le programme et consulté l'interface utilisateur avant de vous enregistrer, auriez-vous remarqué le problème?
la source