Jan van den Berg

j11g.com

Tag: linus

  • Git is eating the world

    The inception of Git (2005) is more or less the halfway point between the inception of Linux (1991) and today (2019). A lot has happened since. One thing is clear however: software is eating the world and Git is the fork with which it is being eaten. (Yes, pun intended).

    Linux and Git

    In 2005, as far as Linus Torvalds’ legacy was concerned, he didn’t need to worry. His pet project Linux — “won’t be big and professional” — was well on its way to dominating the server and supercomputer market. And with the arrival of Linux powered Android smartphones this usage would even be eclipsed a few years later. Linux was also already a full-blown day job for many developers and the biggest distributed software project in the world.

    However, with the creation of Git in 2005, Linus Torvalds can stake the claim that he is responsible for not one, but two of the most important software revolutions ever. Both projects grew out of a personal itch, with the latter being needed for the other. The story of both inceptions are of course very well documented in the annals of internet history i.e. mailinglist archives. (Side note: one of Git’s most impressive feats was at the very early beginning, when Torvalds was able to get Git self-hosted within a matter of days 🤯).

    Today

    Fast forward to today and Git is everywhere. It has become the de facto distributed versioning control system (DVCS). However, it was of course not the first DVCS and may not even be the best i.e. most suitable for some use cases.

    The Linux project using Git is of course the biggest confirmation of Git’s powerful qualities. Because no other open source projects are bigger than Linux. So if it’s good enough for Linux it sure should be good enough for all other projects. Right?

    However Git is also notorious for being the perfect tool to shoot yourself in the foot with. It demands a different way of thinking. And things can quickly go wrong if you’re not completely comfortable with what you’re doing.

    Web-based DVCS

    Part of these problems were solved by GitHub. Which gave the ideas of Git and distributed software collaboration a web interface and made it social (follow developers, star projects etc.). It was the right timing and in an increasingly interconnected world distributed version control seemed like the only way to go. This left classic client-server version control systems like CVS and SVN in the dust (though some large projects are still developed using these models e.g. OpenBSD uses CVS).

    GitHub helped popularize Git itself. And legions of young developers grew up using GitHub and therefore Git. And yet, the world was still hungry for more. This was proven by the arrival of GitLab, initially envisioned as as SaaS Git service, most GitLab revenue now comes from self-hosted installations with premium features.

    But of course GitHub wasn’t the only web-based version control system. BitBucket started around the same time and offered not only Git support but also Mercurial support. And even in 2019 new web-based software development platforms (using Git) are born: i.e. sourcehut.

    Too late?

    However the fast adoption of tools like GitHub had already left other distributed version control systems behind in popularity: systems like Fossil, Bazaar and Mercurial and many others. Even though some of these systems on a certain level might be better suited for most projects. The relative simplicity of Fossil does a lot of things right. And a lot of people seem to agree Mercurial is the more intuitive DVCS.

    BitKeeper was also too late to realize that they had lost the war, when they open-sourced their software in 2016. Remember: BitKeeper being proprietary was one of the main reasons Git was born initially.

    Yesterday BitBucket announced they would sunset their Mercurial support. Effectively giving almost nothing short of a deathblow to Mercurial, as BitBucket was one of the largest promoters of Mercurial. This set off quite a few discussions around the internet. Partly because of how they plan to sunset their support. But partly also because Mercurial seems to have a lot of sentimental support — the argument being that it is the saner and more intuitive DVCS. Which is surprising because, as stated by BitBucket; over 90% of their users use Git. So there is a clear winner. Still the idea of a winner-takes-all does not sit well with some developers. Which is probably a good thing.

    Future?

    Right now Git is the clear winner, there is no denying that. Git is everywhere, and for many IDEs/workflow/collaboration software it is the default choice for a DVCS. But things are never static, especially in the world of software. So I am curious to see where we’ll be in another 14 years!

  • Just for Fun: The Story of an Accidental Revolutionary

    Just for Fun: The Story of an Accidental Revolutionary

    This book had been sitting on my to-read list for way too long! But I finally found a second hand copy, so here we go!

    You could say this is the official autobiography of Linus Torvalds, the creator of Linux. The Operating System that changed the world! You can wake me up in the middle of the night to talk about operating systems. So this book is right up my alley.

    It’s funny to think that more time has passed since this book came out (16 years), than the time there was between the birth of Linux and the release of the book (10 years). So an update would be welcome, however history = history and this book does a good job of documenting the rise of Linux. Even in 2001 it was clear that Linux was a huge force to be reckoned with and that it would only grow bigger from there. But I think few would suspect Linux would be the most used operating system in the world (largely) because of smartphones i.e. Android. Because people were still talking about the desktop in 2001.

    Celeb life.

    The book is structured around alternating chapters written by Linus himself and the writer David Diamond. It follows a chronological timeline. From young Linus to Linux, to underground celebrity status, to bonafide celebrity, to riches and world domination. The story is told in either conversation form between David and Linus or just plain old retelling facts. Because in 2001 things were relatively ‘fresh’ the book has some nice intricate details. Details that would probably be lost when you write a book about this subject 20 years from now. And that is probably what I liked most about it. I was familiar with most of the history, but this book does a great job of filling in the details to get a complete picture from a first degree account. Also there is quit a bit of room towards the end where Linus shares his thoughts on Intellectual Property, copyright and becoming rich (not Bill Gates rich, but still rich). Which was really interesting!

    Here are some take-aways from the book:

    • Linus is of course a programming genius. He wrote Linus when he was around 21. I would guess only a handful of people in the world were able to do what he did. And he did it at a young age. (He probably wouldn’t like this comparison: but it reminded me a lot of Bill Gates who wrote a BASIC interpreter when he was even younger.)
    • But the genius also manifests itself in the ability to make good design calls (very early on). I would even go so far as to state that his programming ability is surpassed by his talent to make the right choice (design, technical etc.)
    • He has proven this again, by unleashing git (the software versioning tool) to the world in 2005. Which made quite an impact on software development in general (e.g. it gave rise to Github) So not only did he start one of the first software revolutions, he also started the second! With git he doubled down on demonstrating the knack for making the right choices.
    • Even though he famously fell out with professor Tanenbaum, I love that he still states Tanenbaums’ book Operating Systems Design and Implementation as the book that changed his life.
    • He comes from a journalist family who were straight-up communist sympathizers and part of a Finnish minority that speaks Swedish. They also dragged young Linus to Moscow on occasion. And his grandfather was bit of a famous poet in Finland.
    • With this communist background in mind it is funny to think he is very much a pragmatist and not an idealist. But maybe exactly because of this. It’s a very conscious decision and he seems to have thought about it a lot and it permeates everything he does.
    • There is a lot of self-deprecating humor in this book.

      Linus Torvalds and Richard Stallman
    • There are quite a few sexual references. Linus starts the book with stating his view on the meaning of life: using sex as example.
    • The Tanenbaum discussion was about technical choices. The success of Linux sort of gave Linus the upper hand in the discussion. I think this irked Tanenbaum but I also suspect Tanenbaum felt that if he had just released his OS Minix to the world in the same manner Linus had, we probably wouldn’t have had Linux.
    • Stallman gave a talk at Linus’ university about GNU and this led to Linus choosing GPL as the license. And of course gcc was the programming language Linux was written in (developed by Stallman).
    • And this is key, Linus acknowledges this, his project came at the exact right time. A year later and someone else would have probably already done it. Or we would be all be using *BSD (who were still fighting other battles). A year early and no-one would have batted an eye, because too few people online were around to notice.
    • So the timing consist of 3 factors coming together: hence the word timing. The GNU license (invented by Stallman), the availability of cheap 386 processors and the internet. Take away either one and things would be different.
    • Most of all I think that the internet was key, because Linus found his co-creators there and feedback. But also because Linux became the de facto operating system for internet servers and was born around the same time the www was born. This is no coincidence. The internet en Linux grew up together.
    • Also one last point that proves he has good gut feeling, in 2001 he predicted the ubiquity of the smartphone:

    The title of the book is ‘Just for Fun’. And it is written with room for jokes and lighthearted thoughts. But there is also plenty of serious thought on ideals and pragmatism. But fun is the general theme throughout Linus’ life and the development of Linux. The fun that you get from following your curiosity, working hard on making it happen, and caring about what you do. The pragmatic approach of Linus to everything he does seems to create a sense of flow and he follows that flow and has fun with it. This is also backed by how an enormous project like the Linux kernel, which is the biggest software project in the world, is managed. The loose structure that dictates the development comes from flow.

    So all in all it’s a very fun book to read! Even if it’s from 2001 and a lot has happened since. I think there could be an updated version. Or you could ask yourself: “who, in 2017, is the equivalent of 1991 Torvalds?”. So, whose biography will we be reading in 10 years time? My money is on Vitalik Buterin (literally, I own Ethereum). He is a current day one-of-a-kind genius whose technology will probably change the world. Get it?