What Is Linux and Why It's Everywhere

Why This Matters

Picture this: you open your phone to check the weather, stream music on your commute, tap your card at a payment terminal, and then sit down at work to deploy code to a cloud server. Every single one of those actions just touched Linux. The phone runs Android (built on the Linux kernel). The music service runs on Linux servers. The payment terminal likely runs embedded Linux. The cloud server? Almost certainly Linux.

Linux is not some niche operating system for hobbyists. It powers 96% of the world's top one million web servers, all of the world's top 500 supercomputers, the International Space Station, Tesla's infotainment systems, and the majority of the world's cloud infrastructure. When you learn Linux, you are learning the operating system that runs the modern world.

This chapter answers the most fundamental question: what exactly is Linux, where did it come from, and why should you invest your time mastering it?

Try This Right Now

If you already have access to any Linux system (a server, a VM, WSL2, or even an Android phone with Termux), open a terminal and type:

$ uname -a

You should see something like:

Linux myhost 6.1.0-18-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.76-1 (2024-02-01) x86_64 GNU/Linux

That single line tells you:

  • You are running Linux (the kernel)
  • Your hostname is myhost
  • The kernel version is 6.1.0-18-amd64
  • It was compiled with SMP (symmetric multiprocessing) and PREEMPT (preemptive scheduling)
  • The distribution is Debian
  • The architecture is x86_64 (64-bit Intel/AMD)

If you do not have a Linux system yet, that is perfectly fine. Chapter 3 walks you through setting one up. For now, read on and come back to run the commands later.

What Linux Actually Is

When people say "Linux," they usually mean one of two things, and the difference matters.

The Linux Kernel

In the strictest sense, Linux is a kernel -- the core piece of software that sits between your hardware and everything else. The kernel's job is enormous and critical:

┌─────────────────────────────────────────────────┐
│              User Applications                   │
│         (Firefox, vim, python, nginx)            │
├─────────────────────────────────────────────────┤
│              System Libraries                    │
│           (glibc, libssl, libpthread)            │
├─────────────────────────────────────────────────┤
│           System Calls Interface                 │
│      (open, read, write, fork, exec, ...)        │
├─────────────────────────────────────────────────┤
│             THE LINUX KERNEL                     │
│  ┌───────────┬──────────┬──────────────────┐     │
│  │ Process   │ Memory   │ Filesystem       │     │
│  │ Scheduler │ Manager  │ Layer (VFS)      │     │
│  ├───────────┼──────────┼──────────────────┤     │
│  │ Network   │ Device   │ Security         │     │
│  │ Stack     │ Drivers  │ (SELinux, etc.)  │     │
│  └───────────┴──────────┴──────────────────┘     │
├─────────────────────────────────────────────────┤
│                  HARDWARE                        │
│       (CPU, RAM, Disk, Network Card, GPU)        │
└─────────────────────────────────────────────────┘

The kernel handles:

  • Process management -- creating, scheduling, and terminating programs
  • Memory management -- allocating RAM to programs, swapping to disk
  • Filesystem access -- reading and writing files on disks
  • Device drivers -- talking to hardware (network cards, USB devices, GPUs)
  • Networking -- implementing TCP/IP, routing packets
  • Security -- enforcing permissions, capabilities, and mandatory access controls

Without the kernel, your applications have no way to talk to the hardware. With a broken kernel, nothing works. The kernel is the foundation.

The Linux Operating System (Distribution)

A kernel alone is not very useful. You need a shell to type commands in, utilities to copy files and manage processes, a package manager to install software, an init system to boot the machine, and thousands of other tools. When all of these are bundled together with the Linux kernel, you get a Linux distribution (or "distro").

┌──────────────────────────────────────────────┐
│          A Linux Distribution                 │
│                                               │
│   Linux Kernel                                │
│   + GNU Core Utilities (ls, cp, grep, etc.)   │
│   + Shell (bash, zsh)                         │
│   + Init System (systemd, OpenRC)             │
│   + Package Manager (apt, dnf, pacman)        │
│   + Libraries (glibc, openssl)                │
│   + Desktop Environment (optional)            │
│   + Default Applications                      │
│   + Configuration & Branding                  │
└──────────────────────────────────────────────┘

When someone says "I run Linux," they almost always mean "I run a Linux distribution." Ubuntu, Fedora, Debian, Arch Linux, Red Hat Enterprise Linux -- these are all distributions. They all share the same kernel (or a version of it) but differ in what tools they bundle, how they manage packages, and what their default configurations look like.

Think About It: If all Linux distributions share the same kernel, why are there hundreds of different distributions? What would be different about each one?

A Brief History: How We Got Here

Understanding where Linux came from helps you understand why it works the way it does.

Unix: The Ancestor (1969)

