Linux Operating System EP.1: History, Features, and File System Explained

Linux is a powerful, open-source operating system (OS) that serves as the foundation for a vast range of devices, from desktop computers to smartphones, servers, and embedded systems. Unlike proprietary operating systems such as Windows and macOS, Linux is developed collaboratively by programmers worldwide, making it one of the most secure, flexible, and efficient operating systems available.

At its core, Linux consists of the Linux kernel, which interacts directly with hardware, and various software tools that form a complete OS. This modular structure allows for multiple Linux distributions (distros), which cater to different needs, whether for general users, developers, or enterprise environments.

In this guide, we will explore the origins of Linux, its key features, and some of the most popular distributions available today.

Explore My Cybersecurity Second Brain: CLICK

The History of Linux: From Unix to Open-Source Revolution

The story of Linux begins with Unix, an operating system developed in the late 1960s and early 1970s at AT&T’s Bell Labs. Unix’s principles of simplicity, portability, and modularity laid the groundwork for modern operating systems, including Linux.

1. The Birth of Unix (1970)

Unix was created by Ken Thompson and Dennis Ritchie at AT&T’s Bell Labs. It introduced concepts like hierarchical file structures, multitasking, and multi-user environments, which became foundational for future OS development.

2. The Berkeley Software Distribution (BSD) (1977)

The University of California, Berkeley, developed BSD as an improved version of Unix. However, legal disputes with AT&T over ownership rights slowed BSD’s growth.

3. The GNU Project (1983)

Frustrated by proprietary software restrictions, Richard Stallman launched the GNU Project to create a free, Unix-like OS. This led to the development of crucial software tools but lacked a functioning kernel.

4. Linus Torvalds and the Linux Kernel (1991)

In 1991, Linus Torvalds, a Finnish student, developed the Linux kernel as a personal project. He released it under the GNU General Public License (GPL), allowing anyone to use, modify, and distribute it freely.

This marked the birth of Linux, which, when combined with GNU software, became a complete and functional operating system.

5. The Rise of Linux Distributions (1990s – Present)

With Linux growing rapidly, developers began packaging it into distributions (or “distros”)—preconfigured versions with additional software, user interfaces, and package management systems. Today, Linux powers everything from supercomputers and web servers to smartphones and embedded devices.

Top Linux Distributions (Distros) and Their Features

There are over 600 Linux distributions, each designed for different users and purposes. Here are some of the most popular ones:

1. Ubuntu (Best for Beginners)

• User-friendly, with a simple interface
• Large community and excellent support
• Regular updates and long-term support (LTS) versions

2. Debian (Stable and Reliable)

• Focuses on stability, making it ideal for servers
• Large repository of software packages
• The foundation for many other distributions, including Ubuntu

3. Fedora (Cutting-Edge Features)

• Features the latest open-source software
• Backed by Red Hat, making it enterprise-friendly
• Emphasizes security and innovation

4. openSUSE (Enterprise and Developer-Friendly)

• Offers two versions: Tumbleweed (rolling release) and Leap (stable release)
• YaST tool for system configuration
• Suitable for both beginners and professionals

5. Manjaro (User-Friendly Arch-Based Distro)

• Based on Arch Linux but designed for ease of use
• Rolling release model ensures up-to-date software
• Comes with pre-installed drivers and software

6. Linux Mint (Windows-Like Experience)

• Best for users transitioning from Windows
• Comes with multimedia codecs and essential software
• Focuses on simplicity and ease of use

7. Red Hat Enterprise Linux (RHEL) & CentOS (Enterprise & Server Use)

• Used in businesses and data centers
• Strong security and long-term support
• CentOS is a free alternative to RHEL, though now replaced by CentOS Stream

8. Arch Linux (For Advanced Users)

• Minimalistic and highly customizable
• Rolling release ensures access to the latest software
• Best suited for experienced Linux users

Core Principles of Linux Philosophy

