Le code temporaire doit-il être placé sous contrôle de version et comment?

Voici quelques exemples de code temporaire / local. Il est nécessaire pour travailler avec la base de code, mais il serait dangereux d'en faire partie:

1. Fichiers de projet. Il peut être nécessaire de modifier les chemins afin de refléter la disposition sur le PC actuel.
2. Makefiles. Par exemple, l'optimisation peut devoir être désactivée pendant le débogage, mais pas pour le serveur CI.
3. Hacks laids sales. Par exemple, return 7au milieu d'une fonction, afin de tester quelque chose, selon la fonction, et soupçonné de casser à la valeur 7. Ou 7 est le code du bouton pas encore implémenté, que j'implémente et que je dois tester tout au long la vie de ma branche.

J'ai essayé de garder ceux-ci dans un git commit que je rebase toujours en haut avant de pousser vers le repo puis de pousser HEAD~. C'est assez gênant et ne fonctionne pas avec svn. Cacher me fait encore plus peur - "Est-ce que je me souviens d'avoir sauté après avoir poussé ??"

Garder le code hors du contrôle de version introduit un bruit désagréable à chaque fois qu'un commit est assemblé et il peut accidentellement être introduit dans un commit un vendredi soir.

Quelle serait une solution sensée pour un tel code à jeter?

Tout le code est temporaire. Lorsque je fais des changements, j'introduis de temps en temps des espaces réservés - cette icône que j'ai dessinée en attendant la vraie du concepteur, la fonction que je connais appellera la bibliothèque que mon collègue écrit et n'a pas encore terminée (ou démarrée), la journalisation supplémentaire qui sera supprimée ou conditionnée d'une autre manière, les bugs que je vais corriger une fois qu'ils auront été remarqués par l'équipe de test, etc.

Alors vérifiez tout. Utilisez une branche de fonctionnalité pour tout votre développement, puis vous pouvez fusionner la version finale dans le tronc et personne n'aura besoin de savoir quels hacks et bodges et correctifs vous avez faits pendant votre cycle de développement, ils n'auront besoin que de voir la version finale. Mais si vous vous êtes engagé régulièrement dans votre branche, vous pourrez voir les choses qui valaient la peine d'être conservées si une journée se déroulait de façon spectaculaire, ou si vous continuiez à coder après un déjeuner dans le pub.

Le contrôle de version n'est pas un référentiel d'artefacts ou un système de stockage de documents. Il s'agit de tenir l'histoire des changements. Collez tout ce que vous aimez là-dedans parce qu'un jour vous voudrez peut-être voir ce que c'était, et ce sont les jours où vous réalisez ce qu'est vraiment votre SCM.

PS. Les fichiers vraiment temporaires (par exemple .obj ou build artefacts) n'ont pas leur place dans votre SCM. Ce sont des choses qui n'ont de valeur pour personne. Vous pouvez dire ce qu'ils sont - si vous les supprimez, cela ne vous dérange pas, ou même remarquez qu'ils sont partis.

Fichiers de projet. Il peut être nécessaire de modifier les chemins afin de refléter la disposition sur le PC actuel.

Pour les fichiers de projet, la meilleure stratégie consiste à générer le fichier de projet via un script. Ajoutez le fichier de projet réel à vos ignores et générez simplement le fichier de projet si nécessaire. Par exemple, dans les projets Java, j'utilise gradle qui peut générer un projet éclipse.

Makefiles. Par exemple, l'optimisation peut devoir être désactivée pendant le débogage, mais pas pour le serveur CI.

Vous devriez pouvoir basculer entre le mode d'optimisation et de débogage sans modifier votre Makefile. À la place, utilisez un indicateur de ligne de commande, une variable d'environnement ou un fichier séparé qui ne se trouve pas dans votre référentiel pour contrôler cela.

Hacks laids sales. Par exemple, retournez 7 au milieu d'une fonction, afin de tester quelque chose, selon la fonction, et suspecté de casser à la valeur 7. Ou 7 est le code du bouton pas encore implémenté, que j'implémente et que je dois tester tout au long de la vie de ma branche.

