· Julia Frank

Coffee tips

Linux Basics Without the Overwhelm: A 7-Stop Beginner’s Roadmap

Julia

·

When I first started using Linux

I felt like I was constantly asking:
“Where do people actually learn this stuff?”

There’s a ton of scattered info online, and it’s not always beginner-friendly—especially when it comes to understanding the core concepts behind the tools we use every day.

So in this post, I’m breaking down the absolute basics every Linux beginner user should know, no matter what distribution you’re using, along with the most helpful and trustworthy resources I’ve found along the way.

Treat this as a Linux basics learning roadmap.

Core Concepts Every Linux User Should Know

1. What Linux Actually Is

First, Linux is not an operating system. It’s a kernel—the core piece that talks to your hardware. It handles memory, CPU, input/output, and loads everything else.

What we call a “Linux distro” (like Ubuntu, Fedora, Arch, etc.) is the kernel plus a collection of software, desktop environments, terminal tools, and a package manager that make it usable as a full operating system.

📚 Helpful resources:

2. The File System Hierarchy

Forget about C:\. Linux has a very different structure, starting at / (called “root”).

Here are a few key directories and what they’re for:

  • /home – where your personal user files live. Every user gets a subfolder here.
  • /etc – contains system configuration files. These are usually plain text files that control how software or services behave.
  • /bin – short for “binaries.” This folder holds essential command-line programs like ls, cp, mv, that are needed for basic system function.
  • /var – contains variable data, such as logs, databases, and files that change over time.

📚 Helpful resource:

3. Terminal vs Shell vs Command Line

They’re related but not the same:

  • Terminal = The graphical window or program where you type commands. (Think: GNOME Terminal, Konsole, iTerm2.)
  • Shell = The program that processes your commands and returns output. The most common is Bash, but there are others like Zsh, Fish, etc.
  • CLI (Command Line Interface) = The general concept of typing commands to interact with a computer instead of using a mouse. It’s the interface, and the shell is one way to access it.

💡 You can think of it like this:

  • Terminal = the tool you open,
  • Shell = the brain inside that tool,
  • CLI = the way you communicate.

Is CLI a program, or is it just a concept? I still do not quite get the difference between CI and terminal/shell combo.

Still not sure about the difference? Read the toggled note below. It will answer a common question about CLI. This one trips a lot of people up, so you’re definitely not alone!

CLI (Command Line Interface) Notes

🧠 CLI (Command Line Interface) = A concept or way of interacting with a computer.

It’s not a specific program. It just means you’re typing commands to give the computer instructions, instead of clicking around with a mouse like in a GUI (Graphical User Interface).

Think of CLI like the method or style of interaction.

🧰 Shell = A program that interprets your commands.

Examples of shells:

  • bash (Bourne Again Shell)
  • zsh (Z Shell)
  • fish (Friendly Interactive Shell)

These are the brains that read your typed commands and execute them.

🪟 Terminal = A program that gives you a window to use the shell.

Examples:

  • GNOME Terminal
  • Konsole
  • Alacritty
  • macOS Terminal
  • iTerm2

The terminal is like the container or tool that displays the shell and lets you type into it.

💡 A Simple Analogy
  • CLI = talking (method of communication)
  • Shell = the language (e.g., English, Spanish, Bash!)
  • Terminal = the phone or microphone you speak into
👇 So when you’re using the command line:
  • You’re using a CLI (concept)
  • Inside a Terminal (program)
  • Running a Shell (program)
Common Shell Commands to Learn Early:
  • cd – change directory
  • ls – list files
  • cp – copy files
  • mv – move/rename files
  • rm – delete files
  • grep – search text in files
  • chmod – change permissions
  • man – open the manual for any command (try man ls)

4. Package Management

This is how you install or update software. Unlike on Windows or macOS where you often download .exe or .dmg files, on Linux you mostly use package managers.

