Linux 0.01 at 35: From a Student Hobby to World Infrastructure

6 minute read

Published:

Thirty-five years ago today, on 17 September 1991, a Finnish student put a small file on an FTP server and told almost no one. It was version 0.01 of a kernel that would later run most of the servers, supercomputers and phones in the world. Its author did not think it would matter much. He had said so himself a few weeks earlier.

“Just a hobby”

On 25 August 1991, Linus Torvalds posted a message to the comp.os.minix newsgroup under the subject “What would you like to see most in minix?” He wrote that he was doing a free operating system for 386(486) AT clones, and he called it “just a hobby”. He also said it would never be big and professional like GNU, and that it probably would not support anything but AT hard disks.

That modesty is worth noticing. The message was not a product launch. It was a student asking other people what they wanted, in the place where people interested in small, understandable operating systems already gathered. The first public release was 0.01, and it was made up of about 10,000 lines of code. Torvalds was not trying to replace anything. He was learning how a 386 machine worked, and he happened to share what he built.

What 0.01 actually was

Version 0.01 was far from a complete system. It was a young kernel that could run only a few basic programs. Its source was small enough that one person could read all of it in a few days. This matters for teaching: a kernel at that scale shows the core ideas clearly. There is a scheduler, there is memory management, there is a file system, and there are drivers for a few devices.

Those are exactly the topics of any operating systems course. If you want to see how a process is created, how a system call crosses from user mode to kernel mode, or how a disk request is queued, a kernel of this size is a good reading exercise. Modern Linux has grown enormously, but the same questions are still at its centre. Our Operating Systems course follows the same list of ideas, and the early Linux source is a fine place to look for them in real code.

The licence decision

The first licence was not what we associate with Linux today. Torvalds’ own account says the early copyright was more restrictive than the GNU copyleft, and among other things it did not allow money to change hands. That changed with version 0.12, and the GNU General Public License took effect for Linux in early 1992.

This turned out to be one of the most important decisions in the project’s history. The GPL says that anyone may use, study, change and share the code, but anyone who distributes a modified version must offer the source under the same terms. For a hobby project, it meant two things. First, a contributor knew that their work could not be locked away by a later owner. Second, companies could build products on the kernel without asking permission, as long as they gave back their changes to the kernel itself when they distributed them.

Licensing is often treated as a legal footnote in engineering. Here it was part of the architecture of the project. It decided who could join, what they could do, and what they had to share.

A community instead of a company

The kernel was developed in public from the beginning. Torvalds described it as written “with assistance from a loosely-knit team of hackers across the Net”, according to kernel.org. Early mailing-list posts show the pattern: people sent patches, such as the POSIX job control added by Ted Ts’o and the paging to disk that appeared in 0.12. The project reached version 1.0 in 1994.

Three habits made this model work, and they are good habits for any software team:

  • Small, reviewable changes. Work arrives as patches that others can read and criticise.
  • Open discussion. Design arguments happen in public, so the reasons for a decision are recorded.
  • One responsible maintainer per area. Trust is organised in layers rather than concentrated in one person’s head.

The Linux Kernel Organization was founded in 2002 as a nonprofit to distribute the kernel, and the Linux Foundation now manages it. The trademark “Linux” is registered to Linus Torvalds personally. The institutions came long after the code, which is an unusual order for a large technology.

Where Linux runs today

The result is hard to overstate. Linux first appeared on the TOP500 list of supercomputers in 1998, and by 2017 every system on that list ran it. Android, the most widely used phone platform, is built on the Linux kernel; by 2013 it already held about 75% of smartphone shipments. Beyond those two, the kernel sits inside web servers, cloud platforms, network routers, televisions, cars and embedded devices that most people never think of as computers.

An 8086 or a 386 would not have a chance of running a modern kernel, yet the basic structure that Torvalds learned and wrote down in 1991 is still recognisable. That continuity is part of the story. The system grew by accretion and constant revision, not by a grand redesign.

What it still teaches

There are at least three lessons for students and engineers.

Start small and make it real. The first version did very little, but it ran on real hardware and it was public. Feedback came because there was something to try.

Design the social system too. The licence, the mailing list and the patch workflow were as important as any scheduling algorithm. Technology that people can join tends to outlive technology that only its owner can change.

Read real code. Operating systems become much easier to understand when you have seen an actual kernel, not only a diagram of one. If you have never opened a kernel source tree, 35 years is a good reason to start.

Torvalds called it a hobby, and in a sense he was right: it began as curiosity, not as a business plan. That may be the most useful point of all. Large infrastructure often starts as a small question that someone cared enough to answer in public.

Sources: Linux History, collected by Alan W Black (Carnegie Mellon University), History of Linux (Wikipedia), About Linux Kernel (kernel.org)