Linux for Backend Engineers

• Part 1: The Foundation ← current
• Part 2: Files, Filesystems, and Permissions
• Part 3: Processes and Threads
• Part 4: Memory Management
• Part 5: Signals and Communication
• Part 6: IPC, Networking, and Containers

1. The Core Idea

Linux is a resource control system.

Linux exists to safely share hardware (CPU, memory, disk, network) among many running programs. It does this by:

• Isolating programs from each other and from hardware.
• Scheduling access to CPU, memory, disk, and network.
• Enforcing permissions and boundaries.

Every feature of Linux exists to solve one of those problems.

2. What is Linux?

Linux is a kernel, not an operating system.

The kernel is the very first software that loads when your computer starts. It sits between your hardware (CPU, RAM, disk) and your software (apps, browser, terminal). Nothing can access hardware without going through the kernel.

What does the Linux Kernel do?

3. User Space vs Kernel Space: The Fundamental Divide

The CPU enforces a hard boundary between two worlds:

┌──────────────────────────────────────┐
│            User Space                │  ← Your Node.js app, shell, browser
│  (Restricted, isolated, cannot       │     Cannot access hardware directly.
│   access hardware directly)          │     Must ask the kernel via system calls.
├──────────────────────────────────────┤
│         System Call Layer            │  ← The gateway: open(), read(), write()
│         (syscalls)                   │     fork(), exec(), socket(), etc.
├──────────────────────────────────────┤
│            Kernel Space              │  ← The kernel itself.
│  (Full hardware access, trusted)     │     Manages CPU, memory, disk, devices.
└──────────────────────────────────────┘

• User space is where your application runs.
• Kernel space is where the kernel runs and manages everything.
• System calls are the only way to cross from user space into kernel space.

🎯 Node.js relevance: Every time you call fs.readFile(), http.createServer(), or crypto.pbkdf2(), your Node.js process makes one or more system calls. Understanding system calls is key to debugging performance and permission issues.

4. What is a Linux Distro?

A Linux Distribution (Distro) is a complete operating system built around the Linux kernel. Different organizations and communities package the kernel with their own tools, configurations, and software to create different distros.

Linux Distro = 6 Core Components

🔑 Key Insight: The Desktop Environment is the most swappable component. You can take any distro's core (kernel + GNU + init system + package manager), replace the DE with your own, and you essentially have a new distro.

4.1 Base vs Derived Distros

Distros form a family tree. A base distro is built from scratch. A derived distro is built on top of an existing one, inheriting its package manager and architecture.

Debian (Base)
└── Ubuntu (Derived from Debian)
    └── Linux Mint (Derived from Ubuntu)
    └── Pop!_OS (Derived from Ubuntu)
    └── Kali Linux (Derived from Debian)
 
Red Hat (Base)
└── Fedora
└── CentOS
└── AlmaLinux
 
Arch Linux (Base)
└── Manjaro
└── EndeavourOS

🎯 Backend choice: Most production servers run Debian/Ubuntu (APT) or Red Hat/AlmaLinux (DNF/YUM). The package manager is the main practical difference.

4.2 GNU Utilities: The Human Interface

GNU provides the userland – the tools that make the kernel usable. Without GNU, you would have a kernel but no shell, no compiler, no basic commands.

🕰️ Fun Fact: The GNU Project by Richard Stallman was creating a free OS before Linux existed. When Linus Torvalds created the kernel, GNU tools + Linux kernel = a complete OS. This is why some call it GNU/Linux.

Key GNU Components

💡 Fun fact: cd is built directly into your shell (Bash), not a separate program like ls. That's why which cd returns nothing, there's no /bin/cd file!

💡 How your shell finds commands: When you type ls, your shell searches every directory in the $PATH environment variable, in order, until it finds a program named ls. That's why you can type ls instead of /bin/ls. Check your PATH with echo $PATH.

4.3 Init System: The Boot Manager

This is the component most beginners overlook, but it is a core part of every Linux distro.

After the kernel finishes loading, it needs to start all the services that make the OS actually usable: networking, audio, display manager, background daemons, and more. The init system is the program responsible for all of this.

The init system is always PID 1 (Process ID 1), literally the very first process the kernel hands control to after booting. Every other process on your entire system is started directly or indirectly by the init system.

🏠 Simple analogy: Think of the kernel as the foundation of a house. The init system is the caretaker who goes room by room switching on the lights, heating, and appliances in the right order before you walk in.

What does the Init System do?

Popular Init Systems

Common systemd Commands

systemctl start nginx        # Start the nginx service right now
systemctl stop nginx         # Stop the nginx service right now
systemctl restart nginx      # Stop then start again (apply config changes)
systemctl enable nginx       # Auto-start nginx every time the system boots
systemctl disable nginx      # Stop nginx from auto-starting on boot
systemctl status nginx       # Check if nginx is running and see recent logs
journalctl -u nginx          # View the full log history for nginx

4.4 Package Manager: The App Store for Linux

A package manager automates installing, updating, and removing software along with all its dependencies (other software it needs to work).

🔬 How APT Works Under the Hood

When you run sudo apt update, here's what actually happens:

1. APT reads /etc/apt/sources.list - the list of repositories
2. It downloads package index files (the "catalog" of what's available)
3. These files are stored in /var/lib/apt/lists/

ls /var/lib/apt/lists/
# Example output:
# archive.ubuntu.com_ubuntu_dists_focal_main_binary-amd64_Packages
# archive.ubuntu.com_ubuntu_dists_focal_universe_binary-amd64_Packages

Each index file contains structured entries like:

Package: curl
Version: 7.68.0-1ubuntu2.18
Architecture: amd64
Depends: libc6, libcurl4
Filename: pool/main/c/curl/curl_7.68.0-1ubuntu2.18_amd64.deb

When you run sudo apt install curl:

1. APT searches /var/lib/apt/lists/ for "curl"
2. It reads dependencies and calculates what else to install
3. It downloads .deb files to /var/cache/apt/archives/
4. It calls dpkg (the low-level installer) to unpack and configure

🧪 Proof: Try this yourself:

sudo rm -rf /var/lib/apt/lists/*
sudo apt install curl   # ERROR: Unable to locate package curl
sudo apt update         # Rebuilds the local database
sudo apt install curl   # Works again

Key APT Directories Summary

4.5 Desktop Environment (DE)

The Desktop Environment is everything visual, the GUI layer on top of the OS. It makes Linux usable for non-terminal users.

DE Components

Popular Desktop Environments

5. The Complete Linux Stack

┌─────────────────────────────────────────────┐
│           Desktop Environment               │  ← What you SEE and CLICK
│  (GNOME, KDE, XFCE, or just a WM)           │    windows, icons, taskbar
├─────────────────────────────────────────────┤
│             Package Manager                 │  ← How you INSTALL software
│  (APT, DNF, Pacman, Flatpak...)             │    handles all dependencies
├─────────────────────────────────────────────┤
│             GNU Utilities                   │  ← What you TYPE
│  (Bash, ls, gcc, glibc, GDB...)             │    commands, compilers, libraries
├─────────────────────────────────────────────┤
│              System Calls                   │  ← The GATEWAY to the kernel
│  (open, read, write, fork, exec, socket)    │    user space → kernel space
├─────────────────────────────────────────────┤
│              Init System  (PID 1)           │  ← What STARTS everything
│  (systemd, OpenRC, runit...)                │    boots all services in order
├─────────────────────────────────────────────┤
│             Linux Kernel                    │  ← The ENGINE
│  (Scheduling, Memory, Disk, I/O)            │    talks to hardware via drivers
├─────────────────────────────────────────────┤
│               Hardware                      │  ← The PHYSICAL machine
│  (CPU, RAM, SSD, GPU, Keyboard...)          │
└─────────────────────────────────────────────┘