Linux basics: versions and essential concepts

2026-04-02T02:00:00.000Z

Linux is not a single software package. It is an operating system ecosystem built around the Linux kernel, together with toolchains, package managers, service managers, and desktop environments. For a beginner, understanding how Linux versions are organized before learning a few essential concepts makes it easier to see the whole picture.

Linux versions

When people talk about a Linux version, they usually mean one of two things:

The kernel version
The distribution and its version

Kernel versions

The Linux kernel is the core of the operating system. It handles hardware, process scheduling, memory, filesystems, device drivers, and other fundamental tasks.

A kernel version commonly looks like this:

1
6.6.21

A useful starting point for reading these numbers is:

The first number identifies the major version.
The second identifies the release series within that version.
The third identifies a patch release.

Kernel releases concern low-level capabilities, including:

Support for new hardware
Improvements to scheduling and memory management
Filesystem and driver enhancements
Security vulnerability fixes

In enterprise environments, two kinds of releases commonly come up:

Stable kernels: releases maintained with fixes, used where stability matters.
Long-term support (LTS) kernels: releases maintained for longer periods, suitable for long-lived production systems.

The kernel version determines much of what the underlying system can do and how reliably it does it.

Common distributions

A kernel alone is not a complete working environment. Users also need command-line tools, package managers, an installer, service management tools, and default configuration. Together, these form a Linux distribution.

Common distributions include:

Ubuntu: approachable for beginners, with an active community and widespread desktop and server use.
Debian: known for stability and used as the foundation for many other distributions.
CentOS: historically common in server environments.
Rocky Linux: one of the enterprise-compatible alternatives adopted after changes to CentOS.
AlmaLinux: another enterprise-compatible option.
Fedora: a way to try newer software and features.
Red Hat Enterprise Linux (RHEL): a commercial enterprise distribution.
Arch Linux: emphasizes customization and rolling releases, and suits users with some Linux experience.

These distributions differ in several ways:

Package management tools, such as apt, dnf, yum, and pacman
Default configuration and directory conventions
How recent their software versions are
Stability and update policies
Community support and commercial services

An analogy can help:

The Linux kernel is the engine.
The distribution is the complete vehicle built around it.

Distributions may use similar kernels while providing noticeably different experiences for users and administrators.

Essential Linux concepts

The following ideas provide a foundation for understanding Linux.

1. Everything is a file

Many Linux resources can be accessed and manipulated through file-like interfaces, including:

Regular files
Directories
Devices
Pipes
Sockets

This consistent approach makes the system easier to work with and automate through scripts.

2. The directory structure

Linux organizes its directories as a tree starting at the root directory, /.

Some common directories are:

/home: home directories for regular users
/root: the root administrator’s home directory
/etc: system configuration
/bin: basic commands
/usr: user-space programs and shared resources
/var: frequently changing data, such as logs and caches
/tmp: temporary files

Learning Linux means becoming familiar with where things belong as well as learning commands.

3. Users and permissions

Linux is a multi-user operating system. Different users have different permissions to access resources.

Permissions commonly distinguish three groups:

u: the file owner
g: the group associated with the file
o: other users

The three basic permissions are:

r: read
w: write
x: execute

For example:

1
chmod 755 demo.sh

This grants:

Read, write, and execute permissions to the owner
Read and execute permissions to the group
Read and execute permissions to other users

Permissions are a foundation of the Linux security model.

4. Processes

When a program runs, it becomes a process. Linux assigns each process a process ID (PID), and the kernel schedules its execution.

A few useful ideas to keep in mind:

One program can start multiple processes.
Processes can run in the foreground or the background.
Processes compete for CPU time, memory, and other resources.
Services are processes that usually run for extended periods.

Common commands include:

1
ps
2
top
3
kill

5. The shell

A shell is the command interpreter between the user and the operating system. Common shells include:

bash
zsh
sh

When a user enters a command in a terminal, the shell interprets it and arranges for it to run. Many administration and automation tasks are implemented as shell scripts.

6. Package management

On Linux, software is commonly installed through a package manager rather than by double-clicking an installer.

Common tools include:

apt: used on Debian, Ubuntu, and related distributions
yum / dnf: used in the RHEL, CentOS, Rocky Linux, and AlmaLinux ecosystem
pacman: used on Arch Linux

Package managers help you:

Install software
Upgrade software
Uninstall software
Handle dependencies automatically

7. Services and daemons

Many Linux capabilities are provided by background services, including:

Web servers
Databases
SSH servers

These long-running background processes are often called daemons. Many modern Linux systems manage services through systemd, with commands such as:

1
systemctl start nginx
2
systemctl stop nginx
3
systemctl status nginx

8. Filesystems

A filesystem determines how data is organized and stored. Common Linux filesystems include:

ext4
xfs
btrfs

They differ in performance, reliability, snapshot capabilities, and extensibility. As a starting point, remember that data on a disk is organized through a filesystem.

Putting it together

You can approach Linux along two main lines:

Versions: distinguish the kernel from the distribution.
Everyday use: understand directories, permissions, processes, shells, package management, and services.

Thinking of Linux as a complete system:

The kernel provides the underlying capabilities.
The distribution shapes how you use those capabilities.
Concepts such as permissions, processes, and filesystems help you use the system effectively.

You do not need to memorize every command at the beginning. Build a clear mental model first. Learning common commands, user management, networking, and service deployment will be easier with that foundation.

EchoTint · Writing