Que dois-je faire quand j'ai déjà trop attendu entre les commits?

J'étais méchant ... Trop de "codage cow-boy", pas assez engagé. Maintenant, me voilà avec un engagement énorme. Oui, j'aurais dû m'engager depuis le début, mais c'est trop tard maintenant.

Qu'est-ce qui est mieux?

1. Faites un très grand commit listant tout ce que j'ai changé
2. Essayez de diviser le fichier en plusieurs commits qui ne seront probablement pas compilés, car les fichiers contiennent plusieurs correctifs, modifications, noms de méthodes supplémentaires, etc.
3. Essayez de faire des réversions partielles de fichiers uniquement pour les commits appropriés, puis annulez les nouvelles modifications.

Remarque: pour le moment, je suis le seul programmeur à travailler sur ce projet. La seule personne qui se penchera sur l'un de ces commentaires de validation est moi, du moins jusqu'à ce que nous embauchions plus de programmeurs.

Au fait: j'utilise SVN et Subclipse. J'ai créé une nouvelle branche avant de faire ces changements.

Plus d'informations : J'ai posé une question distincte sur la manière dont je suis entré dans cette situation: Comment se préparer à la réécriture de la colle d'une application

Pour répondre, vous devez vous demander comment vous comptez utiliser les résultats de ces commits à l'avenir. Les raisons les plus courantes sont:

• Pour voir quelle version un bogue a été introduit.
• Pour voir pourquoi une certaine ligne de code est présente.
• Pour fusionner dans une autre branche.
• Pour pouvoir consulter une version précédente afin de résoudre un problème rencontré par un client ou un testeur dans cette version.
• Pour pouvoir inclure ou exclure certaines parties d'une version.

Les deux premières raisons peuvent tout aussi bien être servies avec un seul enregistrement important, en supposant que vous puissiez créer un message d’enregistrement qui s’applique également à chaque ligne de code modifié. Si vous êtes le seul programmeur, les plus petites mises à jour ne vous faciliteront pas la fusion. Si vous ne prévoyez pas de publier ou de tester une partie seulement de vos modifications non soumises, les deux dernières raisons ne s'appliquent pas.

Il y a d'autres raisons pour faire de petits commits, mais elles sont valables tant que vous êtes au milieu des changements, et que le temps est passé. Ces raisons facilitent la sauvegarde d'une erreur ou d'un changement expérimental, et facilitent la synchronisation avec vos collègues sans pour autant que des fusions effrayantes se produisent.

D'après ce que je comprends de votre situation, comme vous l'avez décrite, il semble peu avantageux de diviser votre engagement à ce stade-ci.

Je pense que quoi que vous fassiez, essayez d’éviter d’archiver du code que vous savez ne pas compiler.

Si vous pensez que votre troisième option est réalisable, cela pourrait être un bon moyen de le faire, à condition que vous puissiez vous assurer que votre séquence de validations ne créera pas un système incomparable. Sinon, il suffit de faire le gros commit. C'est moche, mais c'est simple, rapide et ça se fait. À l'avenir, commettez plus souvent .

La raison la plus importante de faire des commits fréquents, petits et significatifs est de faciliter la compréhension de l'historique du code. En particulier, il est très difficile de comprendre comment le code a changé s’il est difficile de générer des différences compréhensibles.

L'option 1 masque l'historique des modifications que vous avez apportées, mais sinon, cela ne posera aucun problème.

L’option 2 masque l’historique des modifications que vous avez apportées, peut-être un peu moins que l’option 1, mais peut poser d’autres problèmes pour vous-même ou d’autres personnes si elles supposent ou concluent autrement que les commits sont distincts, par exemple, ils peuvent être fusionnés indépendamment dans d’autres branches. À moins qu'il existe une raison pratique forte de préférer cette option à l'option 1, cette solution est moins idéale que cela.

L'option 3 est préférable, toutes choses étant égales par ailleurs, mais si, comme vous l'avez décrit ailleurs, cela nécessiterait des délais "extrêmes" ou entraînerait d'autres coûts importants, vous devrez les comparer aux avantages escomptés de créer des commets plus propres.

En fonction des informations que vous avez fournies, je choisirais l'option 1. Peut-être devriez-vous configurer des rappels vous invitant à valider vos modifications?

Prototypage et réécriture

Une autre considération à garder à l’esprit, en particulier à la lumière de votre note sur le fait qu’il est le seul programmeur, et de mon soupçon selon lequel vous travaillez sur une base de code relativement nouvelle, est qu’il est probablement bon de développer des habitudes différentes en ce qui concerne les changements à apporter. prototypez le nouveau code par rapport au maintien ou à l'extension du code existant. Il n'y a probablement pas de division très nette entre les deux, mais je pense que c'est toujours une distinction utile.

Lorsque vous prototypez un nouveau code, validez chaque fois que vous souhaitez enregistrer vos modifications, presque certainement dans une branche, mais peut-être dans un projet séparé. Ou peut-être même juste en dehors du contrôle de version. Vous pouvez plutôt vous concentrer sur la collecte de preuves sur la faisabilité de diverses hypothèses ou conceptions que vous envisagez. J'écris souvent de petits prototypes en utilisant différents outils, par exemple LINQPad au lieu de Visual Studio pour le code C #.

Une fois que vous avez validé une conception ou une hypothèse particulière, réécrivez-la dans votre projet principal, idéalement dans une branche, et effectuez les petits engagements significatifs qui aideront le mieux à comprendre les autres (y compris votre avenir) quant à la nature des changements. vous faites.

Bien que la seule solution raisonnable soit de ne jamais casser le coffre , cela n’est parfois pas possible. Par exemple, svn peut interrompre la validation si vous en commettez trop (peut-être une option ou une fonctionnalité, je ne suis pas sûr). Dans ces cas particuliers, il suffit de procéder à l'enregistrement. Étant donné que vous êtes un seul programmeur, cela ne va déranger personne.

Par conséquent, je choisirais l'option 1. Si ce n'est pas possible, alors l'option 2.

L'option 3 nécessite beaucoup d'efforts et n'en vaut simplement pas la peine.

Essayez de diviser le fichier en plusieurs commits qui ne seront probablement pas compilés, car les fichiers contiennent plusieurs correctifs, modifications, noms de méthodes supplémentaires, etc.

Quand je me suis retrouvé dans une situation similaire, j'ai utilisé la technique suivante:

1. Ajoutez uniquement le code correspondant à une fonctionnalité particulière: git add --patch
2. Cachez tous les autres changements: git stash save --keep-index
3. Exécuter des tests / essayer de compiler
4. Commit les modifications si tout va bien, sinon passez à 1

Je ne suis pas familier avec SVN, donc je ne sais pas si cela est applicable à votre situation particulière, mais la base devrait être la même: isolez de petites parties de code et testez-les individuellement.

Que diriez-vous de l’option 4: sauvegarder l’état actuel de votre référentiel dans un emplacement temporaire, rétablir son état initial, dresser une liste de toutes les modifications apportées (vous pouvez toujours consulter la sauvegarde temporaire), puis réimplémenter manuellement (et compiler) et les tester!) en tant que commits séparés.

Cela devrait être plus facile, car vous avez déjà écrit le code, il vous suffit de savoir quelles parties copier et coller à partir de votre sauvegarde temporaire.

Lorsque vous avez ré-implémenté chaque modification proprement, et que vous vous êtes ainsi assuré que les commits sont autonomes, petits et compilés, vous pouvez supprimer la sauvegarde temporaire et tout se déroulera presque exactement de la même manière (à l'exception de l'heure et de la date des commits). aurait été si vous l'avez fait dès le début.

Tu es le seul programmeur; il suffit de faire un seul enregistrement massif détaillant les éléments importants de ce que vous avez fait.

Êtes-vous susceptible de revenir en arrière "parties" de ce que vous avez fait? Sinon, passez absolument à l'option 1.