🧰 Different distros use different tools:

  • Ubuntu/Debian: apt (e.g. sudo apt install firefox)
  • Fedora/RHEL: dnf
  • Arch: pacman
Universal formats – wait, formats of what?

These are package formats that are not tied to any specific distro. They aim to work everywhere, regardless of what package manager your distro uses. They’re often used for desktop apps.

  • Flatpak – sandboxed apps with centralized permissions
  • Snap – similar to Flatpak, but made by Canonical (Ubuntu’s creators)
  • AppImage – portable apps that run from a single file without needing to install

5. Processes and Permissions

Let’s break this into two:

🔄 Processes

A process is any running program. You can monitor and manage them with:

  • ps – show current processes
  • top – live system monitor (try it!)
  • kill – terminate a process by its ID (PID)
🔐 Permissions

Linux uses a permission model based on users and groups. Every file and folder has rules:

  • r = read
  • w = write
  • x = execute

You’ll see permissions as something like -rwxr-xr--.

  • chmod – change who can read/write/execute
  • chown – change ownership of a file
  • sudo – “superuser do” – temporarily gives you admin powers to run commands that affect the whole system

This stuff sounds scary, but once you understand the pattern, it’s easy to manage.

6. Display Servers and Desktop Environments

This is where Wayland and X11 come in. These are called display servers – they’re responsible for drawing windows, moving your mouse, rendering graphics.

Above them, you have desktop environments (DEs), which are full user interfaces:

  • GNOME, KDE, XFCE, etc.

💡 The relationship is like this:

Wayland/X11 = the engine


GNOME/KDE/etc. = the dashboard of the car you drive (either fancy or minimalist: KDE is packed with features, GNOME is modern and clean, XFCE is simple and fast.

For a fun comparison:

GNOME = Tesla, KDE = BMW 7 Series, XFCE = old Toyota Corolla 😄.

Did I get it right? What do you think?

X11 vs Wayland
  • X11 is the older system—very flexible but also messy under the hood.
  • Wayland is the modern replacement—simpler, more secure, better scaling support.

There’s an ongoing debate about which one is “better,” similar to the systemd vs init debates. But don’t worry—you don’t have to pick a side right now.

📚 Resources:

7. System Logs and Services

Most modern Linux systems use systemd to manage services, start processes on boot, and handle logs.

Before systemd, many systems used SysVinit or Upstart. These were less centralized and had more manual configuration. systemd is faster and more powerful—but also more complex. Some users still prefer the old ways, which is why the debate lives on.

Key tools:
  • journalctl – lets you view system logs (like boot messages, errors, service outputs)
    • e.g., journalctl -xe shows recent error logs
  • systemctl – start/stop/enable/disable system services
    • e.g. sudo systemctl restart bluetooth

Where to Learn All This Stuff (Reliable Resources)

Here are the best places to start learning—some official, some community-made goldmines.

📘 Official Docs:

🌐 Free Learning Sites:

💬 Mention your favourite learning sites in the comments! 👇

How I Personally Learn

To be honest, I piece things together from a lot of places as the need comes up:

  • I read the Arch Wiki, even though I don’t use Arch.
  • I experiment in a VM (virtual machine) or on my own setup.
  • I Google stuff. A lot.
  • Reddit threads, GitHub issues, blog posts, YouTube videos—if it’s helpful, I’ll read it.
  • And sometimes… I make YouTube videos about what I’ve learned, which really forces me to understand it better.

Final Thoughts

Learning Linux is a journey, not a checklist.

The cool part?
You don’t need to know everything to start using it well.

Just take it one concept at a time, follow your curiosity, and don’t be afraid to break things (in a VM if you’re cautious 😉). That’s how we learn.

If you’re just starting out, I hope this gave you a clearer roadmap.

And if you’ve been around Linux for a while—what did you wish you knew sooner?
I’d love to hear it in the comments.

Now, start using Linux like you belong here (because you do)!

Julia Avatar
Julia
Tags: