Quand dois-je effectuer le premier commit sur le contrôle de source?
Je ne sais jamais quand un projet est suffisamment avancé pour s'engager d'abord dans le contrôle de code source. J'ai tendance à différer la validation jusqu'à ce que le projet soit "terminé", et j'engage principalement les fonctionnalités à partir de ce moment. (Je n'ai pas fait de projets personnels suffisamment grands pour avoir un cadre de base trop grand pour cela.) J'ai le sentiment que ce n'est pas la meilleure pratique, bien que je ne sois pas sûr de ce qui pourrait mal tourner.
Disons, par exemple, que j'ai un projet qui consiste en un seul fichier de code. Il faudra environ 10 lignes de code standard et 100 lignes pour que le projet fonctionne avec des fonctionnalités extrêmement basiques (1 ou 2 fonctionnalités). Dois-je d'abord m'enregistrer:
- Le fichier vide?
- Le code passe-partout?
- Les premières fonctionnalités?
- À un autre moment?
De plus, quelles sont les raisons de s'enregistrer à un moment précis?
Vous devez vous engager dès que vous avez terminé une "unité" sensible.
Qu'est-ce qu'une unité? Cela dépend de ce que vous faites; si vous créez un projet Visual Studio, par exemple, validez la solution juste après sa création, même si elle ne contient rien.
À partir de là, continuez à vous engager aussi souvent que possible, mais n'engagez toujours que les "unités" terminées (par exemple les classes, les configurations, etc.); cela vous facilitera la vie en cas de problème (vous pouvez annuler un petit ensemble de changements) et réduira la probabilité de conflits.
En ce qui me concerne, votre dépôt de contrôle de source fait partie de la configuration de base du projet, donc je m'engage juste après avoir généré mon projet vide.
Hier
... à défaut, si vous ne pouvez pas voyager dans le temps ...
(peut-être que votre voiture ne peut pas atteindre 88 mph, ou votre condensateur de flux vient de casser)
Maintenant
Les nouveaux projets devraient être commis sur le sang, c'est fou de ne pas le faire, et les systèmes DVCS contemporains viennent de supprimer toutes les excuses possibles pour éviter les commits: git init . ; git add * ; git commit -m initial-commit maintenant, avant qu'il ne soit trop tard, comme c'est peut-être déjà le cas.
Une question plus sensée et discutable aurait pu être: "Quand dois-je fusionner mes engagements sur un partagé contrôle de source sur un géré par l'équipe référentiel sur un projet établi? " (notez que les adjectifs, les adjectifs sont importants) Et j'ai le sentiment que la plupart des autres réponses essaient de répondre à cela.
Votre branche personnelle doit être engagée comme une folle , au moins ne fois par jour, avant le coucher. Vous pourriez simplement vous réveiller le lendemain matin et découvrir que vous n'aviez aucune idée de ce que vous faisiez, la nuit précédente. Le VCS devrait vous couvrir contre cela, et avoir la possibilité de revenir à une sous-version-d'une-sous-version très récente qui se compile bien, fonctionne correctement et/ou passe des tests peut être votre meilleure option.
Je dirais s'engager dès que possible. Le but principal du contrôle de source est de vous permettre de revenir en arrière en cas de problème, et cela résonne avec la pratique "commit tôt et souvent".
Personnellement, mon premier commit ne contient généralement que le fichier . Gitignore (ou équivalent) avec quelques filtres dont je sais qu'il sera nécessaire, comme *. Py [co] for Python. La configuration de base du projet et/ou le premier prototype le plus simple est ce qui suit habituellement.
Le premier commit peut être un fichier README avec aussi peu qu'un résumé de ligne du projet, ou suffisamment d'informations sur le premier jalon du projet. Les sujets généraux peuvent également inclure:
- Introduction
- Description du projet
- Structure du projet
- Conventions de codage
- Instructions sur la façon de:
- construire
- tester
- déployer
- Problèmes connus et solutions
- liste de choses à faire
- Conditions d'utilisation
La pratique consistant à mettre à jour le README avant d'apporter des modifications à un projet est également appelée Readme Driven Development et vous permet de réfléchir aux changements avant d'investir du temps dans ces changements.
Quiconque souhaite contribuer ou utiliser ce logiciel commencera alors avec le README.
Si vous avez fait un travail que vous ne voudriez pas perdre, il devrait être dans votre système de contrôle de source.
Cela s'applique certainement aux systèmes distribués comme Git. Si vous utilisez un système centralisé, et la seule façon de consigner quelque chose est de le rendre visible à tout le monde, vous pourrait voulez vous retenir - ou vous pourriez envisager de configurer votre propre référentiel git local et de le soumettre au système centralisé lorsque vous êtes prêt.
Ma règle d'or consiste à archiver une fois mon fichier de solution (ou tout autre élément de script de génération) terminé, même s'il contient quelques fichiers vides. C'est une bonne pratique lorsque plus d'une personne travaille sur le projet. Ce fichier a tendance à avoir les pires problèmes de fusion au départ, car les gens ajoutent des choses au projet, les besoins sont donc engagés tôt et souvent.
Même si vous êtes le seul à travailler sur le projet et qu'il n'a qu'un seul fichier, je trouve plus facile de suivre le même flux de travail et de garder la pensée du problème à portée de main.
Pas sûr si cela a été mentionné.
Mais assurez-vous que ce que vous engagez s'exécute/compile! Donc pas d'erreurs de syntaxe, etc.
Rien de plus frustrant que de retirer du code cassé.
Juste avant de faire quelque chose de stupide.
Pour ceux d'entre nous sans pouvoirs magiques, cela signifie peu et souvent.
Si vous travaillez seul, faites-le chaque fois que vous prenez un verre ou autre chose.
Si vous travaillez en équipe, vous devez probablement vous assurer que la chose se compile, de sorte que si quelqu'un d'autre arrive au plus tard, il n'obtiendra pas un sac d'erreurs. Mais à part ça, autant que vous le pouvez.
Un autre point de vue plus lié aux tests logiciels (approche TDD) serait de s'engager dès que vous auriez de nouveaux cas de tests en vert. Cela signifierait que vous avez terminé une nouvelle "unité" de code.
Environ 2 à 3 heures après le début du projet.
Je rigole. Il n'y a pas de bonne réponse qui convienne à toutes les situations. Tout d'abord, si vous avez un système de contrôle de version distribué (comme git ou Mercurial), alors vous engager dans votre dépôt local ne préservera pas vos données en cas de panne catastrophique. Mais un dépôt à distance privé peut vous coûter de l'argent, par exemple sur github. Vous conserverez l'historique des validations, mais d'après mon expérience, vous n'en aurez pas besoin tant que votre projet ne sera pas un peu avancé.
De plus, vous ne voulez probablement pas trop de désabonnement au début, surtout si vous déplacez des fichiers. Commettre des changements sera un fardeau, même s'il n'est que petit. Vous pouvez même décider de jeter la chose. Mais si vous perdez des modifications qui ne sont pas faciles à reproduire, vous manquerez d'avoir effectué une copie de sauvegarde et les systèmes de contrôle de version constituent des systèmes de sauvegarde extrêmement précieux.
De nos jours, certaines personnes utilisent DropBox ou similaire pour stocker leur code. Cela peut être un bon compromis au début d'un projet, car la mise en place ne nécessite aucun effort. C'est cependant une habitude barbare dans le développement de logiciels sérieux, surtout si plusieurs personnes touchent le code en même temps.
Donc, j'ai tendance à mettre en place un contrôle de version chaque fois que j'ai quelque chose de précieux, c'est-à-dire non trivial à répliquer. La valeur est subjective (et dépend de ses capacités), vous devrez donc faire votre propre jugement. À ce stade, je stocke un deuxième dépôt sur un disque externe, ou sur github si c'est un projet public ou mon compte payant le tiendra.
Beaucoup de gens ont déjà répondu "tout de suite", et je suis d'accord à 100%. J'aime aussi suggestion de Xion pour commencer avec les motifs d'ignorance du VCS (i. E. .gitignore ou équivalent).
Je suppose qu'il est à peu près convenu qu'il n'y a pas d'inconvénients aux commits précoces. Je voudrais ajouter des avantages:
- Vous êtes moins susceptible de commettre des éléments que vous avez choisi de jeter, mais cela persiste. Quand je commence un nouveau développement, je code et je discute rapidement des trucs, et quand j'ai validé plus tard, quand il y a déjà un tas de fichiers, j'ai accidentellement validé des trucs seulement pour les supprimer lors du prochain commit. Ceci, contrairement aux petits ou même vides commits, est un vrai bruit dans l'histoire.
- Si vous êtes un type systématique et que vous avez des premières étapes typiques dans vos projets, les avoir comme points de validation peut être instructif pour vous ou pour d'autres, et cela pourrait même fournir une opportunité de vous dériver à un certain point et de créer un talon de projet réutilisable. J'ai travaillé sur des projets basés sur Maven où cela était utile (car lors de la mise en place d'un projet Maven, certaines petites premières étapes peuvent déjà définir une base assez importante, et bien que ces étapes ne soient pas très utiles pour faire , ils peuvent nécessiter suffisamment réflexion pour garantir la réutilisation).
Lorsque je démarre un nouveau projet, je commence généralement par le valider avant d'ajouter du code. Une règle générale que j'ai toujours suivie est la suivante: si votre PC tombe en panne et efface toutes vos données, quel code préféreriez-vous ne pas avoir à écrire de la mémoire. Il y a dix ans avant TDD et une meilleure pratique de programmation, j'étais assez optimiste sur ce dont je pouvais me souvenir. Maintenant, j'ai tendance à être plus prudent. Comme beaucoup d'autres affiches l'ont dit, engagez-vous tôt et engagez-vous souvent. Vous ne perdez rien en le faisant.
Je travaille seul la plupart du temps, je dois donc avouer que je me relâche, mais je m'engage généralement avant de rentrer chez moi. De cette façon, si je n'arrive pas demain, mes collègues pourront reprendre là où je me suis arrêté.
J'utilise actuellement Tortoise/SVN au travail.
Commit le projet vide immédiatement. Continuez à vous engager plusieurs fois par heure que vous passez à travailler sur le projet. Validez même si le code ne compile pas. Je marque ces commits avec "WIP" dans le massage de validation pour en garder la trace.
J'ai également un script qui valide automatiquement tous mes projets toutes les 10 minutes dans un dépôt de sauvegarde, au cas où j'oublierais de valider manuellement. Appelons cela mon tampon d'annulation soutenu par le cloud.
Archiver (aka. Poussez ) le projet vers un référentiel d'équipe lorsque vous avez besoin de votre équipe pour voir votre code. Ce qui est probablement avant que votre code ne soit prêt à être vu par votre équipe, si vous êtes comme moi.
Si vous voulez être gentil avec votre équipe, squash vos commits avant de les pousser au repo de l'équipe.
Cela peut dépendre du VCS que vous utilisez.
Avec Git, je valide un répertoire vide (ou avec un fichier README) presque vide. Le fait est que je peux revenir en arrière et réinitialiser ma branche à cet état vide si je veux recommencer complètement alors que je suis encore au début du processus de développement (avant de pousser en amont). Je voudrais ensuite valider mes fichiers "générés" (par exemple, la solution Visual Studio). Ensuite, lorsque je coderai réellement, je commencerai à valider chaque unité comme vous le feriez normalement.
Avec SVN, vous poussez en amont avec chaque commit afin de ne pas vraiment avoir le luxe de recommencer comme vous le faites avec Git. Dans ce cas, il peut ne pas être avantageux de s'engager tôt si vous pensez que vous allez effectuer une refonte majeure au début du processus. Cela dépendra du codeur.
J'ai parcouru tous les articles et je pense que nous avons déjà beaucoup de bonnes solutions mais je voudrais partager ma méthodologie avec vous.
Tout en travaillant sur la création de framework (à partir de zéro), de nombreux changements vont avoir lieu pour chaque module jusqu'à ce que le module soit terminé ou finalisé. J'ai donc toujours 2 emplacements, l'un est nommé DYNAMIC et l'autre est STATIC. Lorsque des modifications sont en cours et que le framework n'est pas encore finalisé, il a été validé dans l'emplacement DYANMIC et une fois qu'il est terminé et finalisé, je le déplace vers l'emplacement STATIC. J'ai donc un contrôle de source complet.
Merci
Habituellement, je m'enregistre chaque fois que j'ajoute quelque chose de nouveau, mais j'essaie de séparer les choses dans des validations discrètes.
Cela signifie que si j'ajoute une nouvelle dépendance, j'effectue les modifications jusqu'à ce qu'elles soient compilées, ou qu'elles soient suffisamment grandes pour qu'il soit temps de les refaire à partir de zéro. Si j'ai une tâche plus importante, j'essaie de valider plusieurs fois, quand cela a du sens (une fois par fonction, chaque fois que je la compile et l'exécute avec succès, etc.).
Je m'engage également lorsque je veux un point de sauvegarde (c'est-à-dire "si ce que j'essaie maintenant ne fonctionne pas ou devient trop compliqué, je veux revenir au code tel qu'il est maintenant", ou quand quelqu'un me demande de laisser tomber ce que je suis faire et résoudre un problème urgent).
Si vous utilisez un système de contrôle de source centralisé, vous ne pouvez pas valider arbitrairement pour les points de sauvegarde, car une validation qui ne compile/ne fonctionne pas affecte tout le monde dans votre équipe.
Habituellement, lorsque je commence à ajouter du code passe-partout (par exemple, ajouter une nouvelle webapp dans un site Web Django), je valide toutes les opérations que je fais.
Si je suis un didacticiel pour générer/écrire du code, j'utilise des noms d'étape dans le didacticiel pour les messages de validation. De cette façon, je peux différencier les révisions et voir ce qu'a fait une étape du didacticiel, à tout moment ultérieur.
Disons, par exemple, que j'ai un projet qui consiste en un seul fichier de code. Il faudra environ 10 lignes de code standard et 100 lignes pour que le projet fonctionne avec des fonctionnalités extrêmement basiques (1 ou 2 fonctionnalités).
Cela dépendrait de la difficulté à ajouter des éléments:
s'il était trivial d'ajouter le code de la plaque de la chaudière, je l'ajouterais et je m'engagerais juste avant de commencer avec l'autre code (de cette façon, si je fais une erreur ou si j'introduis un bug bizarre plus tard, je peux simplement revenir au code du passe-partout et commencer encore).
Si le code n'était pas trivial, je m'engagerais chaque fois que j'ajouterais quelque chose de nouveau (n'importe où entre deux lignes de code modifiées, à une centaine environ).
Avec n'importe quelle application, vous allez passer du temps à concevoir les composants. Vous devez connaître, approximativement ou en détail, vos espaces de noms, projets, références externes, bibliothèques tierces, etc.
Si vous faites partie d'une équipe, je suggérerais à votre responsable, ou à la personne choisie, de créer le projet de base, d'obtenir les dépendances définies et de vérifier ce squelette (fondation sur laquelle votre projet sera construit).
Vous devez également vous assurer que vos branches de tâche, de libération, de tronc, etc. sont spécifiées avant l'enregistrement afin que votre processus soit solide.
Si vous travaillez sur une nouvelle "tâche" pour un projet qui est déjà en cours et que vous êtes dans votre propre branche de tâches, effectuez vos vérifications nocturnes afin de préserver votre travail.