Quelle est la manière la plus efficace / efficiente de développer une application avec plusieurs personnes sans contrôle de source?

Introduction à ma situation

Je travaille pour une petite entreprise de développement web. Nous avons une équipe de quatre développeurs ASP.NET, dont moi. Presque tous nos projets (> 98%) sont des projets d'une seule personne qui prennent environ 1 à 4 semaines. Nous n'utilisons pas de contrôle de source ou de version. La seule chose que nous avons est un dossier partagé sur un serveur local qui contient la dernière source (== la source de l'application en direct) de tous les projets.

Dans les rares occasions où nous devons travailler sur le même projet avec plus d'une personne, nous utilisons ... Beyond Compare. Une ou deux fois par jour, les développeurs se demandent s'ils ont une version qui se compile, puis ils synchronisent leur code à l'aide de Beyond Compare. Lorsque seulement deux personnes travaillent sur un projet, cela fonctionne "plutôt bien", mais dès qu'un troisième développeur entre dans le processus, il devient un déchet ingérable. Surtout quand tout le monde commence à apporter des modifications à la base de données.

J'ai (et un ou deux de mes collègues développeurs) ai déjà dit à mon patron à plusieurs reprises que nous devrions commencer à utiliser une forme de contrôle de source et de version comme Git, Mercurial ou TFS (notre patron est très soucieux de Microsoft). Malheureusement, mon patron ne voit pas l'avantage de passer à un système de contrôle de source et de version, car à ses yeux tout fonctionne très bien maintenant et il ne veut pas investir temps et argent dans la mise en place d'un nouveau système et s'assurer que tout le monde sait l'utiliser. Même après lui avoir expliqué les avantages (comme une collaboration simplifiée, différentes versions d'une application, un moyen plus sûr de changer le code, ...) pour lui, il ne pense toujours pas que c'est quelque chose dont nous avons besoin.

Sur les quatre développeurs, seuls deux (dont moi) ont de l'expérience avec le contrôle de source (Git). Et cette expérience est très limitée. Je sais comment cloner un référentiel Github sur mon ordinateur, apporter des modifications, les valider et les repousser vers Github. C'est ça.

Explication de mon problème / préoccupation

Dans quelques semaines, nous allons commencer à travailler sur un projet assez important pour nos normes. Il faudra probablement 2-3 développeurs quelques mois pour le terminer. Je serai le chef de projet (chef de projet et développeur principal) et je serai responsable de tout. J'ai eu mon lot de problèmes avec notre approche Beyond Compare et je ne veux pas emprunter cette voie avec ce gros projet qui sera ma responsabilité.

Comme je doute que nous pourrons

• configurer notre propre serveur Git,
• apprendre à tout le monde à travailler avec Git et
• employer Git avec succès dans ce grand projet,

Je suis intéressé si certains d'entre vous connaissent de bonnes façons de permettre à plusieurs personnes de collaborer sur le même projet sans utiliser le contrôle de source ou de version.

Mise à jour

Je remercie tout le monde pour leurs réponses et commentaires. Voici le plan:

1. Organisez une réunion avec les développeurs pour vous assurer que tous les techniciens se sentent de la même manière lors de l'implémentation du contrôle de code source. Nous ferons un point fort lorsque tout le monde sera derrière.
2. Présentez l'idée au patron et dites-lui que nous avons vraiment besoin du contrôle des sources.
3. Implémentez-le dès que possible.

Veuillez prendre une journée pour installer le contrôle de version et apprendre à tout le monde sur le projet à l'utiliser. Ce n'est pas si dur. Personnellement, je n'ai pas utilisé Git, mais j'ai mis en place et utilisé d'autres systèmes de contrôle de version et ils ne sont pas si difficiles à travailler. Assurez-vous d'en choisir un qui s'intègre à votre environnement de développement. Cela rendra son utilisation pratiquement transparente.

Ce ne sera pas du temps perdu.

Le temps que vous vous perdrez quand quelqu'un écrasements ou supprime un code vous coûtera beaucoup plus.

Si vous n'avez pas de contrôle de version, vous passerez également un temps excessif à sauvegarder votre projet et à vous soucier de la version que tout le monde a et de la version sur le serveur, etc.

Si vous devez convaincre votre patron de faire une estimation du temps qu'il vous faudra pour configurer et surveiller toute solution de contrôle non-version et ajouter le coût de réécriture de quelques jours de travail perdu. N'oubliez pas d'ajouter le coût de la fusion manuelle des modifications de 3 développeurs travaillant sur le même fichier source et le coût supplémentaire de l'erreur de fusion. Un bon contrôle de version vous donne ceci gratuitement

