Some thoughts on Git vs complexity
I originally wrote this in the Git For Human Beings mailing list. The thoughts are stolen from Rich Hickey's Simple Made Easy talk. (Matthew McCullough commented the same parallel the same day, but I think his timestamp was a few hours afterwards). I wanted to tweet about it, but it ended up being a whole post, as I'm trying to gather my thoughts on it for my next Git talk.
There's simple stuff, and there's easy stuff.
Simple means the opposite of complex. Easy, on the other hand, means it's very close to the stuff you already know. Git is "simple" but hard. Subversion is "easy", but eventually complex.
Git is *a lot* of features in one tool (think of the 100+ git plumbing commands). Each feature is simple, but learning to use them together is good bit of work. As soon as you've understood the model and you get that Eureka-moment, the tool never fails you, and you find it more and more fun to use the more you learn. (This is why there are so many git enthusiasts, I reckon.)
Subversion has a very limited set of features.It also turns awfully complex when you want to do stuff like merging. Actually the more I learned about Subversion, and the more I used it, the more frustrating I found it.
Why is Subversion complex?
- Because the stuff on the server is something different from what you
have locally. Your local checkout is just a thin skin. All the
interaction goes over the network with a really thin and crappy API.
It’s like reading a book using binoculars. The same information is
there, but it’s horrible to get at it.
- Everybody is tangled together using the same repository. People start
making mistakes like committing without updating first. Everyone mis-use
trunk as their own sandbox. This is complexity too (everything in one
- It mixes together committing, and pushing the changes to central. A
commit should do one thing, and one thing well, and the reasoning should
be in the commit message. Some are refactorings, others are
- Because branches are completely disconnected - there’s nothing that ties them together, except being a lot like each other. That’s how merging in Subversion works: “I assume that these two directories will be very similar”, and if they aren’t, BOOM.
Git, on the other hand, is simple: It all boils down to being three kinds of objects in a graph (commits, blobs, trees), and the rest of it are algorithms that work this data-structure.