The story starts at AT&T's Bell Labs in 1969. Ken Thompson and Dennis Ritchie created Unix, an operating system built around a few powerful ideas:

  • Everything is a file -- devices, processes, even network connections can be accessed like files
  • Small, sharp tools -- each program does one thing well
  • Text as a universal interface -- programs communicate through plain text streams
  • Pipelines -- you can chain small tools together to do complex things

These ideas were radical in 1969 and they remain the philosophical backbone of Linux today. When you pipe grep into sort into uniq later in this book, you are using a design philosophy that is over fifty years old -- because it works.

GNU: The Free Software Movement (1983)

By the early 1980s, Unix had become proprietary and expensive. Richard Stallman, a programmer at MIT, decided that software should be free -- not "free" as in price, but "free" as in freedom. In 1983, he launched the GNU Project (a recursive acronym: "GNU's Not Unix") to create a completely free Unix-like operating system.

By 1991, the GNU Project had built almost everything needed for a complete operating system: a compiler (GCC), a shell (Bash), core utilities (ls, cp, mv, grep), text editors (Emacs), and libraries (glibc). They had everything except the most critical piece: a working kernel.

Linux: The Missing Kernel (1991)

On August 25, 1991, a 21-year-old Finnish computer science student named Linus Torvalds posted this message to the comp.os.minix newsgroup:

"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."

That "hobby" became the Linux kernel. When combined with the GNU tools, the result was a complete, free, Unix-like operating system. This is why some people call it GNU/Linux -- the kernel is Linux, but much of the userspace came from the GNU Project. In practice, most people just say "Linux."

The Timeline

1969  Unix created at Bell Labs
1983  Richard Stallman launches the GNU Project
1985  Free Software Foundation (FSF) established
1989  GNU General Public License (GPL) v1 released
1991  Linus Torvalds releases Linux kernel 0.01
1992  Linux re-licensed under GPL v2
1993  Debian and Slackware (first major distros) appear
1994  Linux kernel 1.0 released
1996  Linux kernel 2.0 -- SMP support
2003  RHEL (Red Hat Enterprise Linux) launched
2004  Ubuntu 4.10 ("Warty Warthog") released
2007  Android announced (built on Linux kernel)
2008  Linux kernel used in first Android phones
2011  Linux kernel 3.0 released
2013  All Top500 supercomputers run Linux
2015  Linux kernel 4.0 -- live patching
2019  Microsoft ships WSL2 with a real Linux kernel
2020  Linux kernel 5.x series
2022  Linux kernel 6.0 released
2024  Linux kernel 6.x continues active development

Think About It: Linus Torvalds said his project "won't be big and professional." It now runs on everything from wristwatches to supercomputers. What do you think allowed a hobby project to grow into the dominant operating system?

The GPL and Open Source Philosophy

Linux is released under the GNU General Public License version 2 (GPL v2). This is not just a legal technicality -- it is the reason Linux exists in its current form.

The GPL v2 says:

  1. Freedom to use -- You can run the software for any purpose
  2. Freedom to study -- You can read and modify the source code
  3. Freedom to share -- You can distribute copies
  4. Freedom to improve -- You can distribute your modifications

The critical requirement: if you distribute a modified version of GPL-licensed software, you must also distribute the source code under the same license. This is called copyleft -- it ensures that Linux and its derivatives remain free forever.

This is why:

  • You can download the entire Linux kernel source code right now, for free
  • Android, which is built on Linux, must make its kernel modifications public
  • Companies like Red Hat, Canonical, and SUSE can sell support and services around Linux, but cannot lock up the code itself
  • You can build your own Linux distribution tomorrow if you want to

Open Source vs Free Software

