Use Mercurial, you Git!

It's a land rush of revision control, I tell ya! Among the stable of eager candidates for best-loved DVCS, Git and Mercurial seem to be the two tools capturing the most programmer heart-share for now.

Git is admired because Linus Torvalds wrote it, but Mercurial is better because he didn't.

Developers with refined sensibilities are in a tough spot right now. We'd clearly like something to take the place of centralized tools like Subversion. But why, oh why, does it have to be Git? Let's examine the hype and the reality:

"The user interface is... not too bad"

False. I've heard dozens of authors whining about Git's usability. I thought maybe they were overstating the case, or were just confused. Then I tried Git. If anything, they were being too kind. Git polluted my /usr/bin with nearly 150 distinct binaries. Mercurial has one.

And if you think that you only need one or two of those commands for daily use, you're an optimist. Check out the "easy use" guide from, by the way, an awesome Ruby project. You're expected to juggle, depending on how you count them, about ten commands, just for day-to-day work.

The git rebase command will save your changes away, update the topic branch, and then reapply them.... Warning! If you are sharing a branch, you must use: git merge master... Rebase causes the commit layout to change and will confuse anyone you've shared this branch with.

Huh? Blah blah blah Ginger blah blah. For day-to-day use of Mercurial, you only need hg fetch to get code, and hg commit to give code.

Git apologists will tell you that you need all these extra commands because Git was written with the "UNIX philosophy" of small tools that do only one thing, and do it really well. Which brings us to our next myth.

"Git... consists of many commands that do one thing well"

O RLY? From Git's own gurus:

Git checkout can do three separate things:

1. Change to a new head.
2. Revert changes to a small number of files.
3. Create a branch.

Those are pretty massively different tasks. So much for "doing one thing." I'll leave it as an exercise to the reader to debunk the "well" part. Hint: try using git for any non-trivial project.

Having lost the simplicity argument, Git-folk will try to tell you that the reason they dumped 150 pieces on your floor was so that you can build your own revision control software:

"It's not an SCM.... I bet you could make a reasonable SCM on top of it, though"

That was from Linus himself in the early days, though Git's recent admirers echo the same sentiment: "git is first and foremost a toolkit for writing VCS systems."

Who cares? I ordered a version control system, not a toolkit for building one! If I'd wanted building blocks for rolling my own, I'd have gone to Home Depot and bought a 1 and a 0. You can build any software you like out of those, including a source control tool.

Mercurial is a working DVCS right out of the box. Why not use it?

"The model is rock solid and infallible because it is simple."

Horseshit. I've even unwittingly repeated this stinker myself. Let's break it down a little. Quoth the explainers (alongside a rat's nest of UML, to boot):

The core Git filesystem can be explained as four types of objects: Blobs (files), Trees (directories), Commits and Tags.

Unfortunately, no, it can't. The core of Git may well be implemented as four kinds of things. But to get even the most basic tasks done, you need to know repositories, working trees, branches, remotes, masters, origins, index caches, and a bunch of other unexplained concepts.

The manual pages are no help, for the same reason that "look it up" is no help to someone with a spelling question. You have to know the name of the command before you can look it up. And the commands are so obliquely named that there's no way to reason upward from what you know about the alleged "four kinds of objects" to make an educated guess as to which of the 150 commands you're supposed to use.

"Git on Windows is only officially supported using Cygwin"

This is another way of saying, "Git is not supported on Windows."

I like Cygwin -- it's one of the few things that raises my (mandatory) Windows experience at work from "completely unbearable" to merely "excruciating." But forcing my teammates to download and wrestle with the Cygwin setup, much less learn Bash, makes Git a complete non-starter in the one place where it could do me some good.

Punting to Cygwin, in this day and age of awesome scripting languages (like the one Mercurial is based on) is basically shouting to the world, "I can't be bothered to do my job properly."

Actually, speaking of scripting, using Python is exactly why Mercurial can be so scriptable and extensible without dumping 150 inscrutable binaries into your /usr/bin.

"git is reliable"

I wanted to believe this. Really, really wanted to believe it. Unfortunately, Git fails at the most fundamental of source control tasks -- so much so that I'm going to have to take that up in a different post.

The short version is that Git encourages and even requires you to tamper with your project's source history, and that is a recipe for disaster, not reliability.

In summary: Git was created by a brilliant mind and is maintained by a posse of smart, motivated developers. But it's a stinker. Its power might justify the agonizing experience of using it, if there weren't any better alternatives. There are.

Code in good taste. Use Mercurial.

UPDATE 2008-2-6, 9 PM. In retrospect, a discussion on reliability should just be about data integrity: having a repository that's resistant to crashes and hardware failures and such. The concerns in the final section -- discovering how to get data reliably out -- are not a pronouncement on the resilience of the repository format. They have to deal with usability and coherence. "Reliability" as a fuzzy human term is too broad a word here.