Vous ne pouvez pas écrire un test qui induit le cas d'échec suspecté?

Dans la plupart des cas, vous devriez pouvoir ajuster votre flux de travail afin de ne pas apporter ces modifications aux fichiers de votre référentiel. Ces fichiers qui sont modifiés localement doivent être ajoutés au mécanisme d'ignorance de votre projet et ne pas être dans le référentiel. Dans certains cas, vous continuerez à apporter des modifications temporaires que vous ne souhaitez pas mettre dans le référentiel. Pour ceux-ci, ajoutez une séquence spéciale comme: XXX, et ajoutez un hook de pré-validation qui rejette les validations qui y figurent encore.

Le contrôle de version doit contenir le code et la configuration nécessaires à la création de l'application.

Cela signifie que:

• Les éléments temporaires qui ont été introduits pendant un court laps de temps (le temps nécessaire pour localiser l'emplacement d'un bogue ou pour expérimenter une fonctionnalité d'une langue, par exemple) ne devraient pas être dans un contrôle de version: conservez-le jusqu'à ce que vous en ayez besoin , puis supprimez-le simplement lors de la validation .

• Les fichiers locaux propres à une machine particulière peuvent être conservés dans une branche.

  J'éviterais de les garder juste localement, car c'est trop pénible de refaire tout ça quand votre ordinateur portable est volé ou qu'un virus vous oblige à réinstaller le système d'exploitation (et d'ailleurs, vous constatez que votre dernière sauvegarde a été effectuée il y a deux ans) .

  D'un autre côté, soyez prudent avec la structure des fichiers: la configuration locale est OK, jusqu'à ce qu'elle devienne écrasante, et vous oblige à faire un seul changement dans chaque fichier de chacun des 42 développeurs participant au projet.

  Surveillez l'opportunité de supprimer les particularités entre les machines. Cela peut signifier:

  • Donner un accès à un serveur SQL dev pour remplacer les instances locales sur les machines des développeurs,

  • Utiliser des services de distribution de packages comme Pypi ou npm pour les packages publics et leurs homologues privés pour les packages internes,

  • Demandez aux membres de l'équipe d'installer les mêmes versions de logiciels,

  • Rendez les mises à jour logicielles aussi transparentes que possible,

  • Ou permettre de déployer le système d'exploitation et les logiciels nécessaires sur une machine en un clic (plus le temps pour chaque développeur d'installer son Vim vs Emacs préféré, Chrome vs Firefox, etc.)

Alors:

Fichiers de projet. Il peut être nécessaire de modifier les chemins afin de refléter la disposition sur le PC actuel.

Pourquoi ne pas utiliser la même disposition sur chaque PC? Les chemins au sein du projet doivent être relatifs au fichier de projet, ce qui signifie que peu importe où se trouve le projet. Les versions des logiciels et des bibliothèques doivent être identiques pour éviter les bogues cryptiques qui n'apparaissent que sur certaines machines et sont impossibles à reproduire pour les autres membres de l'équipe.

Exemple:

Dans un projet créé avec Visual Studio, vous pouvez trouver:

• Les fichiers eux-mêmes. Les chemins étant relatifs, peu importe que sur ma machine, le projet soit localisé pendant H:\Development\Hello World Project\que d'autres membres de l'équipe l'ont extrait C:\Work\HelloWorld\.

• Les dépendances, c'est-à-dire les bibliothèques tierces et internes. Les deux types doivent être gérés par NuGet, ce qui rend toutes les discussions liées aux conflits obsolètes. Si vous n'avez pas la même version de la bibliothèque que moi, demandez à NuGet de mettre à jour les dépendances. Aussi simple que ça (quand ça marche bien, ce qui n'est pas toujours le cas).

  Notez qu'il est crucial de conserver également les bibliothèques internes dans un NuGet privé. Avoir un tas de bibliothèques stockées dans un dossier partagé ou envoyées par e-mail à travers une équipe conduit à l'anarchie et aux serveurs CI dépressifs.

• Les paramètres. Il est crucial que l'équipe partage les mêmes paramètres. Si la moitié de l'équipe décide de traiter les avertissements comme des erreurs et la moitié de l'équipe conserve les avertissements tels quels, les membres de la première partie de l'équipe passeront leur temps à supprimer les avertissements générés par les développeurs de la deuxième partie de l'équipe.

• Les paramètres liés aux utilitaires. Celles-ci sont délicates, car certains membres de l'équipe peuvent avoir installé certains utilitaires, tandis que d'autres ne l'ont pas fait.

  Il est fortement recommandé d'installer le même ensemble d'outils. Si certains programmeurs veulent utiliser StyleCop, mais d'autres non, l'équipe ne fera pas le travail. Si certains utilisent des contrats de code mais d'autres pas, ils auront les mêmes problèmes.

Makefiles. Par exemple, l'optimisation peut devoir être désactivée pendant le débogage, mais pas pour le serveur CI.

Gardez plusieurs makefiles dans le contrôle de version. Il n'est pas rare de créer une version de débogage sur le serveur CI et de la pousser vers un client qui rencontre un bug délicat.

Hacks laids sales. Par exemple, retournez 7 au milieu d'une fonction, afin de tester quelque chose, selon la fonction, et soupçonné de casser à la valeur 7.

J'éviterais un tel code en premier lieu. Pour tester quelque chose, utilisez des tests unitaires. Si cela prend vraiment quelques secondes pour échanger du code à des fins de débogage , faites-le, mais vous supprimerez ce code dans quelques minutes de toute façon, il n'est donc pas nécessaire de le valider.

Comme vous le décrivez, vous devez écrire un test. Par exemple, si vous voulez être sûr que:

class TemperatureConverter
{
    public int CelsiusToFahrenheit(int temperature)
    {
        ...
    }
}

lève une exception lorsqu'il temperatureest inférieur à AbsoluteZeroconstant, vous ne devez pas jouer avec le code lui-même. Créez plutôt un test unitaire qui:

• auto-documenter votre code,
• augmenter la fiabilité de votre code,
• s'assurer que les responsables peuvent s'appuyer sur des tests de régression lors de la modification de la méthode ci-dessus,
• servir aux autres développeurs de votre équipe qui peuvent avoir besoin de faire le même test.

Nous utilisons des @@commentaires dans le code pour indiquer tout ce qui n'est pas tout à fait prêt, à des fins de test, etc.

De cette façon, nous pouvons nous engager, les collègues n'ont pas à attendre trop longtemps pour se synchroniser et peuvent voir où il y a encore du travail en cours (par exemple, comprendre pourquoi une pièce ne fonctionne pas encore complètement).

Nous effectuons une recherche globale pour @@éviter tout `` reste '' avant d'entrer dans les étapes finales des tests bêta, etc.

En utilisant cette discipline, je ne vois aucune raison de ne pas simplement m'engager. De cette façon, nous n'avons pas de branches distinctes et un seul «protocole» supplémentaire à suivre.

Comme avantage supplémentaire, ces tâches (généralement de petites choses) sont toujours dans le code. Le développeur qui y travaille peut les parcourir rapidement et il n'est pas nécessaire de conserver des listes distinctes.
Vous savez comment se déroule le développement: vous travaillez au même endroit, mais vous utilisez constamment votre esprit comme une pile (« je devrais changer cela là-bas quand j'aurai fini ici »). Le simple @@fait de noter une remarque rapide empêche le débordement de la pile.

J'utilise même @@namepour indiquer les problèmes dont je dois discuter avec «nom».

2 solutions HAMSTER:

• Vous pouvez utiliser un hook de pré-validation pour vérifier votre code pour certains mots-clés inhabituels comme HAMSTER. Ne laissez pas les gens commettre du code HAMSTERed et utilisez-le chaque fois que vous faites des hacks sales.

• Une autre option par exemple en C est d'utiliser #ifdef HAMSTER, alors le code ne s'exécutera que sur votre machine où vous avez un indicateur de compilateur HAMSTER.

Nous mettons tout sous contrôle de source nécessaire pour construire et tester les binaires actuels et comprendre pourquoi les choses ont été conçues / implémentées / testées telles qu'elles sont.

Cela vaut même pour les pointes http://www.extremeprogramming.org/rules/spike.html , comme celles que vous avez décrites; nous les hébergeons simplement dans un sous-arbre différent.

Voici un certain nombre de solutions que j'utilise moi-même occasionnellement dans diverses circonstances, et que vous pourriez considérer utiles lorsqu'elles sont appliquées à vos propres flux de travail:

1. Branches légères qui peuvent être écrasées.

   Git est super à ça. Piratez une branche, effectuez de nombreuses validations, puis rebasez ou écrasez votre historique pour supprimer le bruit.

2. Utilisez une file d'attente de correctifs au-dessus de votre SCM.

   Je me retrouve souvent à utiliser StGit pour faire flotter les correctifs vers le haut de ma branche actuelle. Lorsque j'ai terminé avec la branche, je peux les retirer de la pile avant de les fusionner, les écraser ou les rebaser, ou les fusionner dans la base de code principale si je veux les garder.

3. Utilisez RCS comme SCM "hors bande" pour de petites expériences.

   Parfois, vous voulez simplement vérifier un fichier en cours de manière jetable, sans avoir à nettoyer l'historique par la suite. J'utilise généralement RCS pour cela à l'intérieur de Git ou SVN. Je dis à Git d'ignorer les artefacts RCS, de vérifier mon travail en cours dans RCS, et quand j'aime les résultats, je lance simplement les *,vfichiers ou tout le répertoire RCS. N'exécutez pas git clean -fdxou similaire jusqu'à ce que vous ayez engagé votre travail dans votre "vrai" SCM, ou vous le regretterez.

4. Cachettes nommées.

   Un autre Git-ism, mais pratique: git stash save --include-untracked <some-cool-title>peut être utile à la rigueur. Vous pouvez enregistrer, faire apparaître et appliquer les travaux en cours de cette manière, et afficher vos différents points de contrôle via git stash listou git reflog --all. D'autres SCM peuvent avoir des fonctionnalités similaires, mais votre kilométrage peut varier considérablement avec celui-ci.

Une partie de ce code temporaire n'est vraiment qu'une manifestation d'une méthodologie de construction / test / développement incorrecte, et j'espère que leur existence motivera une amélioration future.

Sur git au moins, vous devriez être libre de jouer avec n'importe quel nombre de branches de fonctionnalités jusqu'à ce qu'elles soient prêtes à être fusionnées dans master / trunk.

Le contrôle de version est censé vous aider , et le plus souvent j'apprécie les informations tirées de la façon dont des erreurs (ou peut-être simplement des décisions moins qu'intuitives) ont été faites dans le passé, et prennent des décisions plus éclairées pour le moment.

Je crois que certains systèmes lanceront des avertissements en voyant TODO dans un commentaire, donc

// TODO: remove this hack.

pourrait être tout ce qui est nécessaire si vous pouvez trouver une option pertinente dans une partie de votre environnement de développement, ou simplement coller une sorte de commande grep dans votre fichier de build. Il peut également être possible d'organiser // HACKou de récupérer n'importe quelle chaîne arbitraire.

C'est plus simple que d'organiser votre code d'une manière particulière et d'espérer que les gens se souviendront de ne pas l'utiliser. Il est également plus sûr de suivre les conseils de @gbjbaanb (si vous pouvez vous assurer que tout le monde voit les avertissements!).

Collez tout ce que vous aimez là-dedans parce qu'un jour vous voudrez peut-être voir ce que c'était, et ce sont les jours où vous réalisez ce qu'est vraiment votre SCM.

Il n'est jamais dangereux de mettre du code dans le contrôle de code source.

Chacun des éléments que vous mentionnez doit être sous contrôle de source.