Comparez ensuite cela au coût du contrôle de version - nul (si vous optez pour l'open source) et de sa configuration - 3 jours-homme.

N'oubliez pas qu'une erreur plus tard dans le projet en coûtera plus d'une dès le début. Si vous devez refaire tout le projet à cause d'une erreur que n'importe qui peut faire, cela coûtera bien plus que le temps de réécriture, cela pourrait coûter à votre patron la réputation de son entreprise.

Si vous partagez la source sur un dossier, vous pouvez également y partager des repo. Le patron ne le saura pas, sauf qu'il y a un dossier .git dedans.

Vous ne devriez jamais avoir à demander la permission de faire votre travail correctement - Seth Godin.

Configurez le contrôle des sources, apprenez à l'utiliser et n'en parlez pas à votre patron. Normalement, je ne préconise pas de désobéir à la gestion, mais dans ce cas, votre patron est stupide. Si vous pensez vraiment que git mettra trop de temps à apprendre, alors commencez par un système de contrôle de version plus simplifié comme svn - il ne fait pas toutes les choses intéressantes que git fait, mais il est encore plus facile d'acquérir une compréhension de base.

N'attendez pas d'être au milieu et sérieusement en difficulté avant de mettre en œuvre quelque chose. Faites-le et faites le travail.

Modifié pour ajouter: ce que votre question demande vraiment, c'est «comment puis-je faire le contrôle de source sans utiliser de système de contrôle de source». Vous avez reconnu le besoin, et je pense que tout le monde ici vous dit vraiment la même chose: il n'y a pas de façon sensée de faire le contrôle de source sans système de contrôle de source.

Je n'ai que votre résumé pour passer, mais d'après cela, il semble que votre patron avance un argument temps et argent, et vous faites un argument de supériorité technique. Vous devez faire un argument temps et argent. Apprenez comment faire les choses et gardez une trace pendant un certain temps, puis présentez un journal à votre patron avec des entrées comme "28/03/2011 a dû attendre 30 minutes pour que Joe revienne à une version compilable afin que nous puissions faire une fusion, la commande git merge contre son dernier commit aurait été d'environ 5 secondes "avec un joli total en bas.

Si la formation et la configuration d'un serveur sont des obstacles commerciaux, il existe un nombre infini de façons de configurer un flux de travail git, y compris le fait qu'un seul membre de l'équipe utilise réellement git, avec des dossiers partagés pour le "serveur".

Demandez à vos collègues de copier leur code dans un dossier partagé donné chaque fois que le moment est venu de le partager. Vous pouvez garder un référentiel pour chacun d'eux et faire vous-même toutes les tâches de contrôle de source, et leur transmettre progressivement de plus en plus de responsabilités de contrôle de source à mesure que vous devenez suffisamment confiant pour les former. C'est loin d'être le moyen idéal de le faire, mais par rapport à ce que vous avez maintenant, même cela vous fera gagner du temps sur les fusions. Il est plus facile de convaincre votre patron avec moins de courbe d'apprentissage en équipe et vous obtenez tous les avantages de restauration et de versionnage que vous souhaitez.

Je ne fais pas beaucoup de travail de base de données, mais à ma connaissance, la fusion des modifications de schéma de base de données n'est pas très bien gérée par le contrôle de source. Si ces fusions sont difficiles, vous voudrez peut-être envisager un changement de processus où toutes les modifications de la base de données passent par un seul contrôleur d'accès.

C'est insensé. Vous devez utiliser un VCS même si vous travaillez seul. Ne pas utiliser de VCS dans une entreprise devrait être interdit. Simplement fais-le. Maintenant! Vraiment ... Vous n'avez pas besoin de choses avancées dès le début. GitHub et GitLab sont très simples à utiliser, mais je suis sûr que vous pouvez trouver d'autres services d'hébergement compatibles avec Windows si votre patron insiste (même s'il n'est pas difficile de configurer et d'utiliser Git sur Windows).

La pensée que vous demandez est impossible . Si plusieurs personnes travaillent sur le même projet sans utiliser de contrôle de code source, vous aurez rapidement beaucoup de problèmes, et puisque vous serez le développeur principal, vous devrez y faire face.

D'après mon expérience personnelle, travailler sur un projet sans contrôle de source devient impossible pour deux développeurs . Pas trois. Pas quatre. Deux. Vous pouvez probablement être en mesure de gérer la situation avec deux développeurs dans des circonstances exceptionnelles : si ces développeurs sont très organisés et professionnels, s'ils interagissent bien, s'ils peuvent facilement échanger (ils sont donc situés dans la même pièce aux mêmes heures, tous les temps) et s’ils sont capables d’éviter les erreurs humaines (modifier par erreur le fichier qui a été modifié par une autre personne au même moment, puis effacer les changements effectués par cette personne).

Dans mon cas, c'était toujours plus ou moins un désastre quand il s'agissait de faire participer deux personnes à un projet sans contrôle de version. Dans le meilleur des cas, une personne envoyait des fichiers modifiés au second et celui-ci a utilisé un outil de comparaison pour appliquer les modifications manuellement. Dans le pire des cas, une personne a suivi les changements qu'elle faisait, puis les a réappliqués chaque fois que la deuxième personne modifiait le code source. Résultat: une énorme perte de temps, d'argent et de productivité.

Maintenant, de mon point de vue et de ma propre expérience, je vois trois solutions au problème que vous avez:

• Installez un contrôle de version facile à utiliser . J'avais l'habitude d'installer CollabNetSubversion en tant que serveur SVN, c'est assez rapide et facile à configurer, si vous ne vous souciez pas du tout de la sécurité . Si vous utilisez Visual Studio, AnkhSvn peut être installé pour permettre aux développeurs de mettre à jour / valider le code source facilement depuis Visual Studio.

• Convainquez votre patron que le test Joel est écrit par une personne qui connaît très bien son travail, et si le test Joel suggère d'avoir un contrôle de version, il y a une bonne raison derrière cela. Après tout, il peut également décider que les développeurs n'ont pas besoin d'outils de mise en évidence IDE / syntaxe pour écrire du code. Le Bloc-notes Windows est très bien, non? Et aussi, pourquoi avoir accès à Internet? Tout ce dont nous avons besoin, c'est d'un très, très ancien PC exécutant Windows 3.1.

• Quittez cette entreprise , car j'ai des doutes sur le fait que tout sauf le contrôle de version y est parfait et professionnel.

Ne pas utiliser un VCS sur un projet plus important parce que vous ne voulez pas investir le temps d'en installer un, c'est comme faire un long voyage pieds nus, parce que vous ne voulez pas investir le temps de mettre des chaussures.

N'importe quel VCS vaut mieux qu'un ordre de grandeur.

Un moyen très simple de configurer un VCS est d'obtenir TortoiseSVN (puisque vous semblez utiliser C #, je suppose que vous êtes sous Windows). Vous créez un référentiel dans un dossier local de votre choix (accédez-y, faites un clic droit> TortoiseSVN> Créer un référentiel ici). Partagez ce dossier dans votre réseau (il devrait de préférence être sur une machine, qui est toujours disponible) et effectuez des achats avec l'URL file://computername/path/to/that/repository. Téléchargement exclu, la configuration ne prend pas plus d'une minute.

Votre réponse est un simple lien vers votre patron ... postez-lui cette page et mettez en surbrillance le nombre de fois où les mots "arrêter" apparaissent de la part de professionnels.

Bien que le mot "stupide" apparaisse probablement autant de fois, je suis certain que votre patron ne l'est pas. Il ne sait tout simplement pas la valeur absolue de cela. La question à lui poser est de savoir quelle question liée à l'entreprise entraînerait la même réponse (peut-être un comptable suggérant "N'assurez pas plutôt cet immeuble que vous êtes lié au maximum, cela vous fera économiser quelques dollars!")

Le contrôle des sources n'est nécessaire que lorsque le nombre de développeurs sur un projet est> 0. Je commence à penser que l'on pourrait en dire autant de l'intégration continue ...

(-:

En tant que développeurs ASP.NET, je vous suggère de choisir l'un de Subversion, TFS ou Mercurial - mais pour être honnête, peu importe le moment où vous allez avec quelque chose. Développer sans contrôle de version n'a aucun sens - encore moins lorsque les outils sont plus ou moins libres de se déployer et que la surcharge pour les utiliser est minime.

TFS vous offrira un niveau d'intégration incroyable. DVCS (mercurial ou git) vous donnera probablement le plus de flexibilité et de capacité. Il n'y a aucune bonne raison de NE PAS le faire.

Si je partais de zéro, ce serait presque certainement avec Mercurial.

Une fois que vous avez le contrôle de version, vous pouvez passer à un serveur de build (TFS, TeamCity) et de là à une intégration continue et à ce stade, vous commencez à gagner la main sur le poing.

Pour revenir à votre point de départ:

Je serai le chef de projet (chef de projet et développeur principal) et je serai responsable de tout

À droite, vous êtes responsable, donc vous décidez que vous avez besoin d'un contrôle de version (parce que vous le faites), vous décidez que vous avez besoin d'un serveur de construction (parce que vous le faites), vous décidez que vous devez avoir une sortie déployable de votre projet dès le premier jour (car si vous pouvez toujours le déployer - et donc faciliter plus de tests) et que le déploiement sera hautement automatisé - ce sont des étapes que vous prenez pour assurer la réussite de votre projet (dont vous êtes responsable ...)

Comme mentionné ci-dessus, vous pouvez placer un référentiel sur le dossier partagé que vous avez déjà. Vous n'avez pas besoin de passer du temps à configurer un serveur si vous utilisez un système de contrôle de source distribué, comme Git, Mercurial ou Bazaar.

Je vous suggère d'utiliser Git, car vous avez déjà une certaine expérience avec lui, ou Mercurial, qui a une bonne intégration dans Visual Studio.

Si à l'avenir votre patron vous dira de passer à TFS, c'est encore mieux que de n'avoir aucun contrôle de version.

À l'époque de Powerbuilder, nous avions toute une équipe travaillant sur une suite d'applications sans utiliser le contrôle de source. Oh, Powerbuilder avait le contrôle des sources, mais en fait, l' utiliser était un crapshoot - si PB s'est écrasé alors que vous aviez extrait un fichier (et il s'est écrasé BEAUCOUP), ce fichier propriétaire de code source binaire était maintenant inaccessible. Un indicateur a été défini dans le fichier, et aucune autre copie de PB n'a pu le charger, même la même personne qui l'a vérifié.

Donc ce que nous avons fait était assez simple. "Hé, Tom, je vais travailler sur xyz.pbl. Alors ne fais aucun changement". Dans le grand schéma des choses, nous avons rarement eu de problèmes.

En supposant que vous ne pouvez pas convaincre votre équipe d'adopter le contrôle de version ou que votre patron ait vent du subterfuge et insiste pour que l'équipe s'arrête, il y a une approche moins qu'optimale que vous pouvez adopter.

Installez Git ou Mercurial sur votre propre machine. Versionnez votre propre travail. Lorsque l'équipe synchronise son travail via le processus Beyond Compare, ajoutez les modifications à votre référentiel local en tant que nouveau commit. Vous serez toujours en mesure de récupérer une version de travail précédente de votre référentiel local si la synchronisation de l'équipe interrompait quelque chose.

L'utilisation d'un DVCS garantit qu'il n'y a aucune exigence d'avoir un serveur et aucun processus d'installation complexe. L'installation de Mercurial et la mise en route avec les bases ne devraient pas prendre plus de 30 minutes environ.

Ce n'est pas une solution idéale, mais c'est mieux que rien.

Ma première réaction à cela a été que vous disposez déjà d'un processus de travail idéal sans contrôle de version. Vous semblez tous avoir une bonne façon de gérer la fusion et ainsi de suite. D'un point de vue managérial, c'est apparemment une bonne situation. J'ai rencontré des équipes qui utilisent le contrôle de version, mais doivent lutter avec le processus de développement lui-même.

Il est donc inutile de convaincre votre patron en basant uniquement votre argument sur le fait que le contrôle de version produirait "un meilleur processus". Il existe cependant un autre argument beaucoup plus important sur la raison pour laquelle vous devez utiliser la version ou le contrôle de source en premier lieu, qui peut facilement être calculé en argent. Et c'est:

Risque

Le problème n'est pas que l'utilisation du contrôle de code source améliore votre processus de développement. C'est plus un problème que ce qui se passerait si vous n'avez pas du tout de contrôle de source. Quels sont les risques?

Supposons que quelqu'un supprime par erreur une fonction dans le code ou un fichier entier? Combien cela coûterait-il pour réparer? J'espère que quelqu'un a couvert cela, donc la solution est marginale.

Mais que se passe-t-il si aucun organisme n'a une sauvegarde du fichier perdu? Combien d'heures de travail cela coûterait-il à réparer? Cela prendrait peut-être des jours, et cela se calcule facilement en moyenne d'heures de travail. Serait-ce trop pour l'entreprise? Pourrait-on y remédier plus rapidement?

Oui, avec une sorte de contrôle de source. En revanche: combien de temps il faudrait pour configurer le contrôle de version et le sauvegarder? La plupart des logiciels open source tels que git ou mercurial ne prennent pas beaucoup de temps à configurer. Apprendre aux gens à l'utiliser ne serait pas si difficile, étant donné que vous savez déjà comment fusionner avec Beyond Compare et que vous vous «connectez» à un dossier partagé. Il s'agit d'un coût d'installation unique. Ces heures de travail seraient-elles inférieures à celles des risques? Si cela est vrai, l'utilisation du contrôle de source devrait être une priorité.

Tant que vous pouvez montrer une raison commerciale pour laquelle il est utile d'avoir le contrôle des sources, et la gestion des risques serait un de ces facteurs énormes, qui convaincrait la plupart des patrons.

Utilisez un système de contrôle de version distribué comme git et utilisez votre machine de dossiers partagés pour stocker le référentiel de référence. Voici pourquoi:

Chaque clone est une sauvegarde

Si le disque dur du serveur tombe en panne, tout le monde en a une copie, prête à être déployée sur un nouveau lecteur ou serveur. Comme votre entreprise n'est pas sérieuse à propos du contrôle de version, je suppose que cela peut être à peu près la même chose avec les sauvegardes.

Référence commune

Avoir un référentiel principal avec une branche master permet de connaître la version qui a le dernier mot. Cela résout le "Vous avez testé vos modifications par rapport à la version de Franck, mais avez-vous également John? Et comment les avez-vous fusionnés?".

Livrez plus confortablement

Le client veut une version alpha aujourd'hui? Eh bien, vous pouvez tester si le maître est suffisamment stable et l'expédier. Si ce n'est pas le cas et que vous n'avez pas le temps de le réparer, remontez dans le temps et obtenez une version plus ancienne mais plus stable. Vous ne pouvez pas faire cela si vous ne disposez que de la dernière version.

Remontez le temps et corrigez vos erreurs

Votre fusion manuelle a rencontré des problèmes que vous n'avez vus qu'après quelques jours, mais vous avez déjà remplacé le contenu de vos dossiers partagés? Sans VSC, vous n'avez pas d'historique, vous ne pouvez donc pas facilement revenir à un point où vous pouvez vérifier les erreurs que vous avez faites et les corriger. Le code n'est pas comme une image, c'est comme un film: il évolue dans le temps. Vous pouvez extraire une image d'un film. Vous ne pouvez pas extraire un film d'une image.

Localisez les bogues plus facilement

Un bogue est apparu mais vous ne l'aviez pas vraiment remarqué au moment de son introduction, vous ne pouviez donc pas le corriger tant que le code était "chaud". Maintenant, vous ne savez pas vraiment quel changement l'a introduit, il peut donc provenir de plusieurs emplacements différents dans le code. Cela prendra des heures juste pour trouver où chercher. Avec git, vous auriez pu simplement développer un test pour dire si le bug se produit sur une version spécifique, et utiliser git bissectpour trouver le commit exact qui a introduit le bug. Au lieu de rechercher des milliers de lignes de code, vous savez maintenant qu'il se trouve dans le changement de 10 lignes et vous pouvez conserver le test dans votre suite de tests pour vous assurer que le bogue n'est pas réintroduit.

Chaque développeur est responsable de son propre travail

Si vous êtes le chef d'équipe et que vous n'avez pas de VCS, vous devrez très probablement faire le sale boulot, les fusions. Si vous le faites par vous-même, vous ne savez probablement pas tout sur tous les changements et vous risquez d'introduire des erreurs. Au contraire, si vous demandez toujours aux personnes qui ont écrit le code de se rassembler avec vous chaque fois qu'il y a du code à fusionner, c'est le moment où elles n'utiliseront pas pour produire du nouveau code.

Avec un VCS, dans un workflow simple, le développeur n'a qu'à prendre en charge son travail, et une seule source externe de changements: la branche master. Il peut y avoir 1 ou 100 personnes engagées dans la branche master, c'est pareil. Pour pouvoir pousser ses changements, il devra les adapter aux derniers changements effectués par d'autres. Il peut sembler qu'il faut plus de temps pour pousser le code, mais c'est parce que vous effectuez également la fusion qui aurait pris du temps de toute façon.

La différence est que la fusion est effectuée par la personne qui a effectué les modifications, qui connaît le mieux ce code parce qu'il l'a écrit.

Qui a écrit ce code?

Il y a ce bug ici, mais qui a écrit cette ligne de code particulière? C'est difficile à retenir, surtout si le projet dure plusieurs mois. git blamevous aurait dit qui et quand cette ligne a été écrite, vous pouvez donc demander à la bonne personne, et il n'y a pas de "Je ne me souviens pas avoir écrit cela".

Le projet s'agrandit

Le client veut plus de fonctionnalités et vous êtes une équipe trop petite, vous aurez besoin d'un autre développeur. Comment gérez-vous la complexité accrue des fusions sans VSC?

Changements urgents

Le client a appelé et a demandé une correction de bogue critique pour la production, mais vous travailliez actuellement sur une nouvelle fonctionnalité. Juste git stashpour mettre vos modifications de côté, ou les valider dans une nouvelle branche et pousser les modifications et vous êtes prêt à commencer à travailler sur le correctif urgent, sans craindre de perdre votre travail en attente.

Cela a fonctionné il y a 10 minutes

Vous effectuez des changements localement et quelque chose qui a fonctionné il y a 10 minutes a cessé de fonctionner. Sans VCS, vous regardez le code ou au mieux, faites une copie de la version de référence et différez pour voir ce que vous changez. Oh, attendez, la référence a changé depuis que j'ai commencé à travailler, donc je ne peux plus faire de différence. Et je ne pensais pas garder une copie vierge du code sur lequel j'ai basé mes modifications.

Avec un VCS, vous faites juste quelque chose comme git difftout de suite, et vous changez par rapport à la bonne version du code sur lequel vous êtes basé.

Je dois conserver mes journaux de débogage

Vous êtes donc un méchant et n'utilisez pas la journalisation? Vous avez dû saupoudrer printfs dans toute votre base de code jusqu'à ce que vous trouviez tous ces morceaux de ce méchant bug? Vous en avez maintenant trouvé un, corrigé, mais vous souhaitez conserver votre code de débogage soigneusement conçu pour résoudre les problèmes restants.

Sans VCS, vous devez soit copier les fichiers, développer le code de débogage (ce qui peut ajouter des erreurs d'édition), pousser cela et remettre vos fichiers sauvegardés. Oh, mais il semble que du code de débogage soit entré de toute façon.

Avec git, il vous suffit de git add --patchsélectionner les quelques lignes de code que vous souhaitez mettre dans votre commit, et vous ne pouvez valider que cela. Ensuite, vous reprenez votre travail et avez toujours votre code de débogage. Vous n'avez pas eu à toucher le code, donc aucune erreur de copier / coller.

La grosse boule de boue

Sans VCS, les gens travaillent de leur côté et vous donnent un tas de changements, parfois sans rapport. Lorsqu'il y a trop de code à vérifier, il est difficile de trouver un bogue.

Un VCS vous permettra d'effectuer de petites modifications incrémentielles et vous donnera un journal des modifications. Le changelog est essentiel: les gens doivent dire qu'il pourquoi ils font le changement, et non pas ce qui est le changement (la quelle question est alredy répondu par le changement de code lui - même). Cela signifie que lorsque vous inspectez du code d'une nouvelle fonctionnalité par exemple, vous n'aurez pas à lire de nombreuses modifications mixtes non liées, comme des corrections de bogues non liées. Cela permet de se concentrer sur le code qui vous intéresse.

Si je vous donne 100 pommes de terre 1 par 1, et qu'une est pourrie, vous la trouverez immédiatement. Maintenant, si je dépose 100 pommes de terre devant vous et vous demande de trouver celle qui est pourrie, ce n'est pas la même tâche.

Échancrure

J'espère que vous avez une bonne politique de style de codage, sinon les changements d'indentation vous rendront fou si vous fusionnez à la main. Bien sûr, vous pouvez ignorer les espaces dans les modifications (mais pas dans les langues lorsque l'indentation compte, comme Python). Mais alors vous aurez du code bizarre difficile à lire.

Vous êtes chef de projet

Si vous êtes le leader, cela signifie que vous serez blâmé si les choses ne fonctionnent pas. Si vous n'êtes pas à l'aise avec la situation parce que votre patron ne comprend toujours pas que l'utilisation du bon outil pour le bon travail en vaut la peine, alors au moins, je refuserais de devenir le leader d'un échec prévisible.

Utilisez dropbox, il a un historique de version automatique. Vous pouvez partager le dossier de dépôt entre plusieurs utilisateurs.

Éditer

Vous pouvez également télécharger TortoiseSVN-client et créer un "référentiel local" sur le lecteur réseau. Ensuite, les gens peuvent extraire le code source par emplacement de dossier réseau.