Linus Torvalds has been working on Linux for 32 years, longer than many software developers have been alive. Surprisingly though, Linux, Torvalds’ earliest “hobby project,” arguably gains in importance each year, despite its age. It’s rare for any software to remain relevant for a few years, much less a few decades. In the case of Linux, its ongoing relevance isn’t an accident. Instead, it’s a testament to some key lessons Torvalds has learned and applied for years. He shared some of those lessons at the recent Open Source Summit in Japan.
Among those lessons: figuring out how to collaborate with others and motivate contributors to ensure Linux keeps evolving. These are central to Linux’s success and, indeed, all successful software projects.
Working with the Linux community
“People seem to think that open source is all about programming,” Torvalds stresses, “but a lot of it is about communication.” For a demographic sometimes characterized as geeky hermits more comfortable with ones and zeroes than social engagement, this is an interesting insight. “People are hard,” he says, but “code is easy.”
No software—and certainly no open source software—is ever just a lone programmer in front of a computer. In the case of Linux, “We rely on literally thousands of people every single release,” says Torvalds. Complicating things, “We have a thousand people involved and they’re not the same thousand people.” Maybe half of those people will “send just one patch, and a lot of them never show up again.” Managing those thousands who return, as well as welcoming the thousands who “have something small they wanted to fix that they cared about,” takes a great deal of social skill.
To do this well requires more than just software development talent, Torvalds goes on. “Maintainers are the ones who translate,” by which he means “the context, the reason for the code.” It’s hard because “people relationships are hard.” Maintaining parts of the Linux kernel, or any significant software, requires “a certain amount of good taste to judge other people’s code,” which can be partially “innate,” he says, “but a lot of it just takes practice…[over] many years.”
For these reasons, “It’s hard to find maintainers [and] it’s much easier to find developers.” Writing software isn’t as hard as incorporating software into larger, functional systems. That takes people skills, not just coding. So how have Torvalds and the Linux kernel community managed to interweave younger developers and their ideas with more established people and practices?
Rust never sleeps
Despite the seeming perpetual youth of Linux adoption, the Linux kernel community hit AARP status a while back. During the next few years, some within the Linux kernel community will be 60 years old. A few will be 70. That’s a demographic you’d expect to be maintaining Cobol, not an operating system that continues to be the heart of modern application development. With that age also comes experience and adeptness at separating hype from substance and consistently delivering exceptional code.
It’s not just the gray-haired set that ensures Linux marches on. As Torvalds tells it, “One of the things I liked about the Rust side of the kernel was that there was one maintainer who was clearly much younger than most of the maintainers.” Certain areas of the kernel, like Rust, help attract new, younger talent. “We can clearly see that certain areas in the kernel bring in more young people,” he continues. Drivers are another prominent example.
Torvalds isn’t swayed by some of the hype around Rust (“Rust has not really shown itself as the next great big thing”), but he’s still a fan, and not just for its technical merits. “Rust was one of those things that made technical sense, but to me personally, even more important was that we need to not stagnate as a kernel and as developers.” Rust has challenged Torvalds and the Linux kernel community to consider new approaches to old problems (and new approaches to new problems). It’s a way of feeding Linux’s fountain of youth and relevance.
This approach has worked for Torvalds for more than 30 years with the Linux kernel. Here’s to another 30 years of figuring out the social interactions that fuel great software systems, and how to encourage younger developers to bring their insights to evolving systems.