A magazine about programmers, code, and society. Written by humans since 2018.

Linus Torvalds

The tech industry is a fertile ground for anecdotes starred by individuals qualifying as brilliant jerks, psychopaths, and other atrocious types of personality. Suffice to say that, from the height of their positions of supposed leadership, many chose the easy path of advancing a twisted agenda that feeds into their hubris, in the detriment of the wider advancement of society.

Let us name a few such individuals: Larry Ellison, Bill Gates, Mark Zuckerberg, Steve Jobs, Richard Stallman, John McAfee, Peter Molyneux, Travis Kalanick, Adam Neumann, Scott McNealy, Elon Musk, Jeff Bezos, Peter Thiel, and Evan Spiegel. The list could go on and on, but for the sake of brevity, we will stop here. It should be no surprise to anyone that Linus Torvalds (or at least, his pre-2018 persona) belongs to this group, too.

Just like Reed Hastings and Satya Nadella have decided to get rid of brilliant jerks in their own corporations, our world at large would benefit from discouraging people from treating others like shit. To a large degree, the types of personality that engage in such behavior do not realize the harm caused around them, in particular, in the long term. In the short term, such words can cause laughter, but they also impregnate the minds of those who attentively listen, and create a tacit sense of approval to engage in similar behavior.

This is a terrible, horrendously vicious circle, and it has to stop.

The Vidéothèque movie of this month, published in 2007, is a sad example of this situation. It was one of the Google TechTalks we mentioned last year in this magazine. This one features Linus Torvalds explaining the history and architecture of Git, the most widely used source control system at the time of this publication but an entirely new kid on the block when the video was filmed.

The Good Parts

Let us start with the more benign parts. After diving into the history of the Git, the architectural talk is divided into three sections, each highlighting a particular aspect of the design and architecture of Git: its distributed nature, its high performance by design, and its absolute reliability. Taken together, these three aspects provide a simple answer to the enduring success that Git has had in the past 17 years, certainly explaining its becoming the de facto standard for source code management in our industry.

Speaking about its distributed aspect, and apart from the obvious (and dismissive) contrasts with CVS (“tarballs and patches are a much superior source control management system than CVS”) and Subversion, Linus mentions the Monotone version control system as an interesting inspiration, but lacking in performance. He also mentions Mercurial, as having mostly the same design as Git. He highlights the importance of being offline and how it literally means working in your own branch (we take branching for granted today, but 17 years ago, this was quite a revolutionary concept). Finally, he talks about how Git entered the enterprise space, first used as a client to access Subversion repositories (something I have personally done in the past when Subversion was still around). Also, related to corporations, he highlights an important, often overlooked aspect: that in a corporate environment, centralized systems work better.

Regarding the performance part, there are two significant points. First, that the mistake made by the designers of Subversion was to focus on the wrong problem: branching was not the issue; merging was. Second, that Git is fast because its code and data structures are really, really simple.

Finally, Linus mentions Git’s reliability as a result of an actual break-in attempt in the Linux kernel source code. This resulted in a natural outburst of paranoia, which in turn brought the choice of hashing every single change with SHA-1 (it is worth remembering that this algorithm was considered cryptographically secure in 2007, but “SHAttered” in 2017). Git is not only designed to handle as many files as needed, but also so that developers can trust each one of them, at all times. This was yet another revolutionary concept back then.

The Unnecessary Parts

Mixed with the juicy technical bits, there is a third aspect of this talk that makes it relevant, but for all the wrong reasons: a seemingly endless stream of criticisms, negativity, and (supposedly) self-deprecating remarks that end up being punches against anyone or anything Linus happens to dislike.

Let us enumerate some gems: “the designers of Subversion were complete morons“; “nobody actually creates perfect code the first time around except me“; “I think most of you are completely incompetent“; “the KDE people are… well…”; “when I merge from somebody, I trust them, but on the other hand, they might have stopped using their medication“; und so weiter.

Yes, there is a “content advisory” at the beginning of the talk. But none of this is needed, so let us focus on the good parts, of which there are many.

Balancing Acts

Maybe the issue at the core is that I am getting old. Because yes, I vividly remember laughing loudly when I watched this talk for the first time in 2007, and engaging in similar remarks and ways of thinking. Older entries of my own blog are filled with such vitriol. I have given talks (some of which are on YouTube) with such remarks. So, yes, I plead guilty to condoning such behavior, your honor.

I do not approve this anymore. With hindsight, I realize that we (as a society) do not need any more of this. And please refrain from arguing on Reddit or elsewhere that this is just me lacking humor. First, yes, I never had any. And second, it is objectively repugnant, no matter how you look at it. So, you have been warned; definitely watch this month’s Vidéothèque entry of Linus Torvalds, but be aware of foul remarks here and there.

But I have to be fair. 17 years have passed since this video, and in 2018 Linus has apologized for years of ranting, and I think that as a result, the whole IT field (and in particular, the Linux galaxy) is a far better place because of that.

Even more: I am positively in awe when faced with the incomparable talent of Linus and the brilliancy of his creations. His work has been a definitive positive source of change and wealth for the whole planet; mankind is collectively better because of his work. The Linux kernel and the Git version control system are both incommensurately valuable and brilliant, and have had (and will have) a transforming impact on the history of mankind. Each in itself would have been a remarkable achievement; taken together, they confirm the magnificence of the creative mind at their origin.

(There is also a possible argument to be made here, that Linux and Git are so good precisely because Linus cares so much, and is so passionate about his creations. I do not know him in person, but I think there might be a certain truth in this possibility, too. I certainly hope so.)

However brilliant, we do not need any more brilliant jerks spewing abusive thoughts towards other creators, particularly when their only sin was that of coming up with ideas that you just happen to dislike. We do not need such statements neither on record nor in other public or private spaces, no matter how good they are, or how big or small their impact on this planet may be. We should collectively let our work speak for ourselves, direct our cynicism and anger toward the resolution of actual world problems (there are a lot of those to choose from), and remember to have some respect for one another.

Cover snapshot chosen by the author from the video.

Continue reading Travis Swicegood or go back to Issue 066: Version Control. Did you like this article? Consider subscribing to our newsletter or contributing to the sustainability of this magazine. Thanks!
Back to top