The Linux Revolution
In 1991, software was primarily a proprietary product developed and controlled by major corporations such as Microsoft, IBM, and AT&T. Today, the core of modern computing—the Linux Kernel—is developed collaboratively by a global community of developers, sponsored by rival enterprises, and distributed freely under copyleft terms. This shift altered how operating systems are built and established open-source collaboration as the dominant paradigm for infrastructure software.
The Famous Email
On August 25, 1991, Linus Torvalds, a 21-year-old student at the University of Helsinki, posted a query to the comp.os.minix Usenet newsgroup. He sought feedback on Minix, a educational Unix clone created by Andrew Tanenbaum.
The complete header and opening message of this historic email demonstrate his humble initial scope:
From: torvalds@klaava.Helsinki.FI (Linus Benedict Torvalds)
Newsgroups: comp.os.minix
Subject: What would you like to see most in minix?
Summary: small poll for my new operating system
Message-ID: <1991Aug25.205708.9541@klaava.Helsinki.FI>
Date: 25 Aug 91 20:57:08 GMT
Hello everybody out there using minix -
I'm doing a (free) operating system (just a hobby, won't be big and professional like gnu) for 386(486) AT clones. This has been brewing since april, and is starting to get ready. I'd like any feedback on things people like/dislike in minix, as my OS resembles it somewhat (same physical layout of the file-system (due to practical reasons) among other things).
I've currently ported bash(1.08) and gcc(1.40), and things seem to work. This implies that I'll get something practical within a few months...
Torvalds did not set out to create a global industry standard; he wanted a Unix-like system that could run on his Intel 80386 PC without the high licensing costs of commercial Unix implementations.
GNU and the Missing Piece
In parallel, Richard Stallman and the Free Software Foundation (FSF) had worked since 1983 on the GNU Project (a recursive acronym for “GNU’s Not Unix”). Their goal was to construct a fully free Unix-compatible operating system. By 1991, they had successfully implemented the compiler (GCC), the command-line shell (Bash), core system libraries (glibc), and various user-space utilities.
However, the GNU project lacked a functioning kernel. Their planned microkernel, the GNU Hurd, was suffering from design delays.
/* hello.c - A simple program compiled using GNU GCC and run on the Linux kernel */
#include <stdio.h>
int main(void) {
printf("Hello from GNU/Linux!\n");
return 0;
}
To demonstrate how the two components interlock, compiling the above program with the GNU compiler:
gcc -Wall -o hello hello.c
This compilation step requires the GNU Compiler Collection (GCC) and links against the GNU C Library (glibc). When run, the resulting binary relies on the Linux kernel’s system call interface to manage process scheduling, memory allocation, and hardware output. Combining the GNU user-space tools with the Linux kernel yielded a complete, functional operating system, commonly referred to as GNU/Linux.
The GPL: The Engine of Growth
The Linux kernel was released under the GNU General Public License (GPL) Version 2. The defining feature of the GPL is copyleft: anyone may run, copy, modify, and redistribute the code, but they are legally obligated to release the source code of any modified versions they distribute under the same GPL terms.
This license prevented corporations from converting the public repository into proprietary forks, creating a collaborative loop. The kernel enforcement mechanism dynamically verifies GPL compatibility of drivers at runtime. For example, the kernel uses EXPORT_SYMBOL_GPL to restrict access to internal functions:
/* kernel/sched/core.c - Restricting internal scheduling symbol to GPL modules */
#include <linux/module.h>
void internal_scheduler_helper(void) {
/* Critical internal scheduling operations */
}
EXPORT_SYMBOL_GPL(internal_scheduler_helper);
If a proprietary driver attempts to load, the kernel module loader checks the module license and blocks access to GPL-only symbols:
/* my_proprietary_driver.c - Loading this module will fail to resolve GPL symbols */
#include <linux/module.h>
MODULE_LICENSE("Proprietary"); // Loading fails if it links with EXPORT_SYMBOL_GPL
This architecture ensures that companies using and extending the kernel contribute their bug fixes and improvements back to the public repository, creating a shared engineering resource.
The Architecture: Monolithic but Modular
Linux is a Monolithic Kernel. Every subsystem—including process scheduling, memory management, file systems, network stacks, and device drivers—runs inside the kernel’s privileged address space. In 1992, Andrew Tanenbaum (creator of Minix) initiated a famous debate, arguing that monolithic architectures were obsolete and that microkernels (which run drivers in user space) were superior for safety and maintainability.
Torvalds countered that monolithic kernels offered superior performance by avoiding the message-passing overhead of microkernels. To resolve the complexity and maintenance problems, Linux adopted a Modular architecture using Loadable Kernel Modules (LKMs). Drivers can be loaded or unloaded at runtime without rebooting the system.
The following C code demonstrates a modular example of a Loadable Kernel Module structure:
/* hello_module.c - A simple loadable kernel module demonstrating initialization */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
static int __init hello_init(void) {
pr_info("Module loaded successfully into kernel space.\n");
return 0;
}
static void __exit hello_exit(void) {
pr_info("Module removed from kernel space.\n");
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("LibreUni Contributor");
MODULE_DESCRIPTION("A minimal LKM demonstrating modular initialization");
The “Distro” Concept
Because a kernel cannot run as an independent environment for users, developers package the kernel with system utilities, desktop interfaces, and package managers into a Distribution (or “Distro”).
Different distributions cater to specific use cases. An example of package management commands to install software (such as curl) across major distribution families demonstrates this divergence:
# Debian / Ubuntu (APT) - Focuses on stability and ease of use
sudo apt update && sudo apt install -y curl
# Red Hat / Fedora (DNF) - The corporate standard for enterprise deployments
sudo dnf install -y curl
# Arch Linux (Pacman) - A rolling release model for absolute control
sudo pacman -S --noconfirm curl
Additionally, Android employs a heavily modified version of the Linux kernel to interface with mobile hardware, but replaces the GNU toolchain with custom runtime libraries and user-space layers.
Why Linux Won
The modular, open-source model enabled Linux to capture key software infrastructure markets:
- Supercomputing: 100% of the world’s top 500 supercomputers run Linux.
- Cloud Infrastructure: Over 90% of cloud instances (AWS, Google Cloud, Azure) run on Linux.
- Web Servers: The majority of internet-facing web servers and databases run on Linux distributions.
- Mobile & Embedded: Android translates to billions of active Linux-based smartphones.
To demonstrate why Linux became dominant over proprietary alternatives, consider troubleshooting a system error. On a closed-source OS, a developer must rely on vendor diagnostics. On Linux, a developer can trace system calls in real time using tools like strace:
# Example: Tracing system calls to troubleshoot file access
strace -e trace=open,openat cat /etc/shadow
The tool reports the exact failing system call and error code:
openat(AT_FDCWD, "/etc/shadow", O_RDONLY|O_CLOEXEC) = -1 EACCES (Permission denied)
cat: /etc/shadow: Permission denied
+++ exited with 1 +++
Because the kernel is open-source, developers can inspect the source code of openat() in the kernel tree to understand the exact permission logic, patch it, and deploy the modified kernel immediately.
Interactive Practice: The Linux Revolution
To demonstrate your understanding of the Linux revolution, complete this practice quiz.
Why was the combination of GNU tools and the Linux kernel critical to forming a complete operating system?
References & Further Reading
For an example of detailed documentation and historical materials on these systems, refer to the resources below:
- Torvalds, L., & Diamond, D. (2001). Just for Fun: The Story of an Accidental Revolutionary. HarperCollins.
- Williams, S. (2002). Free as in Freedom: Richard Stallman’s Crusade for Free Software. O’Reilly Media.
- Silberschatz, A., Galvin, P. B., & Gagne, G. (2018). Operating System Concepts (10th ed.). John Wiley & Sons.
- Kerrisk, M. (2010). The Linux Programming Interface. No Starch Press.
- Linux kernel (CC-BY-SA 4.0)
- Linux kernel version history (CC-BY-SA 4.0)