Some people mean that Git's model is complicated, which what you're talking about. I actually find its model very simple, some people find it complicated, but at any rate, I certainly think Git and Mercurial have comparable complexity in the model.
What most people mean, though, is that Git's UI is complicated. To be blunt, I think this is simply objectively correct. For example, "git checkout foo" might mean go to the foo branch, or might mean revert a file called "foo". There is no way to know. If you want to be sure to revert a file called foo, you can do "git checkout -- foo", I believe, but I don't know a branch equivalent (and it at any rate won't be symmetrical). Want to create a new branch? That's "git checkout -b newbranch". Want to delete it? That's "git branch -d newbranch". There are tons of things like this in the Git UI, where commands have basically arbitrary parameters in different contexts.
Way back when Git was first created, the plan was for what is now called Git to be the underlying implementation of a higher-level UI. I really, profoundly wish that had actually panned out. Instead, Git's low-level commands gradually grew more user-friendly until it hit the "good enough" zone. That's what people usually mean when they say Git's complicated.
Want to revert your changes? That's unpacking from the repo to the working dir. Want to switch to a different branch? That's also unpacking files from the repo to the working dir. The only difference is that in one case the current working branch stays the same and in one case it changes (or you could look at it as in one case you set it to the current value and in the other you set it to something different).
This is why people say you need to understand the underlying model of git to grok it. The commands make perfect sense from the perspective of the data model.
Also, want to create a branch? "git branch new-branch". Delete it "git branch -d new-branch". The "checkout -b" is an optimization, just like "rm -r x" is an optimization of "find x | xargs rm" (why do two commands when you can do one?).
The only thing I don't like about git UI is that it can't decide what to call the "index". It's called "index", "staging area", and "cache" in various places (including command line flags), which is confusing.
Making people understand the internal data structures in order to understand a UI is... not good.
The "underlying model of git" that David refers to (blobs, trees, commits, tags, branches, HEAD, etc.) aren't seen as internal data structures to be glossed over by a UI. They're the very essence of git.
Users don't need to know the 'very essence' of a tool inorder to use it. Do you think that people who drive cars know in detail about how car works? They just need to know about starting a car, making it go forward, backward, parking etc and that's what most car drivers care about.
Git is like driving a manual transmission. In a manual car you have to understand that the clutch disengages the motor from the drive shaft and how the different gears work in general. It's not rocket science and most people can pick it up.
Git is nothing like driving manual.
> In a manual car you have to understand that the clutch disengages the motor from the drive shaft and how the different gears work in general.
No, you most definitely don't, that's complete lunacy. The vast majority of (manual) drivers[0] have no idea how things work and they don't give a fuck. Different gears are for "go faster" and "go slower", and the clutch is for "change gear". People learn to do it right because the alternative is to stall or get a horrible grinding sound and pay top bucks to get stuff fixed, not because they understand how things work under the hood.
[0] in countries where it's the norm, not in countries like the US where manual is for nerds and passioned
Sorry, that's exactly what I meant by "the different gears work in general". You need to understand that underlying model before you can make it work, even if it's only intuitive, and not cerebral.
> the clutch is for "change gear"
That, and it's also "don't stall when I stop".
I think most people understand that it disconnects the engine. I don't think that's as crazy a leap as "understanding the details of how a gearbox works" (which I don't even know, since I've never looked in one).
Anyway, I maintain that my analogy is apt.
No, you only need to understand what the final effect is. The vast majority of drivers neither understand nor care that gearbox speeds change the conversion ratio between the engine's rotating speed and the axle's, if you did and had to gear speeds would be labelled by their conversion ratio not 1-6 (and then you'd have to include the axle's conversion ratio in the mix). And I don't doubt that a Git-based gearbox would do exactly that, and that going in reverse would require either using an inverter or would require using a completely separate reverse transmission.
> Anyway, I maintain that my analogy is apt.
And I maintain that it is not.
I think professional drivers do indeed know how their car works. They certainly should.
We are talking about professional developers/programmers/devops here, right?
As to git's basic model - a dag of commits, with branches being little more than auto-updating labels for commits - that fit into place in the first 5 minutes of usage. My learning time with git was shorter than any previous source control I used, except for sourcesafe, in so far as that is a SCM.
If you want to revert/reset a file, why don't you just use the reset command? That seems like a more direct way than using checkout.
If you want to create a new branch, why not use "git branch branch-name"? As another said, the "git checkout -b branch-name" is just shorthand for convenience.
I've been learning git over a mere 2 months (I came from svn), I'm finding its UI to be very pleasant.
As someone else said, that index/staging/cached situation is bad, though.
* reverts one file
* reverts all files
* removes changes from the index, but doesn't otherwise change anything at all
* moves your branch, without changing any files
* moves your branch and changes all files
This rather makes my point."git checkout -b", meanwhile, is not a shorthand for "git branch something", but rather "git branch --track something origin/something", unless there is no "origin/something", in which case you are again correct.
Because that's what git tell you to do when you run "git status"
# (use "git checkout -- <file>..." to discard changes in working directory)
Some time around year 1960, the plan was to develop a language with syntax ("M-expressions") on top of the Lisp S-expressions.
We are still waiting, I guess.
Has anyone attempted to actually implement this? Building a 'VCS' on top of git but with a simple 'UI'?
[1] https://gist.github.com/russelldavis/e5173ce1269fae67baaf
You don't have to use Python to add more commands on top of Mercurial. Its CLI is also its API, just like git, and you don't typically have to use Python to write tools on top of hg, just like you don't typically need to write C to hack on top of git.
The stdout of hg is guaranteed to remain stable, so you can script it by just parsing stdout. The options are guaranteed to remain stable, so your old tools won't need to be updated in case hg's CLI some day changes, because its CLI never changes.
There are also a bunch of hg CLI commands that start with debug (e.g. hg debugparents or hg debugdag) that you can use to directly manipulate hg's internal revlog data structure and do fun things like create a corrupt repo, if that's what you want to do. :-)
Any first hand experiences with this?
http://inversethought.com/hg/revset/file/2ddbf1893f3b/lol.py
http://jordi.inversethought.com/blog/on-gitology/ explains git's complexity extremely well (without even getting into horribleness of the command line UI). The following is a key quote, though you should read the whole thing.
The following gitological concepts are not particular to git:
* repositories (repos)
* commits or changesets (csets)
* directed acyclic graph (DAG)
* branches
* pushing and pulling changes
* whole-repo tracking, not individual files
* rebasing csets
* pushing and pulling csets
The following are purely gitological and add unnecessary complexity, in addition to eventually being unavoidable:
* Exposing the index/staging area
* Exposing other implementation details: blobs, trees, commits, refs
* refs and refspecs
* Branches are refs
* Detached HEADs (a.k.a “not on a branch”)
* Distinguishing remote and local tracking branches
* Choosing which branch to pull onto
* Bare repos
* Hard, soft, mixed resets
* Porcelain vs plumbing
But after a while of working with both, you start seeing git and hg as relatively equal products, just with different UI quirks.
I eventually moved most of my projects to git, though. Not because I thought it was better, but because it was more widely used. And being the collaborative type, using git was the path of least resistance.
Using this workflow with mercurial is really frustrating when I do it - the occasional pull request for a python-based project. A git branch as a concept is really simple, the mercurial ways I just cant wrap my head around (granted I only use it occasionally).
As a platform I like how all the porcellain in mercurial is implemented in a high level python. I can only wonder how productive writing custom porcellain commands in mercurial is given that interface.