Proud to be a Moron – My Journey with Git

Do you remember Linus Torvald’s talk at Google where he presented Git? He called everyone a moron who was not thinking that Git was the greatest version control system of all time. He especially scoffed members of the Subversion team, who were present at this talk:

I’m using Git for several years now. And it has a lot of cool stuff.

Let me mention the three things I like most about Git:

  • Speed
  • “git blame”
  • The powerful collaboration tools based on Git like “Gerrit” or „GitHub“

My long experience in IT industry has given me the chance to use a lot of different version control systems in my professional life. Let me list the most relevant ones:

  • SCCS
  • ClearCase
  • SubVersion
  • Perforce

All of these previous ones were classic central version control systems. Git was the first distributed version control system that I was using. I liked Git from the beginning, but I also knew very quickly that it was more powerful (more complex?) than any of the other VCS I used before. But as a techie I was eager to use something new and cool, and I was sure that soon I could use all the power of Git and it would help and support me in my everyday life as a software developer.

So, time went by…

After using Git for quite some time I still could not leverage the advantage of all this power and complexity. My main job is to invent powerful software solving complex problems. The tools I’m using (like Git) should help me getting my main job done. But after a significant amount of time using Git, I still experienced that with Git I had to deal much more with “low-level” stuff than with any other VCS I’ve used before. Git took more time and more brain capacity from me than any previous VCS. But I didn’t get enough in return to compensate this.

The Git community did quite a good job in spreading the idea that guys who don’t understand Git aredumb-asses and don’t deserve to use Git. I think this mindset has started with Linus “Morons” speech at Google. I began to assimilate this and felt bad being one of these dumb-asses. I thought this might be because of my age and tried not to think about it too much. I especially didn’t dare talking much about it because then all the Git-Lovers would consider me as an old dumbass moron.

Drilling down on the Git perception…

I felt that I should dig a little more into why some people don’t like Git, but even more I wanted to find out more who are the ones that always tell me that this thing is the greatest VCS on earth.

My experience was that those people who loved Git most, are not the ones that use just as a VCS tool (like myself and probably most “ordinary” software developers). It are the ones whose “main job” is to build something “with” or “around” Git.

Let me give you two examples from within SAP. First there are my “EGit” colleagues. They provided the integration of Git into the Eclipse development platform (check out their cool stuff here: . The other ones are the my colleagues providing infrastructural tools and services in the area of software lifecycle management.

For all these people Git is not only a tool to get their main job done. Git is a significant part of their main job. They deal so much with it, that they finally know every side effect of every Git command. They get used to all this, and in the end they perform every Git related task with virtuosity. On the other hand they are often contextually so far away from the everyday life of an ordinary developer (who uses Git “only” as a version control system) that they don’t understand why people have problems with the power and complexity of Git.

So these poeple love Git. How about the other ones? Are there really just a few old dumbass morons that have problems with Git (like me)? Well, first I looked around in the area of colleagues that I work with regularly. One of them is among the best software architects that we have in this company. Another one holds a PhD in astrophysics and has literally done rocket science software (at ESA). The third one holds a PhD in Chemistry and currently working on a topic that would put knots into my mind. All these three guys are intellectually far beyond my skills, but when I talk to them in private they all admit that they are pissed using Git because it sucks out their brains more than any other VCS tool in the past. Git distracts them significantly more than other VCSs from getting their “main work” done.

OK, these are only three people that I know in person, so that’s maybe not a general issue. I checked out what I can find on the internet. Of course I know that for every successful product, there are millions complaining that this product is bullshit. So I didn’t look much on how much stuff I will find on the internet. I focused on WHAT they were complaining about in the context of Git.

What I found had a pretty good match with my experiences. The “ordinary” developers that mainly create software very often felt overwhelmed and confused by the power of Git. Whereas people working in “Software Lifecycle Management” mostly love it. These are the ones who juggle with branches and code-lines and try to create product out of the many contributions by all the software developers.

Actually Git supports exactly the job the Linus Torvalds does in the context of the Linux development. Guess what, it’s no wonder that Linus created a tool that fits perfectly to his needs. And looking at the personality of him, it’s also no wonder that Linus doesn’t care very much about the “others” (morons).

Let me give you a good example of criticizing opinions on Git:

Things of that page that I also fully support are aspects like:

  • “Complex information model”
  • “Information model sprawl”
  • “Leaky abstraction”
  • “Power for the maintainer, at the expense of the contributor”
  • “Burden of VCS maintenance pushed to contributors”

Sooooo, what do I want?

Let me be clear. Git provided so many solutions possibilities in the area of version control and software lifecycle management.  It united the diversity of many different VCS solutions of the past by providing an accepted world-wide standard. Git is the VCS of the 21stcentury.

But there are still some more things… (not just one more thing :-))

  • I want to talk open about the weaknesses of Git
  • I want that the “Git lovers” stop considering everyone as “moron” or “dumbass” who doesn’t also love Git in its entirety
  • I want that Git improves and becomes simpler for the “ordinary development tasks”

But mainly I want that that developers speak up and also tell their doubts about Git and thereby help improving Git.

You are not a moron if you don’t love Git!

Until this this happens, I’ll stay “proud to be a moron”.

Let me close with two statements of the creator of Git, Linus Torvalds.

The first one is a reply to someone who asked him why he doesn’t use C++ (instead of C) in the Linux development.

„*YOU* are full of bullshit. C++ is a horrible language.“

Secondly in his famous Git talk he said:

I think the designers of subversion were complete morons. Strong opinions, that’s me, right?

There are a few of them in the room today, I suspect. You are stupid.

So let’s altogether continue using the VCS invented by this lovely guy.


Martin “Proud to be a Moron” Kolb

2 Kommentare zu „Proud to be a Moron – My Journey with Git

  1. I have used subversion and git, and have felt the social pressure to abandon subversion. Eventually I’ve managed to use git well, but honestly, it is almost too complex. If you want to get something done and git is only a problem in the way, it is going to breed resentment and waste time(money). The architecture of git lends itself to this kind of problem. Not everyone who needs to crop a photo should have to learn the complexities of photoshop. It is the same way with VCS software. I appreciate the power of GIT and see its many advantages, but I’m hoping that some day we will see a new git that is friendlier. Of particular concern to me is commit visualization. Many tools are available, but running them side-by-side does not produce the same picture of repo activity. This is not a good situation; where is the baseline of truth for „what happened?“

    Gefällt 1 Person

  2. I’m a developer. I’m not building a product around Git. And yet I *love* Git for its power and flexibility, and would not go back to SVN.

    Also, I’ve taught other developers to use Git effectively. And in the course of that, I’ve realized something: Git is actually very easy to understand *if* you start with one key observation.

    That observation is that Git, at its core, only really does two things. It creates commits on the tree in your local repo, and it synchronizes commits between your local repo and remote repos. It can do this because every commit knows the ID of its parent commit, and thus knows where to attach itself to the tree when synced.

    That’s it. That’s all you need to know to use Git effectively. (Well, that and the fact that while you *can* change history, you generally shouldn’t.)

    I won’t call you a moron for not understanding how to work with this. Rather, I’ll call morons the people who *teach* Git in a way that obscures that simple core model.


Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

Du kommentierst mit Deinem Abmelden /  Ändern )

Google Foto

Du kommentierst mit Deinem Google-Konto. Abmelden /  Ändern )


Du kommentierst mit Deinem Twitter-Konto. Abmelden /  Ändern )


Du kommentierst mit Deinem Facebook-Konto. Abmelden /  Ändern )

Verbinde mit %s