What is Linux?

What Linux actually is

The word "Linux" gets used loosely, so let's be precise. Strictly speaking, Linux is a kernel — the core piece of software that sits between your programs and the physical hardware. The kernel is the part that decides which program gets the CPU next, hands out chunks of memory, talks to your disk and network card through device drivers, and enforces who is allowed to do what. It's the manager that never sleeps.

But a kernel on its own isn't something you can use. To get a working operating system you also need a shell to type commands into, a set of basic tools (to list files, copy them, search text), system libraries, and applications. On most Linux systems those tools come from the GNU project, which is why purists call the whole thing "GNU/Linux." When people say "I run Linux," they almost always mean a full operating system built around the Linux kernel — and that's the meaning we'll use too.

You can actually see the kernel on a running machine. The uname command prints kernel information, and on Ubuntu you'll get something like this:

$ uname -srm
Linux 6.8.0-31-generic x86_64

That tells you the kernel name (Linux), its version (6.8.0-31-generic), and the machine's architecture (x86_64). The full uname -a dumps everything at once — we'll use it again in the next lesson.

Where it came from: history & Unix

To understand Linux you have to rewind to Unix. Unix was created at AT&T's Bell Labs in 1969, and it introduced ideas we still rely on every day: everything is a file, small tools that each do one job well, and the ability to pipe one program's output into another (you'll do a lot of piping later in this course). Unix was powerful, but it was commercial and expensive, and its source code was locked down.

In 1983, Richard Stallman launched the GNU project to build a completely free Unix-like system. By the early 1990s GNU had built almost everything — the compiler, the shell, the core tools — but it was still missing one crucial piece: a working kernel.

That gap was filled in 1991 by a Finnish student named Linus Torvalds. He posted a now-famous message announcing a "hobby" kernel, saying it "won't be big and professional." He could not have been more wrong about the scale. He combined his kernel with the GNU tools, and the result was a complete, free, Unix-like operating system. Today the Linux kernel has contributions from thousands of developers and companies and is one of the largest collaborative software projects in history.

So why does this history matter to you, practically? Because the design choices Unix made in 1969 are exactly the ones you'll use at the command line. Try this on any Linux box:

# "everything is a file" — even your terminal is a file
$ ls -l /dev/null
crw-rw-rw- 1 root root 1, 3 Jun 14 09:12 /dev/null

# small tools combined with a pipe (forward-reference: Section 6)
$ cat /etc/passwd | grep '/bin/bash' | wc -l
3

That last line chains three tiny programs — cat reads a file, grep filters lines, wc -l counts them — to answer "how many users have bash as their login shell?" That composability is the Unix philosophy, and it's the heart of what makes the Linux command line so productive. We'll dedicate a whole section to pipes and redirection later.

Distributions: same kernel, different packaging

If everyone shares the same kernel and the same GNU tools, why are there so many "different Linuxes"? The answer is the distribution (or "distro"). A distribution bundles the kernel, the system tools, a way to install software (the package manager), default configurations, and an installer into one ready-to-use product. The kernel underneath is the same family; what changes is the packaging, the release schedule, and the defaults.

Here's a quick tour of the distros you'll actually meet:

• Debian — the rock-stable grandparent of the apt world. Conservative, hugely respected, the base many others build on.
• Ubuntu — built on Debian, polished and beginner-friendly, with long-term-support (LTS) releases. This is the distro we'll use throughout the course.
• Fedora — fast-moving, cutting-edge, sponsored by Red Hat; a great place to see new features first.
• RHEL (Red Hat Enterprise Linux) — the paid, supported enterprise standard; common in big companies and banks.
• Arch — minimal and do-it-yourself; you build the system up yourself, which teaches you a lot (and breaks a lot).

The practical difference you'll feel first is how you install software. On Ubuntu or Debian you use apt:

# Debian / Ubuntu
$ sudo apt update
$ sudo apt install tree

On Fedora or RHEL the same job uses dnf:

# Fedora / RHEL
$ sudo dnf install tree

The good news: the actual commands you'll spend 95% of your time on — ls, cd, grep, cat, chmod, and bash scripting itself — are identical across every distribution. Learn them once on Ubuntu and they transfer everywhere.

Why Linux runs servers, cloud & DevOps

You might use Windows or macOS on your laptop, so why does Linux own the server world so completely? A few reasons stack up:

• It's free. When you run thousands of servers, a per-machine licence fee becomes a fortune. Linux removes that line item entirely.
• It's stable and lean. A Linux server can run for months without rebooting, and a minimal install uses very little memory because there's no graphical desktop in the way.
• It's scriptable and remote-friendly. Everything can be done from the command line, which means everything can be automated. You manage a server you've never physically seen by logging in over SSH.
• It's open. Engineers can inspect, tune, and fix it, and a global community ships security patches fast.

This is why Linux is the backbone of cloud computing and DevOps. Every major cloud — AWS, Google Cloud, Azure — runs the overwhelming majority of its workloads on Linux. The tools that define modern infrastructure are built on it: Docker containers are fundamentally a Linux feature, Kubernetes orchestrates Linux containers, and the servers running your favourite websites, the Android phone in your pocket, and most of the world's supercomputers are all Linux underneath.

Here's the punchline for your career: knowing your way around a Linux shell is not a niche skill. It's the shared language of backend development, DevOps, site reliability engineering, data engineering, and security. A typical day on a server looks like this:

$ ssh deploy@app-server-01
deploy@app-server-01:~$ uptime
 14:02:17 up 87 days,  4:51,  1 user,  load average: 0.08, 0.11, 0.09
deploy@app-server-01:~$ df -h /
Filesystem      Size  Used Avail Use% Mounted on
/dev/root        49G   18G   29G  38% /

No mouse, no windows — just you, a prompt, and a machine that does exactly what you tell it. Learning to be comfortable here is what the rest of this course is about.

Further reading

• The Linux Kernel Archives (kernel.org) — the official home of the kernel source.
• "Linux and the GNU System" (gnu.org) — the GNU project's take on the GNU/Linux name.
• DistroWatch — browse and compare the hundreds of Linux distributions.