Linux for students — kernel, shell, terminal and the folder tree before IC2 (and the “cd documents” that found nothing)

When I was told in Computer Engineering II (IC2) that we’d be working with Linux, my first reaction was “why don’t we just use Windows like always?”. The second came in the first lab: I opened the Fedora terminal, typed cd documents and bash replied No such file or directory. The folder was right there, I could see it in the file manager… but it was called Documents, with a capital D. Linux doesn’t guess: it does exactly what you type, letter by letter.

If you’re in the same situation, this article is for you. Here I explain everything I wish I’d known before opening the terminal for the first time: what Linux really is, why it’s used in the degree, what the kernel, the shell and the terminal are, how folders are organised and how to move around with paths. No unnecessary jargon, and with a real terminal session for you to try yourself.

What is Linux, really?

Linux is usually presented as an operating system, like Windows or macOS. That’s only half true: technically, Linux is just the kernel, the core that talks to the hardware. What you install on your computer is a distribution: the Linux kernel plus lots of tools, libraries, a desktop environment and programs packaged together. Fedora, Ubuntu, Debian and Arch are different distributions that use the same kernel.

What makes Linux special is that it’s free and open source: anyone can see how it works inside, modify it and distribute their own version. That’s why there are hundreds of distributions and why it’s everywhere: servers, Android phones, supercomputers and, in IC2, your Fedora virtual machine.

Why Linux for students in a Data Engineering degree?

It’s the first question everyone asks: you’re studying data, not systems administration. Why Linux? There are very concrete reasons:

• The world’s servers run Linux. When you deploy a web app, a machine learning model or a data analysis in production, it will almost certainly run on Linux. Learning it during the degree means learning the real working environment.
• Data tools were born on Linux. Python, R, Git, Docker, C compilers: everything is designed for Linux first. On Windows they work, but with more friction (paths, permissions, installations).
• The terminal is far more powerful. With one command line you automate tasks that would take hours of clicking on Windows.
• It’s what IC2 uses to compile C, write scripts and understand processes and permissions. The sooner you get used to it, the better.

The story in two minutes — only what matters

You don’t need to learn the whole history of Unix to pass IC2, but three milestones explain why Linux exists and why it’s called what it’s called:

• 1969 — Unix is born at Bell Labs. Ken Thompson and Dennis Ritchie create an operating system designed to be simple, portable and efficient. It’s the grandfather of almost every modern system (macOS descends from it too).
• 1983 — Richard Stallman launches the GNU project. He wanted a completely free operating system. His project built essential tools (compiler, editors, terminal utilities), but the central piece was missing: the kernel.
• 1991 — Linus Torvalds writes the Linux kernel. A 21-year-old Finnish student publishes the kernel GNU was missing. Together they make the first complete free system for PCs; hence the technical name GNU/Linux.

Since 2003 there has been Fedora, the Red Hat-sponsored distribution we use in IC2 (today, Fedora 44). In the terminal session below you’ll see that uname -o literally answers GNU/Linux.

What the kernel is — and why it matters

The kernel is the core of the operating system: the deepest layer of software, the only one that talks directly to the hardware. It decides which program uses the CPU at each moment, how much memory each one gets, who can read each file and how to talk to the disk, the keyboard or the network. You never use it directly: there’s always something in between.

Think of it as in the diagram, from the bottom up:

1. Hardware: the CPU, RAM, disk, network. The metal.
2. Kernel (Linux): the middleman that manages memory, processes, files and devices.
3. Shell (bash): the layer you see and use. It takes your commands as text and turns them into requests to the kernel.
4. Applications: Firefox, VS Code, python3, gcc… the programs running on top of everything.

Why does it matter? Because when you get an error in IC2, knowing which layer it comes from tells you where to look. command not found comes from bash: it doesn’t know that command (usually a typo). Permission denied comes from the kernel: the command exists, but your user isn’t allowed (you’ll see it in Linux permissions).

The terminal, the shell and the console, what’s the difference?

This is the most common confusion when starting out: they’re used as synonyms, but they aren’t the same thing.

