Theory

Command-Line 101 - The Basics

Introduction 📖

Welcome to this command-line class!

In this entry level course you will learn how to use a terminal and navigate through a Linux filesystem.

You will be provided with real Linux terminals in the practice sections of this class (don't worry, we'll get to that a bit later) and will be able to follow the theoretical contents along in your browser.

What’s command-line 💻?

Let's start with the basics of command-line, what is it actually?

A command is an instruction (or a set of instructions) given to a machine.

A command-line is (by extension) a textual line containing one or multiple commands destined for a computer.

A command-line interface (or CLI) is an interface which is made to be interacted with using commands-lines, contrary to a graphical user interface (or GUI).

For instance, apps on your phone have GUIs, the browser on your computer has a GUI, but programs you might use in cmd.exe, powershell.exe or in Linux or Mac OS's terminals might be usable only with specific commands!

Commands are generally typed in a piece of software called a command-line interpreter (or shell) for a computer to do specific actions, there is a difference between a terminal (the window you are typing your commands in) and a shell (the piece software that is actually trying to understand and do something your commands).

Note : A remarkably high amount of people don't really know the difference between a terminal and a shell, you're already a step ahead of them now 😉.

Let's get back to our commands: a command usually looks like this :

$> open filename.txt

Note : The characters “$>” here are not part of the command, they represent the prompt usually displayed by shells to let the user know they can type a new command.

Oh also, open is a command that only works in certain specific contexts, it might not work on your own Linux terminal, but it's an easy to understand example ;).

What are the existing commands?

The commands you can possibly type depends on the command-line interpreter you use, and more generally on the Operating System you’re working on.

Windows machines used to understand commands based on DOS, nowadays they also use PowerShell’s syntaxes, Linux and “unix-like” machines (Ubuntu, MacOS) use commands similar to the Unix Shell, this is the type of commands we’re going to cover during this class.

Note : If you do not understand precisely what Linux, GNU/Linux and Unix are yet, it’s okay, it’s not mandatory for this course and you'll get there slowly.

Why do we (still) use command-line?

Whatever you can do with a graphical user interface, you can do with command-line, also most of the time command-line is much more efficient and lightweight! But don’t take what I tell you for granted, you’ll soon be able to try it for yourself.

Also, commands can be chained and logic can be added to their execution, which allows the automation of an almost infinity of tasks!

Hands-on 🤜!

Let’s start working on your first commands with a little bit of practice!

You will be guided through some exercises for your first experimentations!

Challenge 0 : Your First Commands

[NV Horizons Investigation - Briefing]

Welcome aboard the UNN Daedalus, investigator.

We've just recovered the black box from the NV Horizons, a research vessel whose crew vanished without explanation. The ship's logs are intact; but reading them means knowing your way around a Linux terminal.

Don't worry. We'll teach you as we go.

Your task

Click Open Terminal, then type each of these commands in order, pressing Enter after each one:

cd /mnt
cd nv_horizons
cd logs
ls
cat crew_log_0.txt
cd

If the terminal looks broken (cut off, weird wrapping, after using fullscreen), type resize and press Enter.

What did I just do? (click to expand)

cd — change directory

Moves you between folders, like double-clicking into a folder on your desktop. cd nv_horizons moved you into that folder. cd on its own brings you back to your home folder.

ls — list

Shows you what's in the current folder. Green entries are files, blue entries are folders.

pwd — print working directory

If you're ever lost, pwd tells you where you are.

cat — show file contents

Prints what's inside a file. Always followed by a filename, like cat crew_log_0.txt.

💡 In computing, lists usually start at 0, not 1. That's why this is Challenge 0.

Challenge 1 : Finding the Security Logs

[NV Horizons - Security Subsystem]

The general log shows an emergency protocol was triggered. We need more detail. Specifically, anything from the ship's security subsystem.

The crew's last actions were logged somewhere inside /mnt/nv_horizons. Find the security logs and read them.

Your task

Navigate into /mnt/nv_horizons
Find the folder that holds security logs and enter it
List what's inside
Read the log files

💡 If you get lost: pwd shows where you are, and typing cd alone takes you back home so you can start over.

Theory

Command-Line 102 - Filesystems and more

Linux filesystem arborescence 🌳

Let me tell you a bit about the way linux filesystems are organized.

/ is where everything starts, it’s the root of your filesystem, a little bit like your C: drive is usually where everything is stored on a Windows machine.

/home (which is located inside /, that’s why it starts with the same character) is where the user’s directories are usually stored. It is analogous to the C:\Users directory on Windows.

Each user has its own home 🏠 directory, you can see which one is yours using the following command :

$> echo $HOME

In a Linux terminal, the $ character designates a variable. The $HOME variable has been predefined in your terminal by the operating system, such a variable is named an environment variable.

Observe the difference between your terminal’s output when you type :

$> echo $HOME

and

$> echo HOME

Note : $HOME can also be replaced with the ~ character. Try to echo ~.

Manual pages 📚

Did you know that Linux comes with manuals for almost every command installed?

For instance,

$> man ls

will display the manual pages for the command ls.

You can use your keyboard’s arrows to navigate inside the manpages, the space key to skip to the next page and q to quit.

Stopping a command 🛑

Let’s say that you use the sleep command and type something like

$> sleep 42

Your shell is going to wait 42 seconds before allowing you to type new commands, until then, you’re stuck!

That's what the sleep command does, it waits for a given number of seconds!

If at some point you get stuck in a command-line which blocks the execution of new commands, you can use the CTRL + C shortcut to force the current program to quit.

Exiting a program in such a way is called killing a program.

Note : Some programs do not accept being killed and sometimes, closing your terminal window will be the most efficient way of stopping a program.

Echo 🔉

Echo (which for some reason always reminds me of Ecco the Dolphin) is an incredibly useful Linux command!

You can use it to display character strings on your screen.

For instance if you want to print “Hello, world”, you can type :

$> echo Hello, world

You can also use it to display a variable’s value, for instance :

$> echo Hello, $USER

Challenge 2 : Navigating Deeper

[NV Horizons - Engineering Logs]

The containment field is failing. Chief Engineer Vega's final stabilization attempt was logged somewhere in the ship's subsystems directory, nested inside the logs folder.

Find it and read the relevant file.

Your task

Navigate to the subsystems folder inside logs
Find the containment log file
Display its contents

💡 You can chain folder names in one cd command using slashes. For example, cd folder1/folder2 enters both at once. Absolute paths start with a / and work from anywhere on the system.

Challenge 3 : Reversed Logs

[NV Horizons - Comms Recovery]

An emergency broadcast was recovered, but the message is scrambled : characters appear in reverse. Almost certainly Engineer Vega's last attempt to transmit a containment protocol.

The corrupted file is in /mnt/nv_horizons/comms/corrupted.

Your task

Navigate to the corrupted comms folder
List its files with their sizes (some may be empty)
Read the most recent non-empty file
Reverse its contents to make it readable

💡 ls -l shows file sizes in the output. To reverse text, there's a command-line tool with a name very close to its purpose, try man-pages or search for "reverse" in a Linux cheatsheet.

Challenge 4 : Fragmented Files

[NV Horizons - Data Core]

Emergency protocols split critical logs into multiple files to prevent total data loss. The pieces are in /mnt/nv_horizons/logs/fragments.

You'll see three files: containment_sequence.part1, containment_sequence.part2, containment_sequence.part3.

Reassemble them, in order, to recover Vega's full command.

Your task

Navigate to the fragments folder
Display all three fragments together, in the correct numeric order

💡 The name cat comes from "concatenate" joining things together. It accepts more than one filename at a time.

Challenge 5 : Last Login

[NV Horizons - Forensic Audit]

The lockdown was triggered, but the security logs don't add up. Someone may have tampered with them.

The ship's authentication subsystem keeps the last logged-in user in an environment variable called LAST_LOGGED_USER. That value is our best lead for identifying who triggered the protocol.

Once you have the username, look them up in the crew directory at /mnt/nv_horizons/crew.

Your task

Display the value of the LAST_LOGGED_USER environment variable
Use the username you find to locate that crew member's file in /mnt/nv_horizons/crew
Display their record

💡 Environment variables can be printed individually if you know the name, or you can list all of them at once. Both approaches work for this challenge; try whichever you're more curious about.

Theory

Command-Line 103 - Hidden and Executable files

Hidden files 🕶️

Don't believe everything you see!

On a linux filesystem, every file and directory whose name starts with a dot . will be hidden.

Which means that such files will not be displayed when using a regular ls, ever.

But you can actually see those hidden files and directories using ls -a for “all” though.

This command will also display a new directory : a single dot . which means “the current directory” in Linux and also another one with two dots .. which means “the directory above this one in the filesystem tree structure”!

Observe the difference between :

$> ls .
$> ls -a .
$> ls ..

Advanced ls

ls is already an invaluable tool, but it can give you even more useful information about files and directories!

Using ls -l (that's a L as in leopard) on the /mnt/nv_horizons directory will print the following list :

$> ls -l /mnt/nv_horizons
total 24
drwxr-xr-x 6 1000 users 4096 Mar 20  2025 .
drwxr-xr-x 1 root root  4096 Oct  4 19:40 ..
drwxrwxr-x 3 1000 users 4096 Mar 20  2025 comms
drwxrwxr-x 2 1000 users 4096 Mar 20  2025 crew
drwxrwxr-x 5 1000 users 4096 Mar 20  2025 logs
drwxrwxr-x 2 1000 users 4096 Mar 20  2025 tools

We’re going to leave some of the information printed in this list for another class, but you should already recognize the file and directories names usually displayed by ls!

The first line “total 24” means that this directory uses a total of 24 filesystem “blocks” (but don't bother too much with blocks right now, okay?).

A block is simply a way of counting space on a Linux filesystem, a bit like the more commonly represented Mega octets and Kilo octets.

Note: For the sake of completion, a block is equivalent to 8KB => 8000 bytes. But to be honest, maybe don't bother remembering that right now.

The hours and dates are the last modification date for each item and the number printed on the left of the month (Jan->January in this example) is the file’s size in bytes.

Also keep in mind that in this list, lines starting with d are directories! The ones starting with - are files.

Executing scripts 📜

About scripts

What are scripts, you’re wondering?

Scripts are files containing commands and logic which can be used to automatize mostly any task you do on a computer!

Linux and other Operating Systems in general are full of scripts, some of them are used to install software, update files, make sure programs are not outdated, update the time, move log files, display alerts etc…

Executing your first script

In order to run a script, you just need to write its path in your terminal.

For instance, a script is located in /usr/bin/cowsay in your online terminal

You could type the following command in the terminal to run this script :

/usr/bin/cowsay hello

If you typed the command correctly, you should be greeted by :

 _______
< hello >
 -------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

Congrats, you just ran your first script (and far from the last)!

Now, this is not the only way to run a script.

The path you used here is what is called an absolute path. An absolute path starts from the root of your filesystem ("/").

On a Linux machine, everything starts with the "/" location. Then, you might have other directories such as "/bin", etc...

For instance, the existence of the absolute path /usr/bin/cowsay implies that the following structure exists on the Linux filesystem :

/  
  usr
    bin
      cowsay

But you can also run a script using its relative path, a relative path is, contrary to an absolute path, a path which does not start with “/”.

To run a script within the directory you are currently in, type “./” followed by the script name.

For instance, move inside the /usr/bin directory using cd /usr/bin.

Now, use the following syntax to run the same script again :

./cowsay hello

Hint : Don’t forget to type cd to go back to your home directory after!

Now that you're done with the theory, time for some practice!

Challenge 6 : Hidden in Plain Sight

[NV Horizons - Audit Trail]

Captain Voss executed unauthorized commands moments before the incident. His actions were recorded, but not in a file you'd see with a normal listing.

On Linux, files whose names start with a dot (.) are hidden by default. They don't show up unless you ask.

The captain's audit trail is one of these hidden files, somewhere under /mnt/nv_horizons/logs/.

Your task

Go through each subdirectory of /mnt/nv_horizons/logs/
List all files in each, including hidden ones
Find and read the captain's audit trail

💡 ls accepts a flag that means "show all, including hidden". It's a single letter. Check ls --help if you're not sure.

Challenge 7 : Running a Script

[NV Horizons - Engineering Console]

Voss really did override security. We need to know whether the ship's actual condition justified such an action.

The crew left diagnostic tools in /mnt/nv_horizons/tools. One of them is a script: a program written in plain text that the shell can execute.

Run it, and provide the credentials it asks for.

Your task

Navigate to the tools directory
Find the diagnostic script (probably ends in .sh)
Run it
When prompted, supply Engineer Vega's user ID

💡 Running a script in the current folder usually means prefixing it with ./ (e.g. ./script.sh). You can also use bash script.sh.

Crew IDs follow the format NVH-0XX. You've already seen crew records in earlier challenges; Vega's ID is in one of them.

Theory

Command-Line 104 - Parameters and Permissions

Let's enter our final section for this Linux101 class! And this sections starts with...

Parameters ⚙️

Parameters! Parameters are important : they are options you can add to your commands in order to change their behavior.

For instance, when you type :

$> ls -a

“-a” is a parameter that you add to the command ls.

When you type :

cat challenge_0.txt

“challenge_0.txt” is a parameter that you add to the command cat.

You can add an infinite number of parameters depending on the ones your script/program supports.

Note : Basically anything written after a single command is a parameter. Parameters are separated by a space.

Shortcuts and wildcards 🃏

History

In a Linux shell, you have multiple syntax helpers and keyboard shortcuts to avoid typing long commands or typing the same thing twice or more.

For instance if you want to run the same command that you just ran again, Key Up will go through your history and display the last command-lines you entered.

Note : The command history will also print the whole command-line history for your shell session.

You can also type :

$> !!

To run the last command again.

Autocompletion

Tab will autocomplete files and directories names, for instance if you type :

$> ls /mnt/nv_

And then press Tab, your terminal will automatically replace nv_ with “nv_horizon”.

In case of ambiguity, your shell will not automatically be able to autocomplete your commands, in that case, nothing will be displayed when you press Tab.

Pressing Tab twice in that situation will print the ambiguous file or directory names.

$> ls / # Press Tab twice and observe what is printed

Wildcards

A wildcard is a “magic” character that means everything.

In a Linux shell, a wildcard is represented by the * character, if you type it in your shell, it will be replaced before executing your command by every (non-hidden) files and directories in the current directory.

You can actually test this in your terminal using the following commands :

$> echo * # Will print every file and directory name
$> cat * # Will cat every file in the local directory

Wildcards can also be used in conjunction with other characters, at the start or the end of any character string.

$> echo chall*
$> echo *enge

Permissions

In a Linux filesystem, every file has associated permissions.

Permissions define which actions users or groups of users can do regarding those files and directories. Users

If you can enter commands on a computer, you are logged in as a user.

The command :

$> whoami

Will print your username, this is your identity on the machine.

The $USER environment variable also contains your username, you can display its value with :

$> echo $USER

Your Linux system does not always uses usernames in order to identify users, but each user have a numeric ID called a UID. You can also print your UID using :

$> echo $UID.

Groups

To make permissions management easier, users are divided in groups.

By default on Linux, whenever a user is created, it is part of its own, single-member group whose name is its own.

You can display the groups you are part of using the command :

$> groups

You can also display your username, UID, groups name and groups IDs (GIDs) using id :

$> id

Group IDs are the same as UIDs... but for groups! Unique identifier that are used by Linux instead of names that could be ambiguous.

Read, write, execute

Do you remember the ls -l listing we reviewed earlier? Let's imagine an example ls output:

$> ls -l challenges/command_line_101/
total 28
drwxrwxr-x    3 root     root          4096 Jan 11 21:59 .
drwxr-xr-x    3 root     root          4096 Jan 11 21:59 ..
-rw-rw-r--    1 root     root            96 Jan 11 21:59 .challenge_4
-rw-rw-r--    1 root     root           276 Jan 11 21:59 challenge5.sh
-rw-rw-r--    1 root     root           111 Jan  9 15:44 challenge_0.txt
-rw-rw-r--    1 root     root            77 Jan  9 20:57 challenge_1.txt
drwxrwxr-x    3 root     root          4096 Jan 11 21:58 challenge_2

It’s finally time to explain what all of this means, let’s start by investigating in details the first column of this list, the one with characters like -rw-rw-r--.

As I told you earlier, the first character can be either - (which represents an empty space) or d for “directory”.

Then, you have three sequences of “rwx”, each character of each sequence can also be a single -.

Those sequences describe the permissions associated to the file or directory :

    r - is for read

    w - is for write

    x - is for execute

Following this logic, r-- means “read permissions only”, rw- means “read/write permissions only, and rwx means read+write+execute permissions!

Why three consecutive sequences then?

The first sequence is for the user who owns the file/directory (specified in the third column), the second one is for the group who owns the file/directory (specified in the fourth column) and the third one is for everyone else on the computer.

Now, I'll leave you a small quizz before your final challenge! Good luck and hopefully I'll see you again for the part 2 of this course 😉!

Choose one answer

Quizz Permissions

I will give you specific information describing a file which you will have to translate into a ls -l permission line.

Here is the information you have to use:

You will describe a file, not a directory.
The owner of the file can read and write the file.
The group who owns the file can read it.
Anyone else can not do anything with the file.

Which line corresponds to the information given to you?

Challenge 8 : Stopping a Stuck Process

[NV Horizons - Final Transmission]

Some of the black box's logs may have been tampered with. This black box model can upload backups to the SolCom satellite network if we can reach a satellite, we might recover unaltered copies.

Vega's connection script is at /mnt/nv_horizons/tools/satconnect.sh. There's a problem: it's stuck in an infinite loop. We need to start it, wait for it to do its job, and then interrupt it manually.

Your task

Navigate to the tools directory
Run satconnect.sh
Let it run briefly, then interrupt it before the signal is lost

💡 To stop a running program in the terminal, hold Ctrl and press a specific letter. This sends an "interrupt" signal that asks the program to stop cleanly. (It's the same keypress that cancels a command you started typing but don't want to run.)