Il existe plusieurs raisons pour insérer du code dans un système de contrôle de version. Et TOUS ceux-ci, lorsque vous êtes le seul développeur, tournent autour de la sécurité - à savoir, si vous échouez, la machine meurt ou ce que vous voulez, vous pouvez toujours revenir à ce dernier point de contrôle.

Il est peu probable qu'un programmeur intervenant plus tard dans le projet veuille revenir à une version non compilée. Donc, à mon humble avis, l'option 2 est une folie.

L'option 3 ressemble à une telle perte de temps que si j'étais votre patron et que je vous voyais perdre des heures à le faire, je vous parlerais un peu de la valeur de votre temps.

Pour itérer: en enregistrant votre code, vous couvrez / enregistrez votre cible en cas de panne de votre machine. Tout le reste, dans une équipe composée d'un seul homme, est habillé de vitrine.

Ma règle est la suivante: pas d'enregistrement sans une révision sérieuse du code. Si je suis seul, je devrai examiner le code moi-même, mais il le sera . Vous semblez avoir une quantité de changements de code que quelqu'un d'autre ne pourrait pas réviser, donc vous ne pouvez pas le réviser vous-même (réviser votre propre code est plus difficile et nécessite plus de discipline, car vous faites automatiquement l'hypothèse erronée que votre propre code est correct ).

La règle absolument incassable de tout le monde est la suivante: n'effectuez jamais de vérification dans du code qui ne se construit même pas et évitez sérieusement de vérifier si le code ne fonctionne pas.

Solution: Copiez le code modifié, revenez au point d'origine. Fusionnez une modification à la fois dans le code d'origine, examinez-la, testez-la, et archivez-la. Avec la méthode de programmation que vous avez décrite, vous allez certainement trouver quelques bogues sérieux.

C'est aussi un bon moyen de se former à de bonnes habitudes de programmation.

Je pense que vous vous inquiétez beaucoup trop. Si vous êtes le seul programmeur et que vous n’avez pas de feuille de spécifications contre laquelle travailler, c’est à vous de décider de ce que vous faites. Je suppose que personne ne va vous punir pour avoir fait un gros commit; les seuls problèmes que vous allez rencontrer sont d'ordre technologique, comme l'impossibilité d'annuler des modifications de fichiers individuels dans le commit. Étant donné que vous êtes uniquement en contrôle du repo pour le moment, cela ne devrait cependant pas être un problème majeur.

Il y a une ligne à séparer entre pragmatisme et dogmatisme. Ce que vous avez fait ne serait pas une bonne idée dans une équipe et ne devrait probablement pas être répété à l'avenir, mais dans votre situation, je voudrais simplement soumettre le grand engagement.

Le problème ne réside pas dans les longs délais entre les validations, mais dans le fait que le code reste inchangé trop longtemps. Tout d’abord, quelle est votre définition du terme "long"? Pour certaines personnes, 5 minutes pour l'état transitoire, c'est trop, mais certaines personnes peuvent modifier leur code pendant des jours sans même essayer de faire fonctionner le compilateur.

En fait, cela n'a pas d'importance - ce qui compte, c'est que vous ayez perdu le contrôle de votre code, votre code est devenu ingérable. C'est normal, cela signifie simplement que vous avez une dette technologique et qu'il est temps de penser à la refactorisation. Donc tu es frustré? Votre code ne compile pas, vous n'avez même pas de tests unitaires? Comment pouvez-vous penser à la refactorisation dans ce cas? Pas de soucis. Terminez votre "codage cow-boy" et commencez à le nettoyer. Dans l’idéal, essayez d’écrire des tests. Tu n'as pas le temps pour ça? Ok, commencez par de petites améliorations.

Certains changements ne nécessitent pas de tests. Changez le nom de la variable pour mieux convenir, déplacez le code répété en une fonction séparée, etc ... Vous obtiendrez une meilleure idée de votre code. Après cela, vous pouvez faire de plus gros changements. Encore une fois, essayez d'écrire des tests si possible. Rendez votre code gérable.

Après cela, vous verrez que le prochain changement ne vous prendra pas "trop ​​longtemps" (peu importe ce que cela signifie).