Pourquoi devrais-je utiliser le contrôle de version?
Je lisais un blog où l'écrivain a dit ceci
"Le code n'existe que s'il est enregistré dans un système de contrôle de version. Utilisez le contrôle de version pour tout ce que vous faites. N'importe quel contrôle de version, SVN, Git, même CVS, maîtrisez-le et utilisez-le."
Je n'ai jamais utilisé aucune sorte de contrôle de version et je ne le trouve pas génial. Je l'ai googlé et regardé auparavant, mais j'ai juste besoin de le mettre en termes d'enfants si vous voulez.
Si je comprends bien, des choses comme SVN servent à stocker votre code en ligne pour qu'un groupe d'utilisateurs ou d'autres développeurs aient accès au même code. Une fois que vous avez mis à jour du code, vous pouvez soumettre la nouvelle version et le SVN conservera des copies de l'ancien code ainsi que des nouvelles que vous mettez à jour.
Est-ce l'idée de base ou est-ce que je me trompe complètement?
Si j'ai raison, cela pourrait ne pas être très utile si je:
- Aucune autre personne ne travaille sur le code.
- Ne prévoyez pas de laisser les autres avoir le code.
As-tu déjà:
- Vous avez modifié le code, vous vous êtes rendu compte que c'était une erreur et vous vouliez revenir en arrière?
- Vous avez perdu du code ou une sauvegarde trop ancienne?
- Vous avez dû gérer plusieurs versions d'un produit?
- Vous vouliez voir la différence entre deux (ou plus) versions de votre code?
- Vous vouliez prouver qu'un changement particulier a cassé ou corrigé un morceau de code?
- Vous vouliez revoir l'historique d'un code?
- Vous vouliez soumettre une modification au code de quelqu'un d'autre?
- Vous vouliez partager votre code ou laisser d'autres personnes travailler sur votre code?
- Vous voulez voir combien de travail est fait, et où, quand et par qui?
- Vous vouliez expérimenter une nouvelle fonctionnalité sans interférer avec le code de travail?
Dans ces cas, et sans aucun doute dans d'autres, un système de contrôle de version devrait vous faciliter la vie.
Pour citer mal un ami: un outil civilisé pour un âge civilisé.
Même si vous travaillez seul, vous pouvez bénéficier du contrôle des sources. Entre autres, pour ces raisons:
Vous ne perdez rien. Je n'ai plus jamais commenté le code. Je le supprime simplement. Il n'encombre pas mon écran et il n'est pas perdu. Je peux le récupérer en vérifiant un ancien commit.
Vous pouvez expérimenter à volonté. Si cela ne résout pas le problème, rétablissez-le.
Vous pouvez consulter les versions précédentes du code pour savoir quand et où les bogues ont été introduits.
git bisectest excellent à cet égard.Des fonctionnalités plus "avancées" comme la ramification et la fusion vous permettent d'avoir plusieurs lignes de développement parallèles. Vous pouvez travailler dans deux fonctions simultanées sans interférence et basculer d'avant en arrière sans trop de tracas.
Vous pouvez voir "ce qui a changé". Cela peut sembler basique, mais c'est quelque chose que je me retrouve souvent à vérifier. Je commence très souvent mon workflow par un seul homme: qu'est-ce que j'ai fait hier?
Allez-y et essayez-le. Commencez lentement avec les fonctionnalités de base et apprenez les autres au fur et à mesure. Vous découvrirez bientôt que vous ne voudrez plus jamais retourner à "l'âge sombre" de l'absence de VCS.
Si vous voulez un VCS local, vous pouvez configurer votre propre serveur Subversion (ce que j'ai fait dans le passé), mais aujourd'hui je recommanderais d'utiliser git. Beaucoup plus simple. Il suffit de cd dans votre répertoire de code et d'exécuter:
git init
Bienvenue au club.
Le contrôle de version est un outil rare qui, je dirais, est absolument nécessaire, même si vous ne l'utilisez qu'en tant que développeur solo. Certaines personnes disent que c'est un outil qui vous permet de vivre et de mourir, je suis d'accord avec cette affirmation.
Vous utilisez probablement le contrôle de version en ce moment, même si vous ne le savez pas. Avez-vous des dossiers qui disent "XXX Php Code (décembre)" ou "XXX.php.bak.2"? Ces sont formes de contrôle de version déjà. Un bon système de contrôle de version s'en occupera automatiquement pour vous. Vous pourrez revenir à tout moment (que vous ayez archivé les données) et voir une copie exacte de ces données.
De plus, si vous adoptez un système comme Subversion et utilisez un référentiel distant (comme celui sur un serveur que vous possédez), vous aurez un endroit pour conserver tout votre code. Besoin d'une copie de votre code ailleurs? Pas de problème, vérifiez-le. Accident de disque dur à la maison? Pas un problème (au moins avec votre code source).
Même si vous n'utilisez pas le contrôle de version maintenant, vous l'utiliserez probablement à un moment donné plus tard dans votre carrière et vous pourriez bénéficier de devenir plus à l'aise avec les principes maintenant.
Même en travaillant seul, est-ce déjà arrivé? Vous exécutez votre application, et quelque chose ne fonctionne pas et vous dites "cela a fonctionné hier, et je jure que je n'ai pas touché à cette classe/méthode". Si vous archivez régulièrement du code, un diff de version rapide affichera exactement ce qui a changé le dernier jour.
Voici un scénario qui peut illustrer l'utilité du contrôle de code source même si vous travaillez seul.
Votre client vous demande de mettre en œuvre une modification ambitieuse du site Internet. Cela vous prendra quelques semaines et impliquera des modifications sur plusieurs pages. Vous vous mettez au travail.
Vous avez terminé à 50% avec cette tâche lorsque le client appelle et vous dit de laisser tomber ce que vous faites pour apporter une modification urgente mais plus mineure au site. Vous n'avez pas terminé la tâche plus importante, elle n'est donc pas prête à être mise en ligne et le client ne peut pas attendre le plus petit changement. Mais il souhaite également que le changement mineur soit fusionné dans votre travail pour le changement plus important.
Peut-être que vous travaillez sur la grande tâche dans un dossier séparé contenant une copie du site Web. Maintenant, vous devez comprendre comment effectuer le changement mineur d'une manière qui peut être déployée rapidement. Vous travaillez furieusement et vous le faites. Le client rappelle avec d'autres demandes de raffinement. Faites-le aussi et déployez-le. Tout est bien.
Vous devez maintenant le fusionner dans le travail en cours pour le changement majeur. Qu'avez-vous changé pour le travail urgent? Tu travaillais trop vite pour garder des notes. Et vous ne pouvez pas simplement différencier facilement les deux répertoires maintenant que les deux ont des changements par rapport à la ligne de base à partir de laquelle vous avez commencé.
Le scénario ci-dessus montre que le contrôle de source peut être un excellent outil, même si vous travaillez en solo.
- Vous pouvez utiliser des branches pour travailler sur des tâches à plus long terme, puis fusionner la branche dans la ligne principale une fois l'opération terminée.
- Vous pouvez comparer des ensembles entiers de fichiers à d'autres branches ou à des révisions antérieures pour voir ce qui est différent.
- Vous pouvez suivre le travail au fil du temps (ce qui est excellent pour les rapports et la facturation en passant).
- Vous pouvez récupérer n'importe quelle révision de n'importe quel fichier en fonction de la date ou d'un jalon que vous avez défini.
Pour le travail en solo, Subversion ou Git est recommandé. Tout le monde est libre de préférer l'un ou l'autre, mais il est clairement préférable de ne pas utiliser de contrôle de version. Les bons livres sont " Pragmatic Version Control using Subversion, 2nd Edition " par Mike Mason ou " Pragmatic Version Control Using Git " par Travis Swicegood.
Auteur original: Bill Karwin
Même en tant que développeur unique, le contrôle de source offre un grand avantage. Il vous permet de stocker l'historique de votre code et de revenir à tout moment aux versions précédentes de votre logiciel. Cela vous permet une flexibilité sans crainte pour expérimenter, car vous pouvez toujours restaurer vers une autre version de votre code source qui fonctionnait.
C'est comme avoir un bouton "Annuler" géant jusqu'à votre première ligne de code.
Le contrôle de version est presque impossible à vivre sans après avoir commencé à l'utiliser. C'est indispensable si plusieurs développeurs travaillent sur la même base de code ... mais c'est aussi très utile pour un seul développeur.
Il suit les modifications de votre code et vous permet de revenir aux versions précédentes. Cela vous permet d'expérimenter en sachant que si quelque chose se casse, vous pouvez annuler vos modifications.
Vous gagnez en sécurité (dans le sens d'avoir une sauvegarde de votre code) et le versionnage de votre code (en supposant que vous prenez l'habitude de commettre vos modifications souvent). Les deux sont de très bonnes choses même si personne d'autre ne finit par travailler sur le code avec vous ...
Quelque chose que personne d'autre ne semble avoir explicitement mentionné est le balisage ou l'étiquetage des versions. Si vous avez un client utilisant la version 1 de votre logiciel et que vous êtes occupé à travailler sur la version 2, que faites-vous lorsque le client signale un bogue et que vous devez créer la version 1.1?
Un système de contrôle des sources vous permettra d'étiqueter chaque version que vous effectuez afin que vous puissiez y revenir plus tard, apporter le correctif (et fusionner ce correctif dans le nouveau code de la version 2) et créer une nouvelle version sans craindre que vous puissiez accidentellement livrer quelque chose qui n'est pas prêt.
Le contrôle des sources est au cœur du développement logiciel moderne. Si vous ne l'utilisez pas (même pour des projets personnels car plus vous avez d'expérience, mieux c'est) vous faites quelque chose de mal.
Habituellement, l'une des premières questions que je pose lorsque je suis interviewé pour un emploi est "Qu'utilisez-vous pour le contrôle de code source? Jusqu'à présent, un seul endroit a dit "Rien" mais ils prévoyaient de résoudre ce problème "Très bientôt maintenant ..."
Le contrôle de version est idéal pour vérifier les versions précédentes, même si vous travaillez seul. Par exemple, si vous supprimez accidentellement du code ou un fichier, vous pouvez le récupérer; ou vous pouvez comparer les versions précédentes pour voir pourquoi un nouveau bogue s'est glissé. C'est aussi bien si vous êtes une seule personne travaillant à plusieurs endroits.
Mon préféré est git.
Il existe un certain nombre de raisons d'utiliser le contrôle de version, même si vous êtes la seule personne à toucher le code.
- Sauvegarde - et si votre disque dur tombe en panne? En avez-vous une copie quelque part?
- Historique des révisions - Conservez-vous actuellement des copies de code dans différents dossiers? Le contrôle de version vous donne la possibilité de suivre vos modifications au fil du temps et de différencier facilement différentes révisions, fusionner, annuler les modifications, etc. à l'aide d'outils.
- Branches - la possibilité de tester certains changements, de toujours suivre ce que vous faites, puis de décider si vous souhaitez le conserver et fusionner dans le projet principal ou simplement le jeter.
Si vous gardez votre code sous contrôle de version, cela rend très facile de voir quels fichiers vous avez modifiés (ou avez oublié d'ajouter à la ligne de base).
Le fait que d'autres développeurs participent ou non est totalement orthogonal au besoin d'un système de contrôle de version.
Vous pouvez être le seul développeur mais bénéficierez tout de même de:
- un parcours historique de tous vos changements
- possibilité de revenir en arrière et d'avancer sur cette histoire
- possibilité d'expérimenter avec la source tout en ayant une version fonctionnelle (branchement)
- une copie de sauvegarde (surtout si vous utilisez une machine différente comme serveur de contrôle source, et encore plus si cette machine est régulièrement sauvegardée)
Maintenant, si vous avez un groupe développant sur le même contrôle de version de base de code est encore plus nécessaire,
- les gens peuvent éditer le même fichier en même temps (selon le système particulier, mais la plupart des gens sensés vous permettent de le faire)
- vous pouvez dire qui a fait quoi au code quand
Lorsqu'il y a plus de personnes impliquées, il est plus pertinent de choisir l'outil de contrôle de version que vous choisissez, selon le style de développement.
J'ai récemment commencé à m'intéresser au contrôle de version. Dans les systèmes de contrôle de version, vous avez le concept d'un référentiel pour votre code. Une multitude de nouvelles commandes Shell sont apprises très rapidement afin que vous puissiez interagir avec ce référentiel.
Une fois que vous avez enregistré votre code dans un fichier, vous pouvez ensuite valider ceci dans le référentiel de votre projet. Au fur et à mesure que vous développez votre code et validez vos modifications, le référentiel développe une série de révisions . Vous pouvez accéder à n'importe lequel de ces éléments en en vérifiant une révision. Si vous travaillez seul, il est peu probable que vous fassiez beaucoup de vérification à moins de perdre vos fichiers de code ou de vouloir travailler sur une autre machine. Dans ces cas, vous consultez généralement la dernière révision de tous les fichiers.
Pour ma part, je ne garde plus les fichiers ou dossiers nommés 'project_old' quand je décide de refactoriser quelque chose. Toutes les modifications que je fais sont stockées de manière incrémentielle et je pourrai toujours revenir en arrière vers un projet qui a fonctionné dans son ensemble. J'utilise rarement FTP pour déployer maintenant parce que je vérifie juste mon code via ssh. Seuls les fichiers que j'ai modifiés sont téléchargés et si j'ai besoin de recharger sur le serveur le terminal est déjà là.
J'ai trouvé cet exposé sur GIT très instructif; http://www.youtube.com/watch?v=4XpnKHJAok8
C'est une discussion sur Google où Linus Torvalds fait un argument pour utiliser un système de contrôle de version sur un autre. Ce faisant, il explique comment ils fonctionnent à l'aide de concepts, puis compare différentes manières de les mettre en œuvre.
Il s'agit également de sauvegarder l'ancien fichier, c'est pourquoi il est appelé "Subversion". Vous pouvez donc gérer plusieurs versions de votre travail dans lesquelles vous pouvez revenir en arrière (revenir) et gérer les différentes implémentations de celui-ci (branchement).
Vous constaterez peut-être que vous disposiez d'une version de travail de votre programme.
Vous décidez d'ajouter quelques nouvelles fonctionnalités sur une période de temps et vous les libérez.
Vous commencez à obtenir des rapports de bogues affectant du code que vous pensiez n'avoir pas touché.
En utilisant SVN, par exemple, vous pouvez revenir à une version plus ancienne et vérifier si le nouveau bogue existe. Une fois que vous avez trouvé une version qui a introduit le bogue, il sera plus facile de le corriger car vous pouvez comparer la version qui a fonctionné à ce qui n'a pas fonctionné et voir ce qui a changé, puis cela restreindra la recherche.
Le contrôle de code source a de nombreuses utilisations, même si vous êtes le seul développeur.
On dirait que vous cherchez quelque chose d'un peu plus léger. Consultez Mercurial ( livre de référence génial ). Je l'utilise pour tout, du code source à la correspondance personnelle.
Quelques avantages:
- Bouton d'annulation géant, vous pouvez donc retourner les jours de halcyon de la semaine dernière lorsque le code a réellement été exécuté
- Code à jeter. Vous ne savez pas si c'est la meilleure façon de faire quelque chose? Créez une branche et expérimentez. Personne, mais vous ne devez jamais le savoir si vous utilisez un DVCS comme Mercurial.
- Développement synchronisé. Je développe sur 4 ordinateurs différents. Je pousse et tire entre eux pour garder le courant, donc peu importe lequel je suis, j'ai les dernières versions.
Même si vous n'avez pas encore été dans une situation où vous aviez besoin d'une ancienne version de votre programme, avoir un contrôle de source vous donne une plus grande confiance pour effectuer des changements majeurs.
Je me suis retrouvé à faire un refactoring plus agressif après avoir utilisé le contrôle de code source car j'ai toujours su qu'une version de travail pouvait être facilement restaurée.
Vous voudrez probablement quelque chose comme Subversion même si vous travaillez seul pour avoir un historique de toutes vos modifications. Vous voudrez peut-être voir à quoi ressemblait un morceau de code une fois pour vous rappeler pourquoi vous avez apporté une modification.
Le contrôle de source est également utile lorsque vous vous enregistrez souvent. Si vous vous enregistrez souvent, vous serez toujours en mesure de revenir souvent en arrière. Plusieurs fois, vous pouvez commencer à suivre un chemin pour résoudre un problème, puis vous rendre compte que ce n'est pas le bon chemin. Plusieurs fois, vous pouviez simplement aboyer sur le mauvais chemin et finir par construire une solution terrible - uniquement parce que vous ne vouliez pas perdre tout votre travail. En vous enregistrant souvent, le dernier point de "bonheur" n'est pas loin, même si vous suivez le mauvais chemin, vous pouvez toujours revenir en arrière et réessayer et faire une solution plus élégante et simple. Ce qui est toujours une bonne chose pour que vous puissiez comprendre et maintenir ce que vous avez écrit à l'avenir.
Cela dépend de la taille du projet et de la fréquence à laquelle vous changez d'avis sur certaines parties de celui-ci. Pour les petits projets où vous faites simplement quelque chose de manière linéaire, le contrôle de version ne sera probablement pas d'une grande utilité (bien que si vous supprimez ou corrompez accidentellement un fichier sans contrôle de version, vous pleurerez).
Mais il y a quelques semaines, j'ai rencontré un ami qui écrivait lui-même un énorme projet de loisir. Il avait dix ou vingt copies de son code, avec des suffixes comme "X1", "X2", "test", "plus rapide" et ainsi de suite.
Si vous avez fait plus de deux copies de votre code, vous avez besoin du contrôle de version. Un bon système de contrôle de version vous permet d'annuler une modification que vous avez effectuée il y a quelque temps sans annuler ce que vous avez fait après avoir effectué cette modification. Il vous permet de voir quand certaines modifications ont été apportées. Il vous permet de diviser votre code en deux "chemins" (par exemple, l'un pour tester une nouvelle idée, l'autre pour protéger votre code "testé et approuvé" jusqu'à ce que vous ayez terminé les tests), puis les fusionner à nouveau.