The Linux philosophy is deeply inspired by the Unix Philosophy, formulated by early Unix developers such as Ken Thompson, Dennis Ritchie, and later refined by software engineers like Doug McIlroy and Eric S. Raymond. The core ideas revolve around simplicity, composability, and transparency.

1. Everything Is a File

One of the most fundamental principles of Linux is that everything is treated as a file. This means:

• Configuration files are stored as text files (e.g., /etc/passwd for user accounts).
• Hardware devices (like /dev/sda for a hard drive) are represented as files.
• Processes have file-like descriptors that allow interaction through the filesystem.

This uniform approach simplifies system management, making it easier to manipulate settings, monitor hardware, and debug processes.

2. Small, Single-Purpose Programs

Linux tools are designed to perform one task efficiently. Instead of large, all-in-one applications, Linux provides small, specialized programs that excel in their respective functions.

For example:

• ls: Lists directory contents.
• grep: Searches for patterns in text.
• awk: Processes text-based data.

These tools follow the “Do One Thing and Do It Well” philosophy, ensuring they remain lightweight, fast, and reusable.

3. Chaining Programs Together (Pipelining)

Instead of reinventing the wheel, Linux allows users to chain commands together using pipes (|). This lets different tools collaborate, forming powerful command sequences.

For instance, to find all .log files in a directory and count how many contain the word “error”:

grep "error" *.log | wc -l

• grep "error" *.log: Finds occurrences of “error” in all log files.
• wc -l: Counts the number of matching lines.

This approach fosters composability, letting users build complex workflows from simple commands.

4. Avoid Captive User Interfaces

Unlike proprietary operating systems that rely heavily on graphical interfaces (GUIs), Linux prioritizes command-line interaction. While Linux supports GUIs like GNOME and KDE, the shell (CLI) remains the most powerful way to interact with the system.

CLI tools provide:

• Greater automation through scripting.
• More control over system configurations.
• Higher efficiency for experienced users.

This philosophy ensures Linux remains lightweight, accessible via remote terminals, and adaptable to different environments.

5. Configuration Data Stored in Text Files

Unlike Windows, which uses binary registry files for system settings, Linux stores configurations in plain text files. This makes it easy to:

• Edit settings using simple text editors like nano or vim.
• Automate configurations with scripts.
• Easily back up and restore settings.

For example, network configurations might be stored in /etc/network/interfaces, while user information is kept in /etc/passwd. This text-based approach enhances transparency and flexibility.

Components of Linux: Understanding the Building Blocks

The Linux operating system consists of multiple components, each serving a distinct role. Together, they create a powerful, cohesive, and customizable system.

1. Bootloader: The Startup Manager

The bootloader is responsible for initializing the system during startup. It loads the Linux kernel into memory and hands control over to the OS.

Popular Linux bootloaders include:

• GRUB (Grand Unified Bootloader) – A feature-rich bootloader supporting multiple OS installations.
• Syslinux – A lightweight alternative for embedded systems.
• rEFInd – A visually appealing boot manager, often used on Mac hardware.

The bootloader is crucial for dual-booting and troubleshooting boot issues.

2. Kernel: The Heart of Linux

The Linux kernel is the core of the operating system. It manages:

• Process scheduling – Allocating CPU time to tasks.
• Memory management – Allocating RAM and virtual memory.
• Device drivers – Enabling hardware interaction (disks, printers, USB devices).
• Networking – Handling TCP/IP connections and routing.

Since the kernel directly interacts with hardware, it must be optimized for performance and security. Different types of kernels exist, such as:

• Monolithic Kernel (standard Linux kernel) – High performance but larger size.
• Microkernel (used in specialized OSes) – Smaller, with minimal core functions.

Users can customize their Linux experience by compiling a custom kernel, optimizing it for specific workloads.

3. Daemons: Background Services

Daemons are background processes that run continuously to handle essential system tasks. Examples include:

• cron – Manages scheduled tasks (e.g., running a backup at midnight).
• sshd – Allows remote SSH logins.
• syslogd – Logs system events.

Daemons ensure that Linux remains responsive, automated, and well-maintained.

4. Shell: The Command-Line Interface (CLI)

The shell is where users interact with the system via commands. It serves as an interface between the user and the OS.

Popular Linux shells include:

• Bash (Bourne Again Shell) – The most widely used shell, rich in scripting features.
• Zsh (Z Shell) – An improved shell with powerful auto-completions.
• Fish (Friendly Interactive Shell) – A user-friendly shell with enhanced syntax highlighting.

The shell is central to automation, scripting, and system administration in Linux.

5. Graphics Server: Managing Visual Output

The graphics server handles all GUI-based rendering. The most common one is:

• X.Org Server (X11) – A traditional display server used in most distributions.

Newer alternatives like Wayland offer improved security and efficiency but are still under development.

6. Window Manager: Controlling the Desktop Environment

A window manager determines how windows appear and behave. Examples include:

• GNOME – A modern, user-friendly desktop.
• KDE Plasma – Highly customizable, feature-rich.
• MATE/XFCE – Lightweight, ideal for older hardware.

Users can mix and match window managers with different Linux distributions, customizing their UI experience.

7. Utilities: Essential System Tools

Linux provides a vast collection of utilities that allow users to perform system tasks efficiently. These include:

• File management: ls, cp, mv, rm
• Networking: ping, curl, wget
• Process management: top, htop, kill

These tools form the backbone of Linux, enabling precise control over the system.

Linux File System Hierarchy

The Linux file system follows a tree-like structure, with all files and directories organized under a single root directory (/). Unlike Windows, which assigns different drives (C:, D:), Linux mounts everything—including hard drives, external storage, and network file systems—under this unified structure.

This organization is governed by the Filesystem Hierarchy Standard (FHS), which defines how system files, user files, and applications should be arranged across Linux distributions. Understanding this structure is essential for:

• System administration – Knowing where system configurations, logs, and binaries are located.
• Troubleshooting – Quickly identifying issues related to missing files or misconfigurations.
• Security – Protecting sensitive files and preventing unauthorized access.

This guide will explore each major directory in the Linux file system and explain its role in maintaining system integrity and functionality.

The Root Directory (/): The Foundation of the Linux File System

The root directory (/) is the starting point of the Linux file system. All other directories branch out from it, forming a hierarchical structure. Every file and device, whether internal or external, is mounted somewhere within this hierarchy.

Since / is critical to system operation, it is often located on a separate partition to protect the core OS files from accidental modification.

Now, let’s examine the subdirectories found under /, their functions, and why they are essential.

Major Directories in the Linux File System

1. /bin – Essential System Binaries

The /bin directory contains fundamental system utilities required for basic operation. These binaries are available to all users and can be executed without elevated permissions.

Examples of Important Commands in /bin:

• ls – Lists directory contents.
• cp – Copies files and directories.
• mv – Moves or renames files.
• rm – Removes files or directories.
• cat – Displays the contents of a file.
• chmod – Changes file permissions.

If /bin is missing or corrupted, the system may fail to function properly.

2. /boot – Bootloader and Kernel Files

This directory stores files necessary for the boot process, including the Linux kernel and bootloader configuration. These files must remain intact for the system to start correctly.

Key Files in /boot:

• vmlinuz-* – The compressed Linux kernel.
• initrd.img-* – Initial RAM disk used during boot.
• grub/ – GRUB bootloader configuration files.

Since modifying these files can render a system unbootable, they should be handled with caution.

3. /dev – Device Files

In Linux, hardware devices are represented as files under /dev. This allows users and applications to interact with hardware through standard file operations.

Common Device Files:

• /dev/sda – First hard drive.
• /dev/tty – Terminal devices.
• /dev/null – A special file that discards all data written to it.
• /dev/random – Generates random numbers.

