Learn Linux - History, Background & Linux Philosophy

#Introduction

After episode 0 where we covered prerequisites and set up the environment — from basic skills, distro selection, to verifying that your first Linux system runs — in this episode we'll take a breather from the hands-on work and dive into why Linux exists. We'll trace its history, understand the real problems that gave birth to it, and look at the design philosophy that makes Linux so special.

Why is understanding the history and background important? As engineers, you don't only need to know how to operate a system, but also why the system was designed in a certain way. When you later find files in /proc that can be read like text, or use the | pipeline to chain commands, you'll realize that none of this is a coincidence — it's the fruit of design decisions made decades ago. Without this context, you'll only become a tool operator — not a system engineer.

#The Unix Era: Birth at Bell Labs

The Linux story begins long before 1991, in a project called MULTICS in the mid-1960s. MULTICS was an ambitious project to build a large, sophisticated multi-user operating system, worked on jointly by MIT, GE, and Bell Labs. Unfortunately, the project was too complex and fell behind schedule; Bell Labs eventually pulled out in 1969.

It was from that failure that the magic emerged. At Bell Labs, two researchers — Ken Thompson and Dennis Ritchie — who had worked on MULTICS, felt their need for a comfortable computing environment was still unmet. They then wrote a much simpler new operating system under the pun name "UNICS" (Uniplexed Information and Computing Service), which came to be spelled UNIX. This system was designed around one principle: simple, elegant, and portable.

The big turning point came when Thompson rewrote UNIX in the C language that he and Ritchie had just developed. Previously, operating systems were written in assembly language specific to each hardware — meaning they were hard to port to other machines. By writing UNIX in C (a high-level language that can be compiled on many architectures), UNIX became portable: one source code could run on many kinds of computers. This was a decision that changed history — and it's the reason almost all modern operating systems, including Linux and macOS, are rooted in UNIX.

Unix then spread to universities, especially the University of California, Berkeley, which developed its own variant called BSD (Berkeley Software Distribution). From here came many concepts we still use today — network sockets, the TCP/IP stack, and even the vi utility.

#The GNU Project: Richard Stallman & Software Freedom

In 1983, the software world was dominated by companies selling binaries — source code tightly locked away. Users couldn't see, modify, or study the software they bought. Richard Stallman, a researcher at MIT, felt this was unjust: "software you can't study is a prison for programmers."

Stallman launched the GNU Project — a recursive acronym for "GNU's Not Unix" — with the goal of building a complete operating system that is free, where everyone may use, study, modify, and share software. To protect this freedom, he founded the Free Software Foundation (FSF) and released the GPL license (GNU General Public License).

The GPL is a brilliant legal breakthrough. Instead of prohibiting use, the GPL guarantees freedom through a mechanism called copyleft: if you modify GPL-licensed software and share it, you must also share the source code under the same license. In other words, freedom is "contagious" — once someone receives GPL software, they're bound to pass that freedom on to the next user.

The GNU Project succeeded in building nearly all the components of an operating system: the C compiler (gcc), the text editor (emacs), the shell (bash), and dozens of core utilities like ls, grep, and sed. One crucial component was still missing: the kernel — the heart of the operating system that manages hardware. Without a kernel, GNU was just a collection of great tools that couldn't run on their own.

#The Linux Kernel: Linus Torvalds & the Year 1991

Enter a Finnish student named Linus Torvalds. In 1991, he bought a new PC powered by an Intel 80386 processor and wanted to run UNIX on it. Commercial UNIX was too expensive, and the educational system MINIX (a UNIX variant made for teaching) was too limited — its license didn't allow free modification.

Linus decided to write his own kernel. This wasn't a company project or a university project — it was a hobby project that began with a simple task: printing the character "A" on screen. He posted to the comp.os.minix newsgroup with a now-legendary message, essentially: "I'm working on a free operating system, just as a hobby — it won't be as big as GNU."

The date September 17, 1991 became a milestone: Linux version 0.01 was released. Two things made it different from all other kernels:

1. Released under the GPL license. Linus decided to license his kernel under the GPL after studying Stallman's model. That way, the Linux kernel and GNU tools could legally unite — freedom was preserved on both sides.
2. Developed openly. Anyone could read the code, suggest improvements, and contribute. This open collaboration model is what made Linux grow at an extraordinary pace — from a hobby to the foundation of the internet, servers, cloud, and the Android smartphone.

The combination of GNU tools + Linux kernel ultimately formed a complete, free operating system — that's why this system is technically called "GNU/Linux". To this day, Linux kernel contributors come from thousands of companies (Intel, IBM, Google, Red Hat, Meta) and hundreds of thousands of individuals around the world — the largest collaboration phenomenon in software history.

#GPL vs Proprietary Licensing

#Main Components: Kernel vs GNU Tools vs Distribution

Beginners are often confused hearing the word "Linux" referring to different things. Let's break down the three layers of components that form what you run every day:

• Linux Kernel — the heart of the system. It manages hardware (CPU, RAM, disk, network) and provides an API for programs. Without a kernel, programs can't talk to hardware.
• GNU Tools — the collection of utilities and libraries that make the system usable by humans: the bash shell, the gcc compiler, the ls, cp, mv, grep commands, and thousands more. These are Linux's "household appliances".
• Linux Distribution — a complete, ready-to-use wrapper: kernel + GNU tools + package manager + configuration + community. Ubuntu, Debian, Rocky Linux, and Arch are examples of distros.

Here's an analogy: the kernel is the car engine, GNU tools are the cabin and features (steering wheel, A/C, seats), and the distro is the finished car model marketed to consumers — Toyota, Honda, or VW. The engine and features may be similar, but each manufacturer packages them differently.

#The Unix Philosophy: DNA of the Entire Linux Ecosystem

The most important thing to take away from this episode isn't the historical dates, but the design philosophy that Unix passed on to Linux. This philosophy is what explains why Linux commands behave the way you see — and is the reason so many DevOps tools (Docker, Kubernetes, Terraform) feel "so Linux".

#Everything is a File

Unix treats almost everything as a file: plain text, directories, hardware (disks, keyboards), even running processes. Everything can be opened, read, and written the same way. This is an extremely powerful design — because every tool that can manipulate files (like cat, grep, less) automatically works on everything. Later in episode 2, you'll see directly how /dev (devices) and /proc (processes) are just files that can be read.

#Do One Thing Well

Unix commands are designed to do one task very well: ls only lists files, grep only searches patterns, sort only sorts. There's no giant command that does everything. Consequently, Linux users don't look for "one app for all needs", but rather chain small commands into powerful pipelines. This is the opposite of GUI apps that tend to pile up features.

#Text Streams & Composability

If each program does one thing, how do they work together? The answer: through text. Unix programs read input as text from stdin and write output as text to stdout. Because everything is text, one program's output can become another program's input via the pipeline (|).

ps aux | awk '{print $1}' | sort | uniq -c | sort -rn

The command above counts how many processes each user runs, sorted from highest — built from five small utilities, each doing one thing. This is composability: like LEGO bricks, small commands can be assembled into complex constructions.

#More Unix Philosophy Principles

#Brief Timeline: Unix → GNU → Linux → Distro

#Common Pitfalls

1. Thinking "Linux is Windows with a different theme". This is the biggest misconception. Linux has a different conceptual foundation: the everything-is-a-file philosophy, text pipelines, strict permissions, and the open source ecosystem. You won't last long if you keep comparing it to Windows.

2. Assuming all distros are identical. Debian/Ubuntu vs RHEL vs Arch have different package managers, release philosophies, and update management. Learn the differences — don't copy Ubuntu tutorials onto Rocky without understanding the context.

3. Assuming "free" means low quality. Actually the opposite: because it's open and audited by thousands of eyes, Linux software is often more reliable. The Linux kernel drives most of the world's internet and servers.

4. Assuming Linux = Ubuntu. Linux is the kernel; Ubuntu is just one of hundreds of distros. This confusion makes it hard to understand why commands on Ubuntu can differ from Rocky.

5. Memorizing historical dates without understanding the concepts. Important years won't be useful if you don't understand why the GPL matters, or why "everything is a file" changed how systems work. Prioritize concepts over memorization.

#Conclusion

In this episode 1, we've traced Linux's long journey: from the failure of MULTICS that gave birth to Unix at Bell Labs, the software freedom fought for by Richard Stallman through the GNU Project and the GPL license, Linus Torvalds' hobby project that grew into the world's most influential kernel, to understanding the three component layers (kernel, GNU tools, distro) and the Unix philosophy that is the DNA of the entire ecosystem.

Key takeaways:

• Linux was born from the legacy of Unix and the GNU Project — a combination of the Linux kernel + GNU tools.
• The GPL license guarantees software freedom through the copyleft mechanism.
• Kernel, GNU tools, and distro are three different layers — "Linux" refers to all three at once.
• The Unix philosophy: everything is a file, do one thing well, and text streams — this is what makes Linux so powerful for automation.
• Linux is not Windows with a different theme; it has had a different design paradigm from the start.

This historical understanding is the foundation for understanding how the Linux system works. In the next episode 2, we'll discuss system architecture & the Filesystem Hierarchy Standard (FHS) — dissecting the Hardware → Kernel → Shell → Applications layers, exploring the root directory structure like /etc, /home, /var, /proc, and understanding why /proc can "talk" to the kernel through files. Stay motivated, because from here you'll start truly "reading" how Linux works from the inside!