• Terminal: the window. The program that shows you a cursor and lets you type. In Fedora it’s called Terminal (formerly GNOME Terminal); on Windows, the equivalent is the cmd or PowerShell window. The terminal itself interprets nothing: it only displays.
• Shell: the command interpreter that lives inside the terminal. It reads what you type, interprets it and asks the kernel. There are several: sh, bash, zsh, fish.
• bash: the most common shell on Linux and the one you’ll use in IC2. When you open the Fedora terminal you’re already in bash (in the session below, echo $SHELL confirms it: /bin/bash).
• Console: today almost a synonym for terminal. Historically it was the keyboard and screen physically attached to the computer.

The analogy that helped me most: the terminal is the phone, bash is the language you speak through it and the kernel is the person at the other end who does what you ask. Look at the full journey of a simple command:

You type ls GCID in the terminal; bash understands that you want to list that folder; the kernel reads it from the disk; and the answer (FP1 and IC2) travels back the same way to the window. Three different pieces, a single chain.

Why the terminal and not a graphical interface?

Fedora has a perfectly good file manager. You could click through folders instead of typing ls. So why learn the terminal?

• Speed: moving, searching or renaming a hundred files is one line, not a hundred clicks.
• Automation: commands can be saved in a script and repeated whenever you like. Clicks can’t.
• Remote access: when you connect to a server over the network you only get a terminal, no graphical environment. That’s how almost every server in the world is administered.
• Precision: a command does exactly what it says. No hidden menus.

The file system, how Linux organises everything

On Windows you’re used to C:\Users\Sergio\Documents. On Linux there are no drive letters: everything hangs from a single root called / (slash). It’s a tree that starts at / and branches downwards; a USB stick or the VirtualBox shared folder isn’t a “D:”, but just another folder in the tree (under /average or /mnt).

Folder	What it holds
/	The root: everything starts here
/bin and /usr/bin	Commands and programs (ls, cp, python3)
/etc	System configuration files
/home	Users’ personal folders (/home/sergio)
/tmp	Temporary files (cleared on reboot)
/usr	Installed programs and their libraries
/var	Data that changes: logs, caches
/average and /mnt	External drives, USB sticks, shared folders
/dev	Devices seen as files (disks, terminals)

The most important thing to remember: your personal folder is /home/your_user and its shorthand is ~. Everything you create and save should live there. When you open the terminal, you always start there.

Absolute vs relative paths

This concept confuses beginners, but it’s essential for moving around with cd:

• An absolute path starts at the root / and works wherever you are: /home/sergio/GCID/IC2.
• A relative path counts from the folder you’re in: if you’re in /home/sergio, the same folder is simply GCID/IC2.

Two shortcuts appear everywhere: . is “the current folder” and .. is “the folder above”. And ~ is your personal folder.

In the diagram, the violet path (/home/sergio/GCID/IC2) starts at /; the coral one (GCID/FP1) starts at ~. They’re the same folders you’re about to create in the terminal.

Try it in your terminal

Open your Fedora terminal and type these commands one at a time. This is the session I ran (with the user sergio); on your computer you’ll see your own user name:

$ whoami
sergio
$ cd ~
$ pwd
/home/sergio
$ echo $SHELL
/bin/bash
$ uname -o
GNU/Linux

whoami tells you which user you are; cd ~ takes you to your personal folder and pwd (print working directory) confirms where you are: /home/sergio. echo $SHELL shows the shell you use (bash) and uname -o the system: GNU/Linux, the full name we talked about in the history section.

Now create the folder structure for the degree and look at it:

$ mkdir -p GCID/FP1/topic_variables GCID/IC2
$ ls
GCID
$ ls GCID
FP1
IC2

mkdir -p creates the whole chain of folders at once (-p also creates the intermediate ones and doesn’t complain if they already exist). In your terminal, ls will put the names on a single line (FP1 IC2); here they come out one per line because the output was saved to a file instead of being shown in a window.

And now, moving around with both kinds of path:

$ cd GCID/FP1
$ pwd
/home/sergio/GCID/FP1
$ cd /home/sergio/GCID/IC2
$ pwd
/home/sergio/GCID/IC2
$ cd ..
$ pwd
/home/sergio/GCID
$ cd ~
$ ls -d /bin /etc /home /tmp /usr /var
/bin
/etc
/home
/tmp
/usr
/var

Look at each pwd: with the relative path GCID/FP1 we reach /home/sergio/GCID/FP1 because we started from ~; with the absolute /home/sergio/GCID/IC2 it doesn’t matter where we were; cd .. goes up one level and leaves us in /home/sergio/GCID. The last command checks that the main folders of the tree really exist (ls -d lists them without going inside).