Many /dev entries are virtual files managed by the Linux kernel, rather than physical storage items.

4. /etc – Configuration Files

The /etc directory holds system-wide configuration files and startup scripts. Unlike Windows, which stores settings in a binary registry, Linux keeps configuration files in plain text, making them easier to modify and automate.

Important Configuration Files:

• /etc/passwd – User account information.
• /etc/shadow – Encrypted user passwords.
• /etc/fstab – Filesystem mount points.
• /etc/network/interfaces – Network configuration settings.

Since incorrect modifications can disrupt system behavior, it is best to back up important configuration files before making changes.

5. /home – User Home Directories

Each user in Linux has a dedicated directory inside /home, where personal files, configurations, and application data are stored.

Example Directory Structure:

• /home/littletofu/ – Home directory for user littletofu.
• /home/bob/ – Home directory for user Bob.

Users cannot access other users’ home directories unless they have appropriate permissions.

6. /lib – Shared System Libraries

The /lib directory contains essential shared libraries needed for the system and applications to function. These libraries are similar to Windows DLL files.

Examples of Important Libraries:

• /lib/libc.so.6 – The C standard library.
• /lib/modules/ – Kernel modules for hardware drivers.

Removing files from /lib can cause critical system errors.

7. /media – Mount Point for External Devices

The /media directory is used to automatically mount external storage devices, such as USB drives and DVDs. When a device is inserted, it typically appears under /media/username/.

8. /mnt – Temporary Mount Directory

Unlike /media, which handles automatic mounting, /mnt is used for manually mounting filesystems. System administrators often use this directory for temporary storage of external filesystems.

Example of manually mounting a USB drive:

mount /dev/sdb1 /mnt/usb

9. /opt – Third-Party Applications

The /opt directory is reserved for optional software packages that are not installed via the system’s package manager.

Examples of software stored in /opt/:

• /opt/google/ – Google Chrome installation.
• /opt/zoom/ – Zoom video conferencing software.

10. /root – Root User’s Home Directory

Unlike /home, which contains directories for regular users, /root is the home directory for the root user.

Root users have full system access, and misconfigurations in this directory can compromise security.

11. /sbin – System Administration Binaries

Similar to /bin, but contains commands meant for system administrators.

Examples of Commands in /sbin:

• fdisk – Partition management tool.
• shutdown – System shutdown and restart command.
• iptables – Firewall configuration tool.

Regular users cannot execute these commands without superuser privileges.

12. /tmp – Temporary Files

The /tmp directory is used for storing temporary files created by applications and system processes.

Since contents of /tmp are cleared upon reboot, it is not suitable for permanent storage.

13. /usr – User Applications and Libraries

The /usr directory contains user-installed software, libraries, and documentation.

Important Subdirectories:

• /usr/bin/ – User applications (e.g., firefox, nano).
• /usr/lib/ – Additional system libraries.
• /usr/share/ – Shared documentation and assets.

14. /var – Variable Data Storage

The /var directory holds frequently changing files, such as logs, mail queues, and temporary storage.

Examples of /var Usage:

• /var/log/ – System logs and error reports.
• /var/spool/ – Print and email queues.
• /var/www/ – Web server files.

System administrators often monitor /var/log/ for troubleshooting and security analysis.

Linux in Everyday Life: Where is Linux Used?

Linux is everywhere, even if you don’t realize it! Here are some of the most common use cases:

• Servers: Over 90% of the world’s servers run Linux, including those used by Google, Facebook, and Amazon.
• Smartphones: Android, the most popular mobile OS, is built on the Linux kernel.
• Supercomputers: All top 500 supercomputers in the world run Linux due to its performance and scalability.
• Embedded Systems: Routers, smart TVs, IoT devices, and even Tesla cars use Linux.
• Gaming: With Steam’s Proton compatibility layer, more games are now playable on Linux.