You will hear both terms. They overlap heavily but differ in emphasis:

  • Free Software (Stallman's philosophy): emphasizes user freedom as a moral imperative
  • Open Source (coined 1998): emphasizes the practical benefits of collaborative development

Linux lives comfortably in both camps. For this book, what matters is this: every tool we cover is open source. You can inspect its code, modify it, and learn from it. No black boxes.

Where Linux Runs

The scope of Linux adoption is staggering. Let us look at the numbers.

Servers and Cloud

  • 96.3% of the top one million web servers run Linux
  • 90%+ of public cloud workloads run on Linux
  • All major cloud providers (AWS, Google Cloud, Azure) offer Linux as the primary server OS
  • AWS's own infrastructure runs on a custom Linux distribution (Amazon Linux)
  • Google runs a custom Linux internally across billions of containers

When you visit nearly any website -- Google, Netflix, Amazon, Wikipedia, Reddit -- you are talking to Linux servers.

Supercomputers

  • 100% of the world's top 500 supercomputers run Linux
  • This has been the case since November 2017
  • Before Linux dominated, the list included Unix, Windows, and custom operating systems
  • Linux won because it is free, customizable, and scales from one core to millions

Mobile Devices

  • Android runs on the Linux kernel
  • Android holds roughly 72% of the global mobile OS market
  • That means the majority of smartphones in the world run Linux

Embedded Systems and IoT

  • Smart TVs (Samsung's Tizen, LG's webOS -- both Linux-based)
  • Routers and network equipment
  • Industrial control systems
  • Automotive infotainment (Tesla, Toyota, BMW)
  • Digital signage, ATMs, point-of-sale terminals

Space

  • The International Space Station migrated from Windows to Linux (Debian) in 2013
  • NASA's Mars Ingenuity helicopter runs Linux
  • SpaceX uses Linux on its flight computers

Desktop

Linux has roughly 4% of the desktop market. This is small compared to Windows and macOS, but it represents tens of millions of users. The desktop is also where you will likely do most of your learning.

┌────────────────────────────────────────────┐
│         Where Linux Runs                    │
│                                             │
│  Supercomputers     ████████████████ 100%   │
│  Cloud Servers      ███████████████░  90%+  │
│  Web Servers        ███████████████░  96%   │
│  Mobile (Android)   ███████████░░░░░  72%   │
│  Embedded/IoT       ████████░░░░░░░░  ~50%  │
│  Desktop            █░░░░░░░░░░░░░░░  ~4%   │
│                                             │
└────────────────────────────────────────────┘

Think About It: Linux dominates servers, supercomputers, and phones but has only about 4% of the desktop market. What factors might explain this difference?

Why Learn Linux?

Career Demand

Nearly every job posting for system administration, DevOps engineering, site reliability engineering, cloud engineering, cybersecurity, or backend development lists Linux as a required or preferred skill. This is not a trend -- it has been the case for decades and the demand is growing.

Certifications like the RHCSA (Red Hat Certified System Administrator), LFCS (Linux Foundation Certified System Administrator), and AWS Solutions Architect all require Linux knowledge.

Understanding Over Clicking

On Windows or macOS, you often configure things through graphical menus. You click, toggle, and hope. On Linux, configuration is done through text files and commands. This seems harder at first, but it has profound advantages:

  • Reproducibility -- you can script everything
  • Version control -- you can track every change with Git
  • Remote management -- you can manage a server 10,000 miles away over SSH
  • Automation -- you can configure a thousand servers identically
  • Debugging -- when something breaks, you can read the configuration and logs to understand exactly what happened

Control and Transparency

Linux hides nothing from you. If you want to know what your operating system is doing right now:

$ ps aux      # show every running process
$ top         # watch CPU and memory usage live
$ ss -tlnp    # see which programs are listening on network ports
$ dmesg       # read kernel messages
$ journalctl  # read system logs

On proprietary systems, much of this is hidden behind opaque interfaces. On Linux, it is all text, all accessible, all yours.

Freedom

With Linux, you are not locked into any vendor's ecosystem. You can:

  • Choose your desktop environment (or use none)
  • Choose your init system
  • Choose your package manager
  • Build the system from scratch if you want (see: Linux From Scratch, Gentoo)
  • Run it on hardware that proprietary vendors have abandoned
  • Audit every line of code that runs on your machine

This is not just philosophical. If a vendor discontinues a product, Linux keeps running. If a government mandates backdoors in proprietary software, you can verify that your Linux system has none.

Kernel vs Userspace: A Critical Distinction

One concept that will recur throughout this book is the boundary between kernel space and user space.

┌──────────────────────────────────────────────┐
│              USER SPACE                       │
│                                               │
│  Your programs, shells, scripts, daemons      │
│  They CANNOT directly access hardware         │
│  They MUST ask the kernel via system calls     │
│                                               │
├──────────────────────────────────────────────┤
│          SYSTEM CALL BOUNDARY                 │
│     (the controlled gateway)                  │
├──────────────────────────────────────────────┤
│              KERNEL SPACE                     │
│                                               │
│  The kernel, device drivers, kernel modules   │
│  Full access to hardware and memory           │
│  Runs with highest privilege                  │
│                                               │
├──────────────────────────────────────────────┤
│              HARDWARE                         │
└──────────────────────────────────────────────┘
  • Kernel space: The kernel runs with full access to the hardware. A bug here can crash the entire system.
  • User space: Everything else -- your shell, your web browser, your web server. Programs here cannot directly touch hardware. They must make system calls to ask the kernel to do things on their behalf.

This separation is what makes Linux stable. If Firefox crashes, the kernel keeps running. If a Python script goes rogue and tries to access memory it should not, the kernel terminates it. The kernel is the bouncer.

You will encounter this boundary again and again: when we discuss processes (Chapter 10), the kernel (Chapter 13), and containers (Chapter 62-66).

Hands-On: Exploring Your (or Any) Linux System

If you have a Linux system available, try these commands. Each one reveals something about the system.

What kernel are you running?

$ uname -r
6.1.0-18-amd64

The kernel version follows a pattern: major.minor.patch. The 6.1.0 tells you this is major version 6, minor version 1, patch 0.

What distribution is this?

$ cat /etc/os-release
PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
NAME="Debian GNU/Linux"
VERSION_ID="12"
VERSION="12 (bookworm)"
ID=debian
...

This file exists on virtually every modern Linux distribution and gives you standardized information about which distro and version you are running.

How long has the system been running?

$ uptime
 14:32:07 up 47 days,  3:21,  2 users,  load average: 0.15, 0.10, 0.08

This tells you the system has been running for 47 days without a reboot. Linux servers commonly run for months or years between reboots.

What CPU does the system have?

$ lscpu | head -15
Architecture:            x86_64
CPU op-mode(s):          32-bit, 64-bit
Address sizes:           46 bits physical, 48 bits virtual
Byte Order:              Little Endian
CPU(s):                  4
On-line CPU(s) list:     0-3
Vendor ID:               GenuineIntel
Model name:              Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz
...

How much memory is available?

$ free -h
               total        used        free      shared  buff/cache   available
Mem:           7.7Gi       2.1Gi       3.4Gi       256Mi       2.2Gi       5.1Gi
Swap:          2.0Gi          0B       2.0Gi

The -h flag means "human-readable" -- you will see this flag on many Linux commands.

How much disk space?

$ df -h /
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        50G   12G   35G  26% /

Every one of these commands is a small tool that does one thing well. That is the Unix philosophy at work.

The Linux Development Model

The Linux kernel is the largest collaborative software project in human history. Some numbers to appreciate the scale:

  • Over 30 million lines of code in the kernel source
  • Thousands of contributors per release cycle
  • A new stable release approximately every 9-10 weeks
  • Companies contributing include Intel, Google, Red Hat, Samsung, Microsoft, Meta, Amazon, and hundreds more
  • Linus Torvalds remains the project's Benevolent Dictator For Life (BDFL) with final say on what gets merged

The development process is remarkably open:

  1. Developers submit patches to public mailing lists
  2. Patches are reviewed by maintainers and other developers
  3. Accepted patches flow through subsystem maintainer trees
  4. Linus merges from maintainer trees during the merge window
  5. A series of release candidates (rc1, rc2, ...) are tested
  6. A stable release is tagged

Every email, every patch, every discussion is public. You can read the kernel mailing list archives and see exactly why every change was made.

What Just Happened?

┌─────────────────────────────────────────────────────┐
│                                                      │
│  In this chapter, you learned:                       │
│                                                      │
│  - Linux is a KERNEL, not an operating system.       │
│    A distribution = kernel + userspace tools.         │
│                                                      │
│  - Linux descends from Unix (1969), combines the     │
│    GNU tools (1983) with Linus Torvalds' kernel      │
│    (1991), and is licensed under the GPL v2.          │
│                                                      │
│  - Linux runs everywhere: 100% of supercomputers,    │
│    96% of web servers, 72% of mobile phones           │
│    (Android), the ISS, Mars helicopters, and cars.    │
│                                                      │
│  - The GPL ensures Linux remains free and open.       │
│    You can read, modify, and redistribute the code.   │
│                                                      │
│  - The kernel/userspace boundary is a key concept:    │
│    programs ask the kernel to access hardware via      │
│    system calls.                                      │
│                                                      │
│  - Learning Linux gives you career skills, system     │
│    understanding, and freedom from vendor lock-in.    │
│                                                      │
│  - Commands you met: uname, cat, uptime, lscpu,      │
│    free, df                                          │
│                                                      │
└─────────────────────────────────────────────────────┘

Try This

Exercises

  1. Research exercise: Go to kernel.org and find the current stable kernel version. Compare it to the version shown by uname -r on any Linux system you have access to. Is the system up to date?

  2. Exploration exercise: If you have a Linux system, run cat /etc/os-release and identify: the distribution name, the version number, and the ID. Write these down -- you will need them in Chapter 2.

  3. Reading exercise: Read the original Linus Torvalds newsgroup post from 1991 (search for "linux history linus newsgroup 1991"). What hardware was he targeting? What features was he not planning to support?

  4. Thinking exercise: We said "everything is a file" is a Unix/Linux philosophy. What might it mean for a device (like a hard disk or a keyboard) to be represented as a file? What advantages might this give?

  5. Career exercise: Search a job board for "Linux system administrator" or "DevOps engineer" positions. List five specific Linux skills that appear in multiple job descriptions.

Bonus Challenge

Find three devices in your home that likely run Linux (hint: your router is almost certainly one). For each device, research what Linux-based operating system it uses and what kernel version it likely runs.

What's Next

Now that you understand what Linux is and why it matters, the next question is: which Linux should you use? There are hundreds of distributions, and Chapter 2 will help you navigate this landscape and choose the right one for your goals.