Est-il jamais OK de valider du code non fonctionnel?
Est-ce une bonne idée d'exiger de ne valider que du code fonctionnel?
Cette validation n'a pas besoin de laisser le référentiel dans un état de travail en tant que:
- ... nous sommes aux premiers stades de la conception, le code n'est pas encore stable.
- ... vous êtes le seul développeur du projet. Vous savez pourquoi les choses ne fonctionnent pas. De plus, vous n'arrêtez le travail de personne en validant du code cassé.
- ... le code ne fonctionne pas actuellement. Nous allons y apporter un grand changement. Engageons-nous, afin d'avoir un point sur lequel revenir si les choses tournent mal.
... la chaîne est longue, aucun problème si du code cassé existe dans la branche locale. C'est à dire.
- fichiers locaux
- zone de transit
- s'engage dans la branche locale
- valide dans une branche de fonction personnelle distante
- fusionner avec la branche distante
develop - fusionner avec la branche distante
master - fusionner avec la branche distante
release
... engagez-vous tôt, engagez-vous souvent.
Donc, dans la question liée ci-dessus, la majorité des réponses disent que la validation de code non compilable n'est pas un problème dans les branches locales et de fonctionnalité. Pourquoi? Quelle est la valeur d'un commit rompu?
Ajouté: Il y a quelques commentaires très votés, disant que sur un brach local, on peut faire ce qu'on veut. Cependant, je ne suis pas intéressé par l'aspect technique de la question. J'aimerais plutôt apprendre les meilleures pratiques - les habitudes, que les gens qui ont travaillé de nombreuses années dans l'industrie, ont trouvées les plus productives.
Je suis étonné de la grande quantité de bonnes réponses! Ils m'amènent à la conclusion que je ne suis pas assez habile pour utiliser les branches pour organiser mon code.
L'une des philosophies de branchement (section Développer une stratégie de branchement et une politique de codeline dans Stratégies de branchement SCM avancées - lire aussi Meilleures pratiques Perforce , c'est un pdf mais entre dans d'autres détails) est que vous branchez sur une politique incompatible.
Une politique de codeline spécifie l'utilisation équitable et les enregistrements autorisés pour la codeline, et est le manuel de l'utilisateur essentiel pour la codeline SCM. Par exemple, la politique d'une ligne de code de développement doit indiquer qu'elle n'est pas destinée à être publiée; de même, la politique d'une ligne de code de version devrait limiter les modifications apportées aux correctifs de bogues approuvés. La politique peut également décrire comment documenter les modifications en cours d'enregistrement, quel examen est nécessaire, quels tests sont requis et les attentes de stabilité de la ligne de code après les enregistrements. Une politique est un composant essentiel pour un processus de développement logiciel documenté et exécutoire, et une ligne de code sans politique, d'un point de vue SCM, est hors de contrôle.
(de Perforce Best Practices)
Supposons que vous ayez la version 'branches' (ou 'master') à partir de laquelle une version est construite et 'trunk' (ou 'dev') où les développeurs archivent le code de travail. Ce sont les politiques des succursales. Notant que le "code de travail" fait partie de la politique de la branche "dev", il ne faut jamais commettre de code cassé dans la branche dev. Souvent, il y a des choses telles que les serveurs CI connectés à ces branches et l'archivage de code cassé dans le dev pourrait gâcher la branche de tout le monde et casser la build.
Cependant, il y a des moments où il est approprié d'archiver un code partiel qui ne fonctionne pas. Dans ces cas, il faut créer une branche - une politique incompatible avec le tronc. Dans cette nouvelle branche, on peut décider de la politique ('le code cassé est ok') puis y valider le code.
Il existe une règle simple pour déterminer si une ligne de code doit être branchée: elle doit être branchée lorsque ses utilisateurs ont besoin de politiques d'enregistrement différentes. Par exemple, un groupe de versions de produits peut avoir besoin d'une stratégie d'archivage qui applique des tests rigoureux, tandis qu'une équipe de développement peut avoir besoin d'une stratégie qui autorise des archivages fréquents de modifications partiellement testées. Cette divergence de politique appelle une branche codeline. Lorsqu'un groupe de développement ne souhaite pas en voir un autre
(de Perforce Best Practices)
Sachez que cela provient d'un SCM basé sur un serveur central avec une forte mentalité d'entreprise. L'idée centrale est toujours bonne. On pense souvent à ceux-ci implicitement - vous ne consignez pas de code de développement non testé dans la branche de publication. C'est une politique.
Alors branche, disons que cette branche peut avoir du code cassé et s'en aller.
L'une des philosophies suggérées par Linus Torvalds est que la programmation créative devrait être comme une série d'expériences. Vous avez une idée et suivez-la. Ça ne marche pas toujours, mais au moins vous l'avez essayé. Vous voulez encourager les développeurs à essayer des idées créatives, et pour ce faire, il doit être bon marché d'essayer cette expérience et bon marché pour récupérer. C'est le vrai pouvoir de git commits étant si bon marché (rapide et facile). Cela ouvre ce paradigme créatif qui permet aux développeurs d'essayer des choses qu'ils n'auraient pas pu faire autrement. C'est la libération de git.
Oui, tant qu'il ne s'agit pas d'une branche de publication.
Dans les branches personnelles, tout se passe et peut ensuite être jeté si l'expérience n'a pas fonctionné. C'est l'un des principaux avantages du DVCS: liberté
La valeur de la validation du code cassé?: collaboration et expérimentation
Oui c'est OK et c'est quelque chose que je fais beaucoup.
Le point de commettre du code non compilable (dans les branches au moins) est que parfois votre code est un travail en cours, mais que le travail effectué jusqu'à présent mérite d'être sauvegardé et/ou partagé avec d'autres
Mes pratiques sont:
- écrire d'abord les tests
- les validations wip (work-in-progress) sont bonnes
- engager souvent (plusieurs en une journée) et tôt (enregistrer les étapes de travail)
- Poussez après chaque validation (au cas où vos disques durs plantent/le bus vous frappe).
- toujours travailler d'abord dans les succursales
- lorsque cela est possible, fusionnez uniquement le code de travail à maîtriser
- rebase interactif dans git pour écraser les wips avant la fusion principale
Le problème principal, et peut-être celui que vous abordez, est lorsque vous avez une fonctionnalité qui fonctionne essentiellement et qui est absolument nécessaire à l'entreprise (et doit donc être en `` maître '') mais qui a des tests qui échouent. Une option ici peut être de faire un test en attente qui vous permet d'avancer pour l'instant. Cependant, cela présente un danger car le test peut ne jamais être corrigé et il peut définir un modèle dans d'autres domaines de simplement "suspendre" les tests brisés au lieu de les corriger.
Une autre option serait d'utiliser et de déployer temporairement la branche. Cela peut aider dans certaines situations mais n'est généralement pas recommandé et n'est pas durable.
La meilleure option est peut-être d'adopter une approche plus professionnelle du développement logiciel et de vraiment exiger des tests de travail pour tout code validé. C'est souvent la partie "difficile" du développement logiciel, pas le codage que beaucoup de gens imaginent. Une meilleure approche nécessitera probablement de meilleures estimations initiales, l'allocation des ressources, la définition des priorités, etc. plus, pendant le développement Agile, en accordant suffisamment de temps et en utilisant suffisamment de discipline pour résoudre les problèmes à la fois au moment où ils surviennent et pendant les sessions de préparation.
Concentrez-vous sur ce que signifie "fait" - cela signifie que le code ET les tests sont écrits, ont été refactorisés et fonctionnent. Si vous entendez des commentaires tels que "la plupart du temps terminé, il suffit d'écrire/corriger/refactoriser les tests, alors ce n'est PAS fait. Dire qu'une fonctionnalité est effectuée sans qu'elle soit techniquement complète est l'une des erreurs les plus courantes des programmeurs juniors.
La valeur de toute validation, rompue ou non, est que le code est validé sur un serveur. Dans les environnements professionnels, ce serveur est sécurisé, redondant et exécute des sauvegardes. Si je travaille toute la journée, la validation est une forme de s'assurer que mon code survit quoi qu'il arrive à ma machine locale. Les disques durs meurent. Les ordinateurs portables se perdent ou sont volés. Des sauvegardes du serveur de référentiel seront disponibles même si le bâtiment brûle.
Pensez-y de cette façon. En tant que développeur, l'une des choses les plus perturbantes que vous puissiez faire est d'empêcher d'autres développeurs de votre équipe de travailler sur leurs tâches.
La philosophie de n'engager que du code de travail vient des équipes de développement travaillant sur le même tronc unique dans le référentiel. Cela peut sembler de la folie maintenant, mais il y a 10 ans, c'était la façon de travailler normale. Une branche apparaîtrait lorsque vous vouliez créer une version stable, mais l'idée d'un développeur travaillant dans une branche pour implémenter une nouvelle fonctionnalité était presque inconnue.
Si votre environnement signifie que vos validations n'affectent pas immédiatement les autres développeurs, effectuez-les souvent. cela vous donne plus de sécurité dans votre code, ce qui facilite la restauration d'une erreur de code et de nombreux systèmes de contrôle de source vous offrent une certaine protection du code pour le code validé (mais pas tous).
Maintenant, assurez-vous que vos fusions avec des branches partagées avec d'autres développeurs fonctionnent, et que tout code que vous promouvez à ce niveau compile, réussit tous les tests unitaires et autres vérifications d'intégrité en équipe ... c'est un peu essentiel si vous ne voulez pas continuez à acheter la bière au pub ...
Avant de commencer à devenir dogmatique sur la façon de travailler avec votre contrôle de version, il convient de réfléchir à pourquoi vous travaillez avec le contrôle de version.
S'engager dans le contrôle de version gèle l'état de votre code pour référence future - tout le reste est hors de cela. Regarder les différences et créer des correctifs, c'est simplement voir comment le code a changé entre les instantanés. Les branches et les balises ne sont que des moyens d'organiser des instantanés. Partager du code avec d'autres développeurs, c'est simplement les laisser regarder un instantané particulier.
Quand faut-il s'engager? Lorsqu'il y a une chance raisonnable, vous regarderez à l'avenir l'état de votre code (ou le message de validation expliquant un changement).
Git vous offre une grande flexibilité quant à la façon d'organiser vos instantanés. Il n'y a pas de référentiel central, vous pouvez donc partager votre code avec d'autres développeurs sans pousser votre état vers le référentiel "principal". Vous pouvez facilement créer, fusionner et supprimer des branches pour isoler les détails d'un ensemble d'états du récit du code principal. Vous pouvez valider localement, pour vous aider à annuler un suivi de votre développement actuel, puis regrouper le tout en un seul commit avant de le pousser pour que les autres le voient. Vous pouvez étiqueter des révisions spécifiques afin qu'elles soient faciles à trouver plus tard.
BAISER . Ce qui fonctionne le mieux pour un seul développeur aux premiers stades de développement d'un petit projet va être complètement différent de ce que vous devez faire lorsque vous avez une centaine de développeurs travaillant sur un système critique vieux de dix ans. Dans tout processus de développement logiciel, vous devez éviter de créer des artefacts inutiles simplement parce que quelqu'un d'autre vous a dit de le faire.
Créer/libérer des branches
Vous ne devez jamais délibérément valider du code cassé dans une branche de génération. Toute branche faisant l'objet d'une intégration continue ou à partir de laquelle des versions ou des builds quotidiennes sont effectuées doit toujours être dans un état potentiellement libérable.
Autres succursales: sauvegardez souvent l'état
Pour les branches privées ou fonctionnelles, les objectifs sont souvent différents. Un enregistrement fréquent du code (qu'il fonctionne ou non) peut être souhaitable. En règle générale, vous souhaiterez vous engager à tout moment pour revenir à l'état actuel.
Considérez ces exemples où l'état enregistré offre un avantage significatif:
- Vous pouvez effectuer une validation juste avant d'exécuter une recherche et remplacement globale afin de pouvoir restaurer votre arborescence en une seule opération si les choses tournent mal.
- Vous pouvez effectuer une série de validations intermédiaires tout en refactorisant un morceau de code complexe afin de pouvoir bissecter ou rembobiner si vous finissez par casser quelque chose dans le processus.
- Vous pouvez effectuer une validation, démarrer une nouvelle branche ou créer une balise lorsque vous souhaitez essayer quelque chose d'expérimental tout en étant en mesure de revenir à tout moment à l'état de l'arborescence de travail actuelle.
Je ne pense pas que ce soit OK de valider du code cassé.
Ce qui se passe si
Un correctif urgent est requis. La base de code est dans un état cassé. Vous êtes obligé de revenir en arrière, de corriger et de déployer.
Quelqu'un d'autre commence à travailler dans la même branche sans savoir que vous avez commis un code cassé. Ils pourraient chasser un "hareng rouge" en pensant que leurs changements ont cassé quelque chose.
Vous décidez de quitter l'entreprise, de partir en vacances ou de ne pas pouvoir venir travailler pour une raison quelconque. Vos collègues devront creuser profondément pour trouver ce qui est cassé et pourquoi il a été commis dans un état cassé.
Quelqu'un déploie votre "code cassé"? Cela peut être un "jeu terminé" si vous travaillez avec des données personnelles ou sur un fournisseur de paiement.
Répondre à @WarrenT
Je suis d'accord avec vous que dans un monde idéal où tout le monde travaille dans une branche de fonctionnalité, la validation de code non fonctionnel pourrait fonctionner. J'ai travaillé sur de grands projets et même dans certains cas, plusieurs personnes ont dû travailler dans une même branche de fonctionnalités. J'ai également vu des gens commettre du code "ne fonctionnant pas" dans la branche principale parce que la sortie était dans des semaines et ils prévoyaient de le réparer le lendemain. Toutes ces choses sont candidates à un désastre et je crois fermement qu'elles doivent être évitées à tout prix.
La validation d'une base de code cassée est acceptable tant qu'elle est locale.
Pourquoi?
- Il est essentiel d'utiliser la validation comme point de sauvegarde dans votre développement
- Il vous montre un schéma de pensée utilisé lors du développement du produit.
- Il ne rompt pas la collaboration.
Cependant, lorsqu'il y a une équipe de programmeurs, la philosophie de la maison de programmation est primordiale et remplace les comportements de validation individuels. Certaines maisons de programmation décident de consigner tous les progrès tandis que d'autres décident de ne valider que du code qui résout une fonctionnalité. Dans ce cas, la valeur (cost, du point de vue de la gestion logicielle) d'un commit rompu est désastreuse:
- le temps consacré à d'autres fonctionnalités est désormais consacré à corriger les erreurs.
- la coupe de développement n'est pas respectée ...
- le produit n'est pas expédié à temps
D'autres points peuvent être ajoutés à ces trois cascadant leurs effets de manière exponentielle dans un effondrement de la société ... bien sûr, cela doit être un effet de la validation habituelle chronique d'un mauvais code.