What to watch:

1. pwd is your compass: if you get lost, ask where you are before going on.
2. Relative paths depend on where you are; absolute ones don’t (they start with /).
3. .. always goes up one level and ~ always takes you home.
4. Commands that say nothing went fine: cd and mkdir only speak up when there’s an error.

The errors you’ll see (and what they mean)

Now, on purpose, the typical first-week stumbles:

$ cd ~
$ Ls
bash: Ls: command not found
$ cd topic_variables
bash: cd: topic_variables: No such file or directory
$ cd GCID/FP1/topic_variables
$ pwd
/home/sergio/GCID/FP1/topic_variables
$ cd documents
bash: cd: documents: No such file or directory
$ mkdir My notes
$ ls
My
notes

• Ls: command not found: Linux is case-sensitive. ls exists; Ls doesn’t. It’s bash talking, because it can’t find any command with that name.
• cd topic_variables fails from ~ because that folder isn’t there, but inside GCID/FP1. With the full relative path, it works.
• cd documents: my anecdote. If the folder doesn’t exist with that exact name, there’s nothing to be done. Use ls first to see what it’s really called (and Tab to complete it).
• mkdir My notes creates two folders, My and notes, because the space separates arguments. If you really want a space, type mkdir "My notes"; better still, my_notes.

Distributions — why there are so many “Linuxes”

When someone says “I’m going to install Linux” they mean “I’m going to install a Linux distribution“: the kernel plus a packaged set of software. Each one makes different choices (which programs it ships, how often it updates, how packages are installed):

Distribution	What it’s known for	Installing packages
Fedora	Modern and stable; the IC2 one, sponsored by Red Hat	sudo dnf install
Ubuntu	The most popular on desktops; tons of help in forums	sudo apt install
Debian	Very stable; Ubuntu’s base	sudo apt install
Arch Linux	For people who want to build everything by hand	sudo pacman -S
Red Hat Enterprise Linux	Company servers (Fedora’s big sister)	sudo dnf install

The good news: the terminal commands you’ll learn in IC2 work the same on all of them. What mostly changes is how you install programs.

Open source — what it actually means

Open source means the source code is public: anyone can read it, study it, modify it and publish their own version. For you as a student it has very practical consequences:

• All the IC2 tools are free, no licences to buy.
• You can look at how any tool is built and learn from it.
• If something fails, someone has almost certainly already asked and solved it in a forum.
• What you learn is transferable: it works the same on your laptop, on a university server and on a cloud machine.

Getting comfortable with the terminal — the right mindset

The terminal feels intimidating at first because you have to know what to type: there’s no menu to browse. But that’s exactly its strength: once you know the commands, you’re faster than anyone with a mouse. The learning curve is real but short: after two weeks of IC2 you’ll move around the folders without thinking.

The most important thing when you’re starting: with your normal user you can’t break the system. Dangerous commands need sudo (administrator permissions) and will ask for your password. So explore, experiment and make mistakes. Just respect two things: sudo and rm (delete), which on Linux has no recycle bin.

Summary

Concept	In one sentence
Linux	The kernel; with the GNU tools it makes GNU/Linux
Distribution	Kernel + packaged programs (Fedora in IC2)
Kernel	Manages memory, processes, files and devices
Shell / bash	Interprets what you type and asks the kernel
Terminal	The window you type in
/	The root of the tree: no drive letters
~	Your personal folder (/home/your_user)
Absolute / relative path	From / / from where you are
. and ..	The current folder / the one above

Three ideas to take away:

1. Terminal, shell and kernel are three different pieces: the error tells you which one complained.
2. Everything is a single tree that starts at /; your place is ~.
3. Linux does exactly what you type: capitals, spaces and exact names matter (and pwd, ls and Tab save you).

What’s next

With all this clear you have the context to start working in the terminal. If you don’t have Fedora yet, you need to install it before going on: here’s the full guide to install Fedora on VirtualBox. And the next article is where the real action starts: the basic Linux commands you’ll use every day in IC2 to navigate, create, copy and move files.

Keep goingAll Fundamentals articles

Did this article help you? Here is how you can support SergioLearns →