Quelle est la différence entre Mercurial et Git?

J'utilise git depuis un certain temps maintenant sur Windows (avec msysGit) et j'aime l'idée du contrôle de source distribué. Récemment, j'ai regardé Mercurial (hg) et ça a l'air intéressant. Cependant, je ne peux pas comprendre les différences entre hg et git.

Quelqu'un a-t-il fait une comparaison côte à côte entre git et hg? Je suis intéressé de savoir ce qui diffère hg et git sans avoir à sauter dans une discussion fanboy.

Ces articles peuvent aider:

• Git contre Mercurial: veuillez vous détendre (Git est MacGyver et Mercurial est James Bond)
• Les différences entre Mercurial et Git

Edit : Comparer Git et Mercurial à des célébrités semble être une tendance. En voici encore un:

• Git est Wesley Snipes, Mercurial est Denzel Washington

Je travaille sur Mercurial, mais fondamentalement, je crois que les deux systèmes sont équivalents. Ils fonctionnent tous les deux avec les mêmes abstractions: une série d'instantanés (changesets) qui composent l'histoire. Chaque changeset sait d'où il vient (le changeset parent) et peut avoir de nombreux changesets enfants. La récente extension hg-git fournit un pont à double sens entre Mercurial et Git et montre en quelque sorte ce point.

Git se concentre fortement sur la mutation de ce graphique historique (avec toutes les conséquences que cela implique) alors que Mercurial n'encourage pas la réécriture de l'histoire, mais c'est facile à faire de toute façon et les conséquences de le faire sont exactement ce que vous devriez vous attendre à ce qu'elles soient (c'est-à-dire , si je modifie un ensemble de modifications que vous avez déjà, votre client le verra comme nouveau si vous retirez de moi). Mercurial a donc une préférence pour les commandes non destructives.

En ce qui concerne les branches légères, Mercurial prend en charge les référentiels avec plusieurs branches depuis ..., je pense toujours. Les référentiels Git avec plusieurs branches sont exactement cela: plusieurs volets de développement divergents dans un seul référentiel. Git ajoute ensuite des noms à ces brins et vous permet d'interroger ces noms à distance. L' extension Signets pour Mercurial ajoute des noms locaux, et avec Mercurial 1.6, vous pouvez déplacer ces signets lorsque vous poussez / tirez.

J'utilise Linux, mais apparemment TortoiseHg est plus rapide et meilleur que l'équivalent Git sur Windows (en raison d'une meilleure utilisation du pauvre système de fichiers Windows). Les deux http://github.com et http://bitbucket.org fournissent l' hébergement en ligne, le service à Bitbucket est grande et réactif (je n'ai pas essayé github).

J'ai choisi Mercurial car il est propre et élégant - j'ai été rebuté par les scripts shell / Perl / Ruby que j'ai obtenus avec Git. Essayez de jeter un œil au git-instaweb.shfichier si vous voulez savoir ce que je veux dire: c'est un script shell qui génère un script Ruby , qui je pense exécute un serveur web. Le script shell génère un autre script shell pour lancer le premier script Ruby. Il y a aussi un peu de Perl , pour faire bonne mesure.

J'aime le billet de blog qui compare Mercurial et Git à James Bond et MacGyver - Mercurial est en quelque sorte plus discret que Git. Il me semble que les utilisateurs de Mercurial ne sont pas si facilement impressionnés. Cela se reflète dans la façon dont chaque système fait ce que Linus a décrit comme "la fusion la plus cool JAMAIS!" . Dans Git, vous pouvez fusionner avec un référentiel non lié en faisant:

git fetch <project-to-union-merge>
GIT_INDEX_FILE=.git/tmp-index git-read-tree FETCH_HEAD
GIT_INDEX_FILE=.git/tmp-index git-checkout-cache -a -u
git-update-cache --add -- (GIT_INDEX_FILE=.git/tmp-index git-ls-files)
cp .git/FETCH_HEAD .git/MERGE_HEAD
git commit

Ces commandes me semblent assez obscures. Chez Mercurial, nous faisons:

hg pull --force <project-to-union-merge>
hg merge
hg commit

Remarquez à quel point les commandes Mercurial sont simples et pas spéciales du tout - la seule chose inhabituelle est le --forcedrapeau hg pull, qui est nécessaire car Mercurial abandonnera sinon lorsque vous tirez d'un référentiel non lié. Ce sont des différences comme celle-ci qui font que Mercurial me semble plus élégant.

Git est une plateforme, Mercurial est «juste» une application. Git est une plate-forme de système de fichiers versionnée qui est livrée avec une application DVCS dans la boîte, mais comme d'habitude pour les applications de plate-forme, elle est plus complexe et a des bords plus rugueux que les applications focalisées. Mais cela signifie également que le VCS de git est extrêmement flexible, et il y a une énorme profondeur de choses sans contrôle de source que vous pouvez faire avec git.

Voilà l'essence de la différence.

Git est mieux compris à partir du sol - du format du référentiel. Git Talk de Scott Chacon est une excellente introduction à cela. Si vous essayez d'utiliser git sans savoir ce qui se passe sous le capot, vous vous retrouverez confus à un moment donné (à moins que vous ne vous en teniez qu'à des fonctionnalités très basiques). Cela peut sembler stupide quand tout ce que vous voulez est un DVCS pour votre routine de programmation quotidienne, mais le génie de git est que le format du référentiel est en fait très simple et vous pouvez comprendre toute l'opération de git assez facilement.

Pour quelques comparaisons plus techniques, les meilleurs articles que j'ai personnellement vus sont ceux de Dustin Sallings:

• Les différences entre Mercurial et Git
• Fil Reddit où Dustin expérimenté répond aux questions de son propre néophyte

Il a en fait largement utilisé les deux DVCS et les comprend bien - et a fini par préférer git.

La grande différence est sous Windows. Mercurial est supporté nativement, Git ne l'est pas. Vous pouvez obtenir un hébergement très similaire à github.com avec bitbucket.org (en fait encore mieux car vous obtenez un référentiel privé gratuit). J'utilisais msysGit depuis un certain temps, mais j'ai déménagé vers Mercurial et j'en ai été très satisfait.

Si vous êtes un développeur Windows à la recherche d'un contrôle de révision de base déconnecté, optez pour Hg. J'ai trouvé Git incompréhensible alors que Hg était simple et bien intégré au shell Windows. J'ai téléchargé Hg et suivi ce tutoriel (hginit.com) - dix minutes plus tard, j'avais un dépôt local et j'étais de retour pour travailler sur mon projet.

Je pense que la meilleure description de "Mercurial vs. Git" est:

"Git est Wesley Snipes. Mercurial est Denzel Washington"

Ils sont presque identiques. La différence la plus importante, de mon point de vue (je veux dire, la raison qui m'a amené à choisir un DVCS plutôt qu'un autre) est la façon dont les deux programmes gèrent les branches.

Pour démarrer une nouvelle branche, avec Mercurial, il vous suffit de cloner le référentiel dans un autre répertoire et de commencer à développer. Ensuite, vous tirez et fusionnez. Avec git, vous devez explicitement donner un nom à la nouvelle branche de sujet que vous souhaitez utiliser, puis vous commencez à coder en utilisant le même répertoire .

En bref, chaque branche de Mercurial a besoin de son propre répertoire; dans git, vous travaillez généralement sur un seul répertoire. Changer de branche dans Mercurial signifie changer de répertoire; dans git, cela signifie demander à git de changer le contenu du répertoire avec git checkout.

Je suis honnête: je ne sais pas s'il est possible de faire de même avec Mercurial, mais comme je travaille habituellement sur des projets web, utiliser toujours le même répertoire avec git me semble très confortable, car je n'ai pas besoin de re -configurez Apache et redémarrez-le et je ne salis pas mon système de fichiers à chaque fois que je branche.

Edit: Comme Deestan l'a noté, Hg a nommé des branches , qui peuvent être stockées dans un seul référentiel et permettre au développeur de changer de branche dans la même copie de travail. Les branches git ne sont pas exactement les mêmes que les branches nommées Mercurial, de toute façon: elles sont permanentes et ne jettent pas les branches, comme dans git. Cela signifie que si vous utilisez une branche nommée pour des tâches expérimentales même si vous décidez de ne jamais la fusionner, elle sera stockée dans le référentiel. C'est la raison pour laquelle Hg encourage l'utilisation de clones pour des tâches expérimentales de courte durée et des branches nommées pour des tâches de longue durée, comme pour les branches de publication.

La raison pour laquelle de nombreux utilisateurs de Hg préfèrent les clones à la branche nommée est beaucoup plus sociale ou culturelle que technique. Par exemple, avec les dernières versions de Hg, il est même possible de fermer une branche nommée et de supprimer récursivement les métadonnées des changesets.

De l'autre côté, git invite à utiliser des "branches nommées" qui ne sont pas permanentes et ne sont pas stockées en tant que métadonnées sur chaque ensemble de modifications.

De mon point de vue personnel, le modèle de git est donc profondément lié au concept de branches nommées et de basculer entre une branche et une autre avec le même répertoire; hg peut faire la même chose avec des branches nommées, mais pourtant, cela encourage l'utilisation de clones, que je n'aime pas trop personnellement.

Il y a une énorme différence entre git et mercurial ; la façon dont les représentent chaque commit. git représente les commits comme des instantanés, tandis que mercurial les représente comme des diffs.

Qu'est-ce que cela signifie dans la pratique? Eh bien, de nombreuses opérations sont plus rapides dans git, comme passer à un autre commit, comparer les commits, etc. Surtout si ces commits sont loin.

AFAIK il n'y a aucun avantage à l'approche de mercurial.

Rien. Ils font tous les deux la même chose, tous les deux se comportent à peu près également. La seule raison pour laquelle vous devriez choisir l'un plutôt que l'autre est si vous aidez un projet qui en utilise déjà un.

L'autre raison possible de choisir un est une application ou un service qui ne prend en charge qu'un seul système. Par exemple, j'ai plutôt choisi d'apprendre git à cause de github ..

Aussi la comparaison de Google (bien que ce soit un peu vieux, fait en 2008)

http://code.google.com/p/support/wiki/DVCSAnalysis

Si je les comprends bien (et je suis loin d'être un expert dans chacun), ils ont fondamentalement chacun une philosophie différente. J'ai d'abord utilisé du mercure pendant 9 mois. Maintenant, j'ai utilisé git pour 6.

hg est un logiciel de contrôle de version. Son objectif principal est de suivre les versions d'un logiciel.

git est un système de fichiers basé sur le temps. Son objectif est d'ajouter une autre dimension à un système de fichiers. La plupart ont des fichiers et des dossiers, git ajoute du temps. Le fait qu'il fonctionne à merveille en tant que VCS est un sous-produit de sa conception.

Dans hg, il y a un historique de l'ensemble du projet qu'il essaie toujours de maintenir. Par défaut, je crois que hg souhaite que tous les changements soient apportés à tous les objets par tous les utilisateurs lorsqu'ils poussent et tirent.

Dans git, il n'y a qu'un pool d'objets et ces fichiers de suivi (branches / têtes) qui déterminent quel ensemble de ces objets représente l'arborescence de fichiers dans un état particulier. Lorsque vous poussez ou tirez, git envoie uniquement les objets nécessaires aux branches particulières que vous poussez ou tirez, ce qui est un petit sous-ensemble de tous les objets.

En ce qui concerne git, il n'y a pas de "1 projet". Vous pourriez avoir 50 projets tous dans le même dépôt et git s'en ficherait. Chacun pourrait être géré séparément dans le même référentiel et bien vivre.

Le concept de succursales de Hg est des succursales hors du projet principal ou des succursales, etc. Git n'a pas un tel concept. Une branche dans git n'est qu'un état de l'arbre, tout est une branche dans git. Quelle branche est officielle, actuelle ou la plus récente n'a aucun sens dans git.

Je ne sais pas si cela avait un sens. Si je pouvais dessiner des images hg pourrait ressembler à ceci où chaque commit est uno

             o---o---o
            /        
o---o---o---o---o---o---o---o
         \         /
          o---o---o

Un arbre avec une seule racine et des branches qui s'en détachent. Bien que git puisse le faire et souvent les gens l'utilisent de cette façon qui n'est pas appliquée. Une image git, s'il y a une telle chose, pourrait facilement ressembler à ceci

o---o---o---o---o

o---o---o---o
         \
          o---o

o---o---o---o

En fait, à certains égards, cela n'a même pas de sens de montrer les branches dans git.

Une chose qui est très déroutante pour la discussion, git et mercurial ont tous les deux quelque chose appelé une "branche" mais ils ne sont pas à distance les mêmes choses. Une branche dans mercurial se produit lorsqu'il y a des conflits entre différents repos. Une branche en git est apparemment similaire à un clone en hg. Mais un clone, bien qu'il puisse donner un comportement similaire, n'est certainement pas le même. Considérez-moi les essayer en git vs hg en utilisant le repo de chrome qui est assez grand.

$ time git checkout -b some-new-branch
Switched to new branch 'some-new-branch'

real   0m1.759s
user   0m1.596s
sys    0m0.144s

Et maintenant en hg en utilisant clone

$ time hg clone project/ some-clone/

updating to branch default
29387 files updated, 0 files merged, 0 files removed, 0 files unresolved.
real   0m58.196s
user   0m19.901s
sys    0m8.957

Ces deux sont des points chauds. C'est à dire, je les ai courus deux fois et c'est la deuxième manche. Le clone hg est en fait le même que git-new-workdir. Les deux font un répertoire de travail entièrement nouveau presque comme si vous aviez tapé cp -r project project-clone. Ce n'est pas la même chose que de créer une nouvelle branche dans git. C'est beaucoup plus lourd. S'il existe un véritable équivalent de la ramification de git en hg, je ne sais pas ce que c'est.

Je comprends qu'à un certain niveau, hg et git pourraient être capables de faire des choses similaires. Si c'est le cas, il y a encore une énorme différence dans le flux de travail vers lequel ils vous mènent. Dans git, le workflow typique consiste à créer une branche pour chaque fonctionnalité.

git checkout master
git checkout -b add-2nd-joypad-support
git checkout master
git checkout -b fix-game-save-bug
git checkout master
git checkout -b add-a-star-support

Cela vient de créer 3 branches, chacune basée sur une branche appelée master. (Je suis sûr qu'il y a un moyen dans git de faire ces 1 ligne chacune au lieu de 2)

Maintenant, pour travailler sur celui que je fais

git checkout fix-game-save-bug

et commencer à travailler. Engagez des choses, etc. Passer d'une branche à l'autre, même dans un projet aussi grand que Chrome, est presque instantané. En fait, je ne sais pas comment faire ça en hg. Cela ne fait partie d'aucun tutoriel que j'ai lu.

Une autre grande différence. L'étape de Git.

Git a cette idée d'une scène. Vous pouvez le considérer comme un dossier caché. Lorsque vous vous engagez, vous ne validez que ce qui est sur la scène, pas les changements dans votre arborescence de travail. Cela peut sembler étrange. Si vous souhaitez valider toutes les modifications dans votre arborescence de travail, vous feriez ce git commit -aqui ajoute tous les fichiers modifiés à la scène, puis les valide.

Quel est l'intérêt de la scène alors? Vous pouvez facilement séparer vos commits. Imaginez que vous avez modifié joypad.cpp et gamesave.cpp et que vous souhaitez les valider séparément

git add joypad.cpp  // copies to stage
git commit -m "added 2nd joypad support"
git add gamesave.cpp  // copies to stage
git commit -m "fixed game save bug"

Git a même des commandes pour décider quelles lignes particulières du même fichier vous souhaitez copier sur la scène afin que vous puissiez également diviser ces validations séparément. Pourquoi voudriez-vous faire ça? Parce que les commits séparés, les autres ne peuvent extraire que ceux qu'ils veulent ou s'il y a eu un problème, ils peuvent annuler uniquement le commit qui avait le problème.

Il y a un tableau de comparaison dynamique sur le versioncontrolblog où vous pouvez comparer plusieurs systèmes de contrôle de version différents.

Voici un tableau de comparaison entre git, hg et bzr.

Il existe des différences assez importantes en ce qui concerne le travail avec les succursales (en particulier à court terme).

Il est expliqué dans cet article (BranchingExplained) qui compare Mercurial à Git.

Y a-t-il des collaborateurs Windows sur votre projet?

Parce que s'il y en a, l'interface graphique Git-for-Windows semble maladroite, difficile, hostile.

Mercurial-on-Windows, en revanche, est une évidence.

Une chose à noter entre mercurial de bitbucket.org et git de github est que mercurial peut avoir autant de référentiels privés que vous le souhaitez, mais github vous devez passer à un compte payant. C'est pourquoi je choisis Bitbucket qui utilise mercurial.

L'an dernier, j'ai évalué à la fois git et hg pour mon propre usage, et j'ai décidé d'y aller avec hg. Je sentais que cela ressemblait à une solution plus propre et fonctionnait mieux sur plus de plates-formes à l'époque. Mais c'était surtout un coup sec.

Plus récemment, j'ai commencé à utiliser git en raison de git-svn et de la possibilité d'agir en tant que client Subversion. Cela m'a conquis et je suis maintenant passé complètement à git. Je pense qu'il a une courbe d'apprentissage légèrement plus élevée (surtout si vous devez fouiller à l'intérieur), mais c'est vraiment un excellent système. Je vais aller lire ces deux articles comparatifs que John a publiés maintenant.

Je suis actuellement en train de migrer de SVN vers un DVCS (tout en bloguant sur mes découvertes, mon premier véritable effort de blogging ...), et j'ai fait quelques recherches (= googler). Autant que je sache, vous pouvez faire la plupart des choses avec les deux packages. Il semble que git ait quelques fonctionnalités avancées plus ou mieux implémentées, je pense que l'intégration avec Windows est un peu meilleure pour mercurial, avec TortoiseHg. Je sais qu'il y a aussi Git Cheetah (j'ai essayé les deux), mais la solution mercurielle semble juste plus robuste.

Voyant comment ils sont tous deux open-source (non?) Je ne pense pas non plus qu'il manquera de fonctionnalités importantes. Si quelque chose est important, les gens le demanderont, les gens le coderont.

Je pense que pour les pratiques courantes, Git et Mercurial sont plus que suffisants. Ils ont tous les deux de grands projets qui les utilisent (Git -> noyau Linux, Mercurial -> projets de fondation Mozilla, les deux entre autres bien sûr), donc je ne pense pas qu'il manque vraiment quelque chose.

Cela étant dit, je suis intéressé par ce que les autres en disent, car cela constituerait une excellente source pour mes efforts de blogging ;-)

Le guide InfoQ sur DVCS contient de superbes et exhaustifs tableaux de comparaison et graphiques sur git, Mercurial et Bazaar .

Je me rends compte que cela ne fait pas partie de la réponse, mais sur cette note, je pense également que la disponibilité de plugins stables pour des plates-formes comme NetBeans et Eclipse jouent un rôle dans lequel l'outil est le mieux adapté à la tâche, ou plutôt, quel outil est la meilleure solution pour "vous". Autrement dit, sauf si vous voulez vraiment le faire de la manière CLI.

Eclipse (et tout ce qui en découle) et NetBeans ont parfois des problèmes avec les systèmes de fichiers distants (tels que SSH) et les mises à jour externes des fichiers; ce qui est encore une autre raison pour laquelle vous voulez que tout ce que vous choisissez fonctionne de manière "transparente".

J'essaie de répondre à cette question pour moi aussi en ce moment .. et j'ai résumé les candidats à Git ou Mercurial .. merci à tous d'avoir fourni des contributions utiles sur ce sujet sans devenir religieux.

Encore une autre comparaison intéressante de mercurial et git: Mercurial vs Git . L'accent principal est mis sur les internes et leur influence sur le processus de branchement.

Si vous êtes intéressé par une comparaison des performances de Mercurial et Git, consultez cet article . La conclusion est:

Git et Mercurial tournent tous les deux en bon nombre mais font un compromis intéressant entre la vitesse et la taille du référentiel. Mercurial est rapide avec des ajouts et des modifications, et maintient la croissance du référentiel sous contrôle en même temps. Git est également rapide, mais son référentiel se développe très rapidement avec les fichiers modifiés jusqu'à ce que vous reconditionniez - et ces reconditionnements peuvent être très lents. Mais le référentiel compressé est beaucoup plus petit que celui de Mercurial.

Le site Web mercurial a une grande description des similitudes et des différences entre les deux systèmes, expliquant les différences de vocabulaire et les concepts sous-jacents. En tant qu'utilisateur git de longue date, cela m'a vraiment aidé à comprendre l'état d'esprit de Mercurial.

Si vous migrez depuis SVN, utilisez Mercurial car sa syntaxe est BEAUCOUP plus compréhensible pour les utilisateurs de SVN. A part ça, vous ne pouvez pas vous tromper non plus. Mais vérifiez le tutoriel GIT et HGinit avant de sélectionner l'un d'entre eux.

Ce lien peut vous aider à comprendre la différence http://www.techtatva.com/2010/09/git-mercurial-and-bazaar-a-comparison/

Certaines personnes pensent que les systèmes VCS doivent être compliqués. Ils encouragent à inventer des termes et des concepts sur le terrain. Ils penseraient probablement que de nombreux doctorats sur le sujet seraient intéressants. Parmi ceux-ci se trouvent probablement ceux qui ont conçu Git.

Mercurial est conçu avec une mentalité différente. Les développeurs ne devraient pas se soucier beaucoup de VCS et devraient plutôt consacrer leur temps à leur fonction principale: l'ingénierie logicielle. Mercurial permet aux utilisateurs d'utiliser et d'abuser avec plaisir du système sans les laisser faire des erreurs non récupérables.

Tout outil professionnel doit être livré avec une CLI clairement conçue et intuitive. Les utilisateurs de Mercurial peuvent faire la plupart du travail en émettant des commandes simples sans aucune option étrange. Dans Git double dash, les options folles sont la norme. Mercurial a un avantage substantiel si vous êtes une personne CLI (et pour être honnête, tout ingénieur logiciel qui se respecte devrait l'être).

Pour donner un exemple, supposons que vous effectuez une validation par erreur. Vous avez oublié de modifier certains fichiers. Pour annuler votre action dans Mercurial, il vous suffit de taper:

$ hg rollback

Vous obtenez alors un message indiquant que le système annule votre dernière transaction.

Dans Git, vous devez taper:

$ git reset --soft HEAD^

Donc, supposons que vous ayez une idée de la réinitialisation. Mais en plus, vous devez savoir ce que sont les réinitialisations "--soft" et "--hard" (des suppositions intuitives?). Oh et bien sûr, n'oubliez pas le caractère '^' à la fin! (maintenant au nom de Ritchie, c'est que ...)

L'intégration de Mercurial avec des outils tiers tels que kdiff3 et meld est également bien meilleure. Générez vos patchs fusionnez vos branches sans trop de tracas. Mercurial comprend également un simple serveur http que vous activez en tapant

hg serve

Et laissez les autres parcourir votre référentiel.

En fin de compte, Git fait ce que fait Mercurial, d'une manière beaucoup plus compliquée et avec une CLI bien inférieure. Utilisez Git si vous souhaitez transformer le VCS de votre projet en un domaine de recherche scientifique. Utilisez Mercurial si vous voulez faire le travail VCS sans vous en soucier et concentrez-vous sur vos tâches réelles.