The package "gnuit" (GNU Interactive Tools, a file browser/viewer and process viewer) was called "git" in Debian up until 2009-09-09, while git was called "git-core".
Therefore, a better graph to look at is:
Which shows that the popularity did not rise dramatically (take the green line for the left part until they cross, then take the red line).
It does look like something happened that caused a spike in popularity.
It's less dramatic, but it does look like there's a pretty substantial increase that can probably be attributed to "using an easier to discover package name." Out of (genuine) curiosity, does the graph include Ubuntu users?
The number of popcon submissions in Ubuntu is one order of magnitude higher than the number of popcon submissions in Debian.
Unfortunately, I cannot find out whether Ubuntu makes the graphs publically accessible like Debian does.
2. Linus himself wrote it (the kernel previously used BitKeeper but that never got any real traction AFAIK).
Having said that, I think this phrase totally nails it:
"If it's good enough for the Linux kernel, it's good enough for you" is a very convincing argument.
For the longest time Github just wouldn't send a tar ball when you clicked the download button. And then around 2010, BitBucket was doing a lot of stuff behind the scene and the service was down a lot. A lot of basic features just wouldn't work. They were probably getting ready to sell to Atlassian.
I think that's the main #1 reason Git and Github took off.
Another one is Linus' diatribe on SVN. That video on youtube's been viewed millions of times. The video really got the Linux fanboys jumping around all excited even though its command line interface sucks and didn't work quite well on Windows.
for eg. it is comparable to the chart of Facebook growth
I personally still prefer bzr's cli.
Using it in your own ivory tower isn't going to impress anyone for the simple reason that no one sees it. Instead, people look at the broader world of all the interconnected git archives in the linux and web development communities, get excited, pull repos and learn git. There's just no equivalent in the hg community that I see. You guys have walled yourselves off, and it's killing your software.
Git just has a directed acyclic graph and pointers to the nodes of it. That's all. End of story.
Mercurial has the concept of a branch, a tag and so on as seemingly separate axiomatic things. It's not as stupid.
I like stupid.
Arguments can be made for both sides, picking a single design decision and saying that that’s obviously better is not going to work. Implementation and (especially in a case like distributed systems) network effects are much stronger than any single isolated design decision.
I would argue that in the case of Git it's not about a single design decision. The whole design is very simple and easily understandable. Thus everything can be derived from the design decisions.
The design decisions also have clear rationales.
"Why something is better" and "why something has "won"" are of course different questions that deserve different answers.
Of course, I may also be a terrible teacher.
I find it easy to teach, thanks the concepts being simple and clear. I don't have to transfer a lot of information before people can start reasoning about things themselves and independently finding out more.
I always try to make sure people understand two things:
1) The history tree (==how to read the metro-map that is gitk)
2) Distribution, that you are responsible for syncing with others, not the other way round
Almost everything else I prefer the students at least try to figure out themselves.
And of course, if mercurial could give me more features, I'd probably think twice. However, it's practically equivalent to git.
I was comparing git and mercurial, not giving the one true testament to comparison of every possible version control system.
If most of your work is done with one group of people inside your company and you decide mercurial is a better fit it would seem silly just to go with git because it is popular.
Besides the two are similar enough that someone versed in mercurial should be able to learn enough git to be useful quickly enough should it be required.
And I'm not saying you should choose git because it's better. I'm saying git "won" in the community because it was the choice of people who want to play in the community. Culture matters, and hg's proponents, for whatever reason, are less likely to want to share their stuff.
Do hg people "share less" or are there simply less of them? IIRC github allows commits from hg as well as git.
And of course not everyone (in fact possibly only the minority) is interested in cloning and issuing pull requests on OSS a huge amount of programming happens internally in corporations where everyone will use whichever VCS is mandated.
Subversion was indeed a much better CVS than CVS. And the world almost jumped on it as a standard. But then git appeared. If you were a young person looking at building exciting projects from source, you might never have reason to learn svn. I think that qualifies as "forgotten"
Network effect: many many people pick git because everyone else uses it (and that’s a good reason), thus they never try Mercurial, which may or may not be better suited to their use case.
I have some code in Git with my custom patches, with upstream being Hg. `git-hg' works like a charm -- simple, clean etc. etc.. Dunno what you are talking about here.
Git provides git-fast-export & git-fast-import as two-way interconnects, with well-defined data formats.
I clearly didn't, too, so I deleted the post.
2) Git is trivial to extend. If something for git doesn't exist that does not suggest any sort of arrogant attitude from git, but rather just a total lack of interest from both the developers and the community.
Using loaded terms to put down people who use the tool they prefer isn't going to convince anyone that your argument has merit.
 Now that you've drawn attention to it, I do indeed wish I'd phrased that differently. But certainly not because I hurt someone's feelings...
The new BitBucket is awesome, though.
At least that's how I see it.
Also, git is accumulating tooling and integration with other tools much more than hg is, afaict.
Free private repos are great, of course.
> I would have to say it's because not enough people have
> tried Mercurial
code control is a solved problem and people have moved on to do other things...
Mercurial has BitBucket and Bazaar has Launchpad, so they hardly 'loose' to git and GitHub here. There is but one thing that git does better (I'm forced to use git at work) - it's faster, or at least feels faster. Other than that, on the technical side, both Bazaar and Mercurial are I think on par with git and they win hands down in terms of ease of use.
So, yes, I would guess that the cause of git popularity is primarily Linus and then GitHub and then the popularity itself.
If all mercurial is bringing to the table is being a bit more pleasant, I am still going to pass over it for that reason.
 dvcs history locally should not be sacred, because rewriting experimental branches is necessary for clarity and to avoid polluting the main repository branches. dvcs history on a central repo can be made sacred with git by disabling non-ff commits and disabling deletes.
DVCS (either mercurial or git) seems to be a much more exotic concept for people unfamiliar with DVCS than MySQL/PostgreSQL is to those only familiar with, say, Oracle RDBMS.
I'm not a DBA though, so maybe I am wildly wrong with that thought.
(Also this comparison maps back to the topic incorrectly, in that I obviously greatly prefer PostgreSQL in the comparison, but I greatly prefer git in the other scenario).
Mercurial for anything smaller or startup. Love it. The issue with Mercurial is that you'll need to determine how you want to do automated deploy builds, but the code management is great and using BitBucket + Hg I never have trouble seeing which code I'm working in or resolving conflicts. I actually think Mercurial has the second-best visual branching display.
Real big enterprise cannot use TFS without being in a mess with merge. You always have to merge to a parent which require a lot of organisation. Also, it's not the fastest source control when the code base is over few gigs per branches. With over 50 developers/testers (in the same project) we had reach a bottleneck with TFS.
This is a BS argument.
Yes, everybody got it wrong, Git is wrong, SVN is wrong, it's CCs broken model that's correct.
" you need an army of administrators to make it work"
Yes, let's sink an awful amount of money in a half-baked software that needs all kinds of 'helpers' to work properly.
Personally I won't work in a company that uses CC anymore, and it's been only bliss since then.
Sourcesafe is bad, but it's a different kind of bad. And it makes even CC look good.
I personally started using git because github made setting up hosted version control so darned easy and nice. Also, I hated using SVN from my work life experience, so I knew I didn't want to use that on my own projects.
Once I understood the power of git branching there is no way I could ever go back. Also, I tried mercurial and it always felt slower and "worse". Git commands might be cryptic, but it's always felt faster and had a community around it that makes better tools for it.
Near the end he walked through the distributed nature of git. That was the second of third OSCON I attended, and I have never seen, nor have I seen since, that many utterly confused developers in a single room.
At the time I thought it was just a poor presentation.
With the benefit of hindsight, I've realized the presentation was just fine. We, the developers, just had that much baggage from using CSV and Subversion. "What do you mean forking isn't evil!" "What do you mean you can branch like that?"
It feels like, at some point, there was a tipping point of younger developers who didn't have to unlearn subversion. Makes me wonder what other heresies we'll do a 180 degree turn on in the future...
Mercurial is a much better fit for how my mind works than Git (I feel that Git is from the school that thrives despite complexity, where I prefer the school that puts lots of effort into a really clean model to minimize complexity).
But I am now giving up on Mercurial: every open source project I play with is on github, so I absolutely need to master Git - and I don't want to keep using two systems.
The network effect wins.
Perhaps the question should be closed with an "already answered" link to this: http://stackoverflow.com/questions/1598759/git-and-mercurial...
Edit: Followup with some more links:
I use Mercurial and Git every day, and I can tell you there's a marked difference between the usability of Mercurial and Git. Git would become totally unusable if it weren't for stackoverflow and google, while I can figure everything out just from Mercurial's short and sweet help manuals.
Learning Curve. Git has a steeper learning curve than Mercurial due to a number of factors. Git has more commands and options, the volume of which can be intimidating to new users. Mercurial's documentation tends to be more complete and easier for novices to read. Mercurial's terminology and commands are also a closer to Subversion and CVS, making it familiar to people migrating from those systems.
I really do think that Mercurial's user interface is easier for beginners to pick up, and more difficult to shoot oneself in the foot with. It's the little things, like the fact that Mercurial's push and pull commands do exactly the opposite of one another, that hg clone/pull URLs are identical to what you type into a web browser to browse the repo, and the ease of dealing with Mercurial "bare" repositories (hg up -r null) for mirroring and backup purposes.
And the way Mercurial's command-line interface strongly discourages one from modifying history; it makes it harder for things to get messed up on a small team coordinating with a shared-access repo. Yes, I know git has the reflog, but in general people seem to have much fewer "OMG WHAT JUST HAPPENED TO MY BRANCH" moments with Mercurial than with git. That (along with mq, which provided a unique solution to our team's needs) was the major reason I chose Mercurial over git at work. If we're going to brandish about the term "UX" here, then I'd say Mercurial definitely has a better "UX" than git.
But Mercurial has pain points, too. The biggest one, in my opinion, is the way branches work: Mercurial started out with named branches, which it seems the community has recognized as a mistake, and has moved to replace with git-style branches (called "bookmarks" in Mercurial land). These work better, but there are still some drawbacks: for one thing, Mercurial lacks the notion of a "remote", so unlike in git your local bookmarks and remote bookmarks have to share the same namespace. This leads to counter-intuitive behavior when it comes to synchronizing bookmarks with a remote server, and often you'll find that bookmarks aren't necessarily updated when you'd expect them to be.
Additionally, the notion of a "tip" makes working with feature branches frustrating, because by default Mercurial will check out from whatever branch was pushed to most recently, rather than a de-facto standard "master" as in git. Hand in hand with this complaint, by default Mercurial will want to push all your changesets, not just those under your current working bookmark, so you have to constantly specify e.g. "hg push -r master" to keep from pushing local throw-away branches. And it's not easy to delete local throw-away branches if you decide you don't want them (the downside of Mercurials aversion toward history modification), so one generally winds up using a separately-cloned repo for temporary work, which is unfortunate in contrast with git.
Mercurial and git are both great, efficient, high-performance tools. But if I had to generalize, I'd say that Mercurial is better for beginners and for "enterprisey" usage, whereas git, despite its interface inconsistencies, can be more powerful once you fully understand it and its data model (but only if you aren't working primarily on Windows, and don't need Mercurial Queues).
Again, I'll admit I'm biased (I'm mostly a Linux guy), but for the day job, they are currently paying me to develop stuff for Windows, and both myself (via Cygwin), and my current coding partner (via MSysGit) have no issues whatsoever with Git in Windows. A previous team member also quickly adapted to Git via TortoiseGit.
The flexibility of being able to rewrite history, the staging area, stashes and branching quickly are just too powerful, and being both code monkeys and CLI junkies, we don't miss the "integration" much (albeit, I love EGG: https://github.com/byplayer/egg).
Branching with bookmarks is very close to the way git usually handles branching. Mercurial bookmarks are like git refs: named pointers to changesets that move on commit.
Concludes that Git handles larger amounts of data more efficiently and stores revision info in a safer/clearer way. Git might be more arcane in terms of it's command syntax, but gets the job done.
Think of it exactly like an atomic bomb. Atomic bombs are simple: you need fissile material that decays and emits neutrons, and you need it to get close enough to keep a reaction going.
The fissile material in this case is the quality of the software. If it's good, consider it fissile. If it sucks, it probably ain't exploding anytime soon. Git is good. It works, it's fun to use, and it's collaborative.
The trigger was Linux. A large developer community suddenly was introduced to it, and used it day-to-day as Linus was still developing Git itself. The bomb had dropped.
Github was the mechanism itself. It brought all of the developers closer together (like neutrons) and the reaction started spreading. The quality of the experience ensured people actually wanted to be there, and to share it.
Critical mass of ~the social web~ anything in society. 1. Quality, 2. Trigger, 3. Social Mechanism. Boom.
Edit: no pun intended ;)
I looked at hg. It is easier, especially for the windows users. However, git was already coming from a few different directions and hg's simplicity was not enough to tip the scale.
We are now mid-migration. If git devs are listening - this is my biggest nit:
$ apropos git | grep ^git | wc -l
I do believe an alternative "porcelain" will eventually supplant the core git commands, making it more user friendly.
I would say mercurial is more polished on windows, taking tortoisehg into account. Maybe most mercurial users are on windows while most git users are on linux?
(now i don't believe that mercurial actually is bigger than git, even on windows, but the data from the post is still dodgy)
The "Linux uses git!"-argument is a good one but mercurial has an almost as good one: Firefox. So i don't think that would be an overwhelming factor.
If you can find the 'open source updates' from oscon on youtube/oreilly, Shawn Pearce gives an architectural update that will inform your speculations.
OTOH not having to do the merges on the shared repo is much better and avoids the "don't checkout HEAD just yet 'cos it's all manor of fucked up right now" problem.
Also poorly quantifiable is the sense of fear or anticipation that courses through your veins when you hear the phrase, in an SVN shop, "Hey, I've got a feature branch I want to merge in."