Dois-je conserver le code généré dans le contrôle de source
C'est un débat que je vais prendre une partie en. J'aimerais obtenir plus d'opinions et de points de vue.
Nous avons certaines classes qui sont générés au moment de la construction de gérer DB opérations (dans Ce cas précis, avec Subsonique, mais je ne pense pas que c'est très important pour la question). La production est définie comme une pré-étape de génération dans Visual Studio. Donc, à chaque fois qu'un développeur (ou le fonctionnaire processus de construction) exécute une génération, ces classes sont générées, et ensuite compilées dans le projet.
Maintenant, certaines personnes prétendent que le fait que ces classes enregistrées dans la source de contrôle pourrait causer de la confusion, dans le cas où le code que vous obtenez, ne correspond pas à ce qui aurait été produit dans votre propre environnement.
Je voudrais avoir un moyen de retracer l'histoire du code, même si elle est généralement considérée comme une boîte noire.
Des arguments ou contre-arguments?
Mise à JOUR: j'ai posé cette question car j'ai vraiment cru qu'il y est une réponse définitive. En regardant toutes les réponses, je pourrais dire avec un haut niveau de certitude, qu'il n'existe pas une telle réponse. La décision devrait être prise en fonction de plusieurs paramètres. De lire les réponses ci-dessous pourrait fournir une très bonne ligne de conduite pour les types de questions que vous devriez vous poser lorsque ayant à se prononcer sur cette question.
Je ne sélectionnez pas accepté de répondre à ce point, pour les raisons mentionnées ci-dessus.
- Vous pouvez être intéressé à une question similaire: stackoverflow.com/questions/739391/...
- Je tiens à dire que, dans le cas de Subsonique, il peut être intéressant de garder le contrôle de code source comme un moyen également suivre (un peu) les modifications de base de données facilement, dans le cas où vous n'avez pas d'autre moyen de retracer l'histoire de votre base de données.
- Dans ma pensée, le principal problème est que les différents développeurs de ne pas obtenir le même résultat lors de la génération des classes. La config de génération doit être vérifiée, et donner de la cohérence s'appuie dans tous les environnements de développement.
- Ne sais pas comment faire cela, cependant, je pense que cette question devrait être fermée, comme c'est trop ouvert à l'opinion et à la discussion sans liées étroitement à certains systèmes de contrôle de source ou de certains types de fichiers générés.
- C'est une grande question, mais il est trop opinion pour, DONC comme indiqué par les multiples des réponses contradictoires, et l'OP propre commentaire à cet effet.
Vous devez vous connecter pour publier un commentaire.
Enregistrement dans la source de contrôle est plus d'ennuis que cela vaut la peine.
Que vous avez à faire un commit à chaque fois que vous faites une génération pour qu'elle soit toute valeur.
Généralement nous quittons le code généré( idl, jaxb des trucs, etc) à l'extérieur de contrôle de la source où je travaille et il n'a jamais été un problème
Chaque fois que je veux montrer des changements à une source d'arbre sur mon propre repo, tous les fichiers générés' apparaîtra comme ayant changé et ont besoin de comitting.
Je préfère avoir un nettoyeur de la liste des modifications qui incluent seulement réel des mises à jour qui ont été effectuées, et non l'auto-généré des changements.
Les laisser sortir, et puis, après une construction, ajouter un "ignorer" sur chacun des fichiers générés.
Le mettre dans le contrôle de code source. L'avantage d'avoir l'histoire de tout ce que vous écrivez disponibles pour les futurs développeurs l'emporte sur la douleur mineure de temps en temps la reconstruction après une synchronisation.
Regardons cela de cette façon: avez-vous vérifier vos fichiers de l'objet dans le contrôle de code source? Source généré les fichiers sont de construire des artefacts comme les fichiers objets, des bibliothèques et exécutables. Ils devraient être traités de la même façon. La plupart diront que vous ne devriez pas être la vérification généré les fichiers objets et les exécutables dans le contrôle de source. Les mêmes arguments s'appliquent à la source généré.
Si vous avez besoin de regarder l'historique de version d'un fichier généré, vous pouvez synchroniser de la version historique de ses sources et de reconstruction.
La vérification des fichiers générés de toute sorte dans la source de contrôle est analogue à la base de données de la dénormalisation. Il y a parfois raisons de le faire (généralement pour la performance), mais cette opération doit être effectuée avec le plus grand soin car il devient beaucoup plus difficile de maintenir l'exactitude et de la cohérence une fois les données est dénormalisé.
Je dirais que vous devriez éviter tout ajout de code généré (ou autres objets) à la source de contrôle. Si le code généré est le même pour la donnée d'entrée, alors vous pourriez juste vérifier les versions que vous souhaitez diff et de générer le code à des fins de comparaison.
J'appelle le principe DRY. Si vous avez déjà les "fichiers source" dans le dépôt qui sont utilisés pour générer ces fichiers de code au moment de la construction, il n'est pas nécessaire d'avoir le même code commis "deux fois".
Aussi, vous pouvez éviter certains problèmes de cette façon, si par exemple la génération de code des pauses un jour.
Je ne pense pas que vous devriez les vérifier dans.
Sûrement tout changement dans le code généré sera le bruit des changements entre les environnements, ou des modifications à la suite de quelque chose d'autre, par exemple un changement dans votre base de données. Si votre base de données de scripts de création (ou de toutes autres dépendances) sont dans le contrôle de code source, alors pourquoi avez-vous besoin de les scripts générés ainsi?
Non, pour trois raisons.
Code Source est tout ce qui est nécessaire et suffisant pour reproduire un instantané de votre demande de certains, actuel ou précédent, de point dans le temps - rien de plus et rien de moins. Une partie de ce que cela implique, c'est que quelqu'un est responsable de tout vérifié dans. En général, je suis heureux d'être responsable pour le code que j'ai écris, mais pas le code qui est généré comme une conséquence de ce que j'écris.
Je ne veux pas que quelqu'un puisse être tenté de raccourci d'une compilation à partir des sources primaires en utilisant le code intermédiaire qui peuvent ou peuvent ne pas être à jour (et le plus important est que je ne veux pas accepter la responsabilité.) Et pas il est trop tentant pour certaines personnes, pour se retrouver pris dans un sens processus sur le débogage des conflits dans le code intermédiaire basé sur une partie de construit.
Une fois qu'il est en contrôle de code source, j'accepte la responsabilité pour une. il y, b. il être au courant, et c. qu'il soit fiable intégrable avec tout le reste là-bas. Qui comprend le retirer quand je ne suis plus l'utiliser. Le moins que la responsabilité de la meilleure.
La règle générale est pas, mais si il faut du temps pour générer le code (en raison de DB d'accès, services web, etc.) ensuite, vous voudrez peut-être enregistrer une version mise en cache dans le contrôle de source et de sauver tout le monde la douleur.
Vos outils doivent également être conscients de cela et gérer la vérification de la source de contrôle lorsqu'il est nécessaire, de nombreux outils de décider de vérifier à partir de la source de contrôle, sans aucune raison.
Un bon outil utiliser la version en cache sans le toucher (ni modification du pas de temps sur le fichier).
Aussi vous avez besoin de mettre le grand avertissement à l'intérieur du code généré pour les gens à ne pas modifier le fichier, un message d'avertissement en haut n'est pas assez, vous devez la répéter à chaque dizaine de lignes.
Nous ne stockons pas généré DB code: comme il est généré, vous pouvez l'obtenir à volonté à n'importe quelle version de la source des fichiers. Le stockage, il serait comme le stockage du bytecode ou telle.
Maintenant, vous devez vous assurer que le générateur de code utilisé à une version donnée est disponible! Les versions plus récentes peuvent générer un code différent...
Laisser.
Si vous êtes à la vérification dans les fichiers générés, vous êtes en train de faire quelque chose de mal. Quel mal peut différer, il se pourrait que votre processus de génération est inefficace, ou quelque chose d'autre, mais je ne peux pas le voir jamais être une bonne idée. L'histoire doit être associé à la source des fichiers, pas le générés.
Il crée simplement un casse-tête pour les gens qui finissent en essayant de régler les différends, de trouver les fichiers qui ne sont plus générés par la construction et pour les supprimer, etc.
Un monde de douleur attend ceux qui vérifier dans les fichiers générés!
Il existe un cas particulier où vous souhaitez enregistrer vos fichiers générés: lorsque vous aurez besoin de construire sur des systèmes où les outils utilisés pour générer les autres fichiers ne sont pas disponibles. L'exemple classique de cela, et j'en travailler avec, est Lex et Yacc code. Parce que nous développons un système d'exécution qui a de construire et d'exécuter sur une grande variété de plates-formes et architectures, nous ne pouvons compter que sur les systèmes cibles à avoir des compilateurs C et C++, pas les outils nécessaires pour générer le lexing/analyse du code pour notre définition de l'interface de traduction. Ainsi, quand nous changeons nos grammaires, nous vérifions dans le code généré pour l'analyser.
d'arriver un peu tard ... de toute façon ...
Souhaitez-vous mettre compilateur de fichier intermédiaire dans la source de contrôle de version ?
Dans le cas de la génération de code, par définition, le code source est l'entrée du générateur tandis que le code généré peut être considéré comme des fichiers intermédiaires entre le "réel" de la source et de la construction de l'application.
Donc, je dirais: ne mettez pas de code généré sous contrôle de version, mais le générateur et son entrée.
Concrètement, je travaille avec un générateur de code que j'ai écrit: je n'ai jamais eu de maintenir le code source généré sous contrôle de version. Je dirais même que depuis le générateur atteint un certain niveau de maturité, je n'ai pas eu à observer le contenu du code généré bien que l'entrée (par exemple une description du modèle) changé.
Dans certains projets que j'ai ajouter le code généré au contrôle de code source, mais ça dépend vraiment. Mon guide de base est que si le code généré est une partie intrinsèque du compilateur, alors je ne vais pas l'ajouter. Si le code généré à partir d'un outil externe, comme Subsonique dans ce cas, alors je voudrais ajouter, en cas de contrôle de source. Si vous périodiquement mettre à niveau le composant puis je veux savoir les changements dans la source générée en cas de bugs ou problèmes surviennent.
Autant que le code généré qui doivent être vérifiées dans un scénario du pire est manuellement différenciation de fichiers et de revenir le fichiers si nécessaire. Si vous utilisez svn, vous pouvez ajouter un pre-commit hook dans le svn de refuser la livraison si le fichier n'a pas vraiment changé.
Ça dépend vraiment. En fin de compte, l'objectif est d'être en mesure de reproduire ce que vous aviez en cas de besoin. Si vous êtes en mesure de régénérer vos binaires exactement, il n'est pas nécessaire pour les stocker. mais vous devez vous rappeler que, dans le but de recréer votre truc, vous aurez probablement besoin de votre configuration exacte que vous avez fait en premier lieu, et cela ne signifie pas seulement votre code source, mais aussi de votre environnement, de votre IDE, peut-être même à d'autres bibliothèques, des générateurs ou des choses, dans la configuration exacte (versions) vous avez utilisé.
J'ai un problème dans des projets ont été mise à niveau de notre environnement de compilation vers des versions plus récentes ou même à l'autre des vendeurs, où nous avons été incapables de recréer la même binaires que nous avions avant. C'est une vraie douleur lorsque les binaires pour être deplyed dépendent d'un type de hachage, en particulier dans un environnement sécuritaire, et le recréé les fichiers d'une certaine manière différente en raison de compilateur mises à jour ou quoi que ce soit.
Alors, voulez-vous de stocker le code généré: je dirais que non. Les fichiers binaires ou les résultats qui sont publiés, y compris les outils que vous avez reproduit avec je voudrais stocker. Et puis, il n'est pas nécessaire pour les stocker dans le contrôle de code source, il suffit de faire une bonne sauvegarde de ces fichiers.
Le travail de gestion de la configuration (dont le contrôle de version n'est qu'une partie) est d'être en mesure de faire ce qui suit:
La première assure que quand vous dites au client ou à l'utilisateur final "le bug que vous avez rapporté la semaine dernière est fixe et la nouvelle fonctionnalité a été ajoutée" qu'ils ne viennent pas de retour deux heures plus tard, et de dire "non il n'a pas". Elle fait également en sorte qu'ils ne disent pas "Pourquoi est-il en train de faire X? Nous n'avons jamais demandé de X".
Le second signifie que lorsque le client ou un utilisateur signale un bug dans une version vous il y a un an, vous pouvez revenir à cette version, de reproduire le bug, le réparer, et prouver que c'était votre correction a éliminé le bug plutôt que d'une perturbation de compilateur et d'autres correctifs.
Cela signifie que votre compilateur, bibliothèques, etc doivent également faire partie de la CM.
Alors maintenant, pour répondre à votre question: si vous pouvez faire tous les ci-dessus, alors vous n'avez pas besoin d'enregistrer toutes les représentations intermédiaires, parce que vous êtes garanti d'obtenir la même réponse de toute façon. Si vous ne pouvez pas faire tous les ci-dessus, alors tous les paris sont éteints parce que vous ne pouvez jamais garantie de faire deux fois la même chose et obtenir la même réponse. Ainsi vous pouvez mettre toutes vos .o fichiers sous contrôle de version ainsi.
La bonne réponse est "Ça Dépend". Cela dépend de ce que les besoins du client sont.
Si vous ne pouvez reprendre le code pour une version particulière, et de résister à tout audit externe sans elle, alors vous n'êtes toujours pas sur la terre ferme. En tant que dev, nous devons tenir compte non seulement du "bruit", de la douleur et de l'espace disque, mais le fait que nous sommes chargé de jouer le rôle de générer de la propriété intellectuelle et il peut y avoir des ramifications juridiques. Seriez-vous en mesure de prouver au juge que vous êtes capable de régénérer un site web exactement de la façon dont un client a vu il y a deux ans?
Je ne vous suggère pas d'enregistrer ou de ne pas enregistrer gen avais des fichiers, selon la façon dont vous décidez si vous n'êtes pas en impliquant les Experts en la Matière de la décision que vous êtes probablement tort.
Mes deux cents.
Il y a de bons arguments pour et contre présentées ici.
Pour l'enregistrement, j'ai construit la T4 système de génération dans Visual Studio et notre défaut out-of-the-box en option, le code généré à être archivé. Vous devez travailler un peu plus difficile si vous préférez ne pas vérifier à l'.
Pour moi l'essentiel est de comparaison la sortie générée lors de l'entrée ou du générateur lui-même est mis à jour.
Si vous n'avez pas votre sortie vérifié, alors vous avez à prendre une copie de tout code généré avant la mise à niveau d'un générateur ou de la modification de l'entrée afin de pouvoir la comparer avec la sortie de la nouvelle version. Je pense que c'est assez fastidieux, mais avec contrôlés en sortie, c'est une simple question de comparaison la nouvelle sortie contre le référentiel.
À ce stade, il est raisonnable de se demander "Pourquoi ne vous vous souciez de changements dans le code généré?" (Surtout par rapport à l'objet du code.)
Je crois qu'il y a quelques raisons principales, qui sont venus jusqu'à l'état actuel de l'art, plutôt que de tout problème inhérent.
Vous artisanat manuscrite code mailles étroitement avec le code généré. Ce n'est pas le cas sur l'ensemble des fichiers obj ces jours-ci. Lorsque le code généré des changements, c'est malheureusement très souvent le cas que certains manuscrits de code à modifier pour correspondre. Les gens souvent ne pas observer un degré élevé de compatibilité avec les points d'extensibilité dans le code généré.
Code généré simplement des modifications de son comportement. Vous ne supporteriez pas ce à partir d'un compilateur, mais en toute équité, une au niveau de l'application générateur de code cible un champ différent de problème avec un large éventail de solutions acceptables. Il est important de voir si les hypothèses que vous avez fait sur le comportement précédent sont aujourd'hui brisé.
Vous ne le faites pas confiance à 100% à la sortie de votre générateur à partir d'une version à une autre. Il y a beaucoup de valeur à partir de générateur d'outils, même s'ils ne sont pas construits et entretenus avec la rigueur de votre fournisseur de compilateur. La version 1.0 aurait été parfaitement stable pour votre application, mais peut-être que 1.1 a quelques petits problèmes pour votre cas d'utilisation maintenant. Alternativement, vous pouvez modifier les valeurs d'entrée et de trouver que vous êtes exercisig un nouveau morceau du générateur que vous n'avez pas utilisé avant, peut - être vous être surpris par les résultats.
Essentiellement toutes ces choses viennent vers le bas de l'outil de maturité, la plupart des applications d'entreprise générateurs de code ne sont pas proche du niveau que les compilateurs ou encore lex/yacc niveau des outils ont été pendant des années.
Les deux côtés des valides et des arguments raisonnables, et il est difficile de s'entendre sur quelque chose de commun. Systèmes de Contrôle de Version (Vcs) les pistes les fichiers
les développeurs, et ont l'hypothèse que les fichiers à l'intérieur de VCS sont fabriqués à la main par les développeurs et les développeurs sont intéressés par l'histoire
et le changement entre une révision des fichiers. Cette hypothèse d'égaliser les deux concepts, "je veux obtenir ce fichier quand je fais la caisse." et "je suis
intéressé par la modification de ce fichier."
Maintenant, les arguments des deux côtés pourrait être reformulée comme ceci:
Heureusement, il semble que les deux conditions ne sont pas fondamentalement contradictoires. Avec une extension de l'actuel Vcs, il devrait être possible d'avoir
les deux. En d'autres termes, c'est un faux dilemme. Si nous réfléchissons un moment, il n'est pas difficile de se rendre compte que le problème découle de l'hypothèse selon Vcs maintenez-la enfoncée. Vcs
convient de distinguer les fichiers, qui sont fabriqués à la main par les développeurs, à partir de fichiers qui ne sont pas fabriqués à la main par les développeurs, mais arrive juste à être à l'intérieur
cette VCS. Pour la première catégorie de fichiers, que nous appelons les fichiers source (le code) habituellement, les Vcs ont fait un excellent travail aujourd'hui. Pour cette dernière catégorie, les Vcs ont
pas eu un tel concept pourtant, autant que je sache.
Résumé
Je vais prendre git comme un exemple pour illustrer ce que je veux dire.
git status
ne doit pas afficher les fichiers générés par défaut.git commit
devrait inclure les fichiers générés, comme un instantané.git diff
ne doit pas afficher les fichiers générés par défaut.PS
Git crochets pourrait être utilisé comme une solution de contournement, mais ce serait bien si git prend en charge en mode natif.
gitignore
ne répond pas à notre exigence, pour ignorésles fichiers ne vont pas dans les Vcs.
enter code here
Je plaide pour. Si vous êtes en utilisant un processus d'intégration continue qui vérifie le code, modifie le numéro de build, construit le logiciel, puis les tests, alors il est plus simple et plus facile de ce code comme une partie de votre dépôt.
En outre, il est une partie intégrante de tous les "clichés" que vous prenez de votre dépôt de logiciels. Si c'est une partie du logiciel, alors il devrait faire partie du dépôt.
Je dirais que oui, vous voulez le mettre sous contrôle de code source. À partir d'une gestion de la configuration de point de vue TOUT ce qui est utilisé pour produire un logiciel build doit être contrôlé de sorte qu'il peut être recréé. Je comprends que le code généré peut facilement être recréée, mais un argument peut être faite que c'est pas la même depuis la date/horodateurs seront différentes entre les deux versions. Dans certains domaines, comme le gouvernement, ils exigent beaucoup de temps c'est ce qui est fait.
En général, le code généré n'a pas besoin d'être stockées dans la source de contrôle parce que l'historique de la révision de ce code peut être tracée par l'historique de la révision du code qui les a générés!
Cependant, il semble que l'OP est en utilisant le code généré la couche d'accès aux données de l'application au lieu de le faire manuellement à écrire un. Dans ce cas, je voudrais changer le processus de construction, et d'engager le code source de contrôle, car il est une composante essentielle de l'exécution du code. Cela supprime également la dépendance sur l'outil de génération de code à partir du processus de construction dans le cas où les développeurs ont besoin pour utiliser les différentes version de l'outil pour les différentes branches.
Il semble que le code doit être généré une seule fois au lieu de tout construire. Quand un développeur a besoin d'ajouter/supprimer/modifier la façon dont un objet accède à la base de données, le code doit être généré à nouveau, juste comme faire des modifications manuelles. Cela accélère le processus de construction, permet de manuel optimisations à apporter à la couche d'accès aux données, et l'histoire de la couche d'accès aux données est conservé d'une manière simple.
J'ai (malheureusement) la liquidation de mettre beaucoup de dérivés de sources sous contrôle de code source parce que je travaille à distance avec des gens qui soit ne peuvent pas être pris la peine d'installer un environnement de construction ou qui n'ont pas les compétences nécessaires pour configurer de façon à ce que les dérivés de sources sont construits exactement de la droite. (Et quand il s'agit de Gnu autotools, je suis une de ces personnes me! Je ne peux pas travailler avec trois systèmes différents, chaque de ce qui fonctionne avec une version différente de autotools—et uniquement cette version.)
Ce genre de difficulté est sans doute plus à temps partiel, les bénévoles, les projets open-source que pour des projets rémunérés où la personne qui paie les factures peuvent insister sur un uniforme de l'environnement de construction.
Lorsque vous faites cela, vous êtes essentiellement en s'engageant à la construction de la dérivée des fichiers en un seul site, ou seulement à correctement configuré sites. Votre Makefile (ou autre) devrait être mis en place pour avis, où ils sont en cours d'exécution et devrait refuser de re-tirer les sources, sauf si ils savent qu'ils sont en cours d'exécution à un coffre-fort site de construction.
Absolument avoir le code généré dans le contrôle de source, pour de nombreuses raisons. Je suis en réitérant ce que beaucoup de gens ont déjà dit, mais certaines raisons que je ferais sont
CodeCompileUnit
dans un ordre canonique.Je laisse les fichiers générés hors d'une arborescence source, mais dans une construction séparé de l'arbre.
par exemple de flux de travail est
Il y a probablement de bonnes manières dans Subversion/Mercurial/Git/etc de lier l'histoire de la véritable source des fichiers dans les deux endroits.
Si c'est une partie du code source, alors il devrait être mis dans le contrôle de source peu importe qui ou ce qui l'engendre. Vous voulez que votre contrôle de code source pour refléter l'état actuel de votre système sans avoir à le régénérer.
Semble que il ya très forte et convaincante des avis sur les deux côtés. Je vous recommande de lire tout le haut voté réponses, et ensuite décider quels arguments s'appliquent à votre cas spécifique.
Mise à JOUR: j'ai posé cette question car j'ai vraiment cru qu'il y est une réponse définitive. En regardant toutes les réponses, je pourrais dire avec un haut niveau de certitude, qu'il n'existe pas une telle réponse. La décision devrait être prise en fonction de plusieurs paramètres. Lire les autres réponses, peut fournir une très bonne ligne de conduite pour les types de questions que vous devriez vous poser lorsque ayant à se prononcer sur cette question.