Linux for Beginners

1.1 Why Linux is everywhere

• It is free — no licenses, no activation keys.
• It is open source — anyone can read, modify, and redistribute the code.
• It is modular — you can strip it down to a 5 MB embedded system or scale it up to a multi-thousand-core supercomputer.
• It is powerful from the command line — once you learn the shell, you can automate almost anything.
• It is stable and secure — designed from the ground up for multi-user, networked, always-on use.

1.2 How Linux differs from Windows / macOS

If you come from Windows, the biggest mental shift is that the command line is not optional — it is the primary interface for serious work. The graphical desktop is just one application running on top of the system. Most administrative tasks (installing software, configuring services, mounting drives) are still faster, clearer, and more reliable in the terminal than through any GUI.

Other key differences:

Path separators

Forward slashes /, never backslashes. /home/user/file, not C:\Users\user\file.

No drive letters

Everything lives under a single tree starting at / (the root). External drives and partitions are mounted into directories like /mnt/usb.

Extensions don't matter

A program is executable because of its permission bits, not because it ends in .exe. A text file can be called anything.

Case sensitivity

File.txt and file.txt are two different files. Watch your capitalization.

Software sources

From package repositories, not random websites. apt install firefox instead of downloading a .exe.

2.1 The filesystem hierarchy

Linux organizes everything into a single tree starting at / ("root"). Every file, every device, every drive lives somewhere under this tree. Here are the directories you will encounter most often:

The shorthand ~ always expands to your home directory. So cd ~/projects is the same as cd /home/majid/projects.

2.2 Everything is a file

This is one of Linux's foundational ideas. A regular document is a file — but so is a hard drive (/dev/nvme0n1), a USB port, a network connection, the random number generator, even running processes (/proc/1234). Programs read and write to all of them using the same operations they would use on a text file.

2.3 Users, root, and sudo

Linux is multi-user from the ground up. Every file has an owner, and every running program runs as some user. There is one special user named root who can do absolutely anything — read any file, kill any process, modify the kernel.

Logging in as root for daily work is dangerous (one typo can wipe the system), so the convention on Ubuntu/Debian is:

• Your normal account does most things — browse, edit your own files, run programs.
• When you need root power for one command, you put sudo in front of it. Linux asks for your password, runs that one command as root, then drops back to normal.
• Only users in the sudo group are allowed to do this. Your account is in that group by default on a fresh install.

sudo apt install nano       # install software
sudo mkdir /mnt/nvme        # create directory in protected location
sudo systemctl start docker # start a system service

2.4 File permissions

Every file in Linux has three sets of permissions: what the owner can do, what the group can do, and what everyone else can do. Each set has three flags:

r — read

View the contents of a file. For directories, list the files inside.

w — write

Modify the file. For directories, add or remove files.

x — execute

Run as a program. For directories, enter (cd into) it.

When you run ls -l you see something like:

-rw-r--r-- 1 majid majid 4096 May  1 17:22 notes.txt

That breaks down as: file type (- for file, d for directory, l for symlink), owner permissions (rw-), group permissions (r--), everyone-else permissions (r--), then the owner and group names.

Permissions are also written as octal numbers (each rwx group becomes a digit 0-7):

• 755 = rwxr-xr-x — typical for executables
• 644 = rw-r--r-- — typical for regular files
• 600 = rw------- — owner only (used for swapfiles, SSH keys, sensitive configs)

2.5 Processes

A process is a running instance of a program. Every process has a PID (process ID, a number), a parent process (every process is launched by another), a user it runs as, memory it has allocated, and file handles it has open.

You can list processes with ps or watch them live with top / htop. You stop a misbehaving process with kill <PID>.

2.6 The shell

The shell is the program that reads the commands you type and runs them. The default on Ubuntu is bash ("Bourne Again Shell"). Modern alternatives include zsh and fish.

Your prompt looks like this:

majid@majid-desktop:~$

Reading left to right: your username, the @ separator, the machine's hostname, the colon, your current directory (~ = home), and finally $ (which becomes # if you're root).

2.7 Streams, pipes, and redirection

Every program has three default streams:

• stdin (standard input) — where it reads from
• stdout (standard output) — where it writes results
• stderr (standard error) — where it writes error messages

By default they're all your terminal. But you can redirect them:

Real example:

echo "/mnt/nvme/swapfile  none  swap  sw  0  0" | sudo tee -a /etc/fstab

This prints the line (echo), pipes it to tee, which (with sudo and the -a "append" flag) writes it to the end of /etc/fstab. The trick here: sudo echo ... > /etc/fstab wouldn't work, because the redirect is done by your shell, not by sudo.

2.8 Package management

On Ubuntu/Debian-based systems (including JetPack), software comes from packages stored in online repositories. The tool that manages them is apt.

2.9 Services and systemd

Long-running background programs (Docker, networking, SSH, web servers) are called services or daemons. They're managed by systemd via the systemctl command.

2.10 Mounting filesystems

In Linux, drives don't get drive letters — they get attached ("mounted") into a directory in the existing tree. Once mounted, accessing that directory means accessing the drive.

An NVMe drive setup typically looks like:

Block device

/dev/nvme0n1 — the whole disk

Partition

/dev/nvme0n1p1 — the formatted partition

Mount point

/mnt/nvme — the directory it's attached to

The file /etc/fstab lists what should be auto-mounted at boot. Each line has 6 fields: source, mountpoint, filesystem type, options, dump, fsck order.

2.11 Environment variables

Variables that programs (and the shell) can read. They're spelled in UPPERCASE by convention. View one with the $ prefix:

echo $HOME       # /home/majid
echo $USER       # majid
echo $PATH       # list of folders the shell searches for commands

Set one for the current shell:

export MY_VAR="hello"

Make it permanent by adding the line to ~/.bashrc (your shell's startup file).

3.1 Navigation

3.2 File and directory operations

3.3 Viewing file contents

3.4 Editing files in the terminal

Two editors are common on Linux: nano (simple, friendly) and vim / vi (powerful, steep learning curve). For beginners, stick with nano.

3.5 Finding things

3.6 Permissions and ownership

3.7 System information and monitoring

3.8 Process management

3.9 Networking

3.10 Disks and filesystems

3.11 Archives and compression

3.12 Text processing

3.13 Miscellaneous essentials

4.1 Inspecting hardware and storage

lsblk shows a tree of every block device (drive) and its partitions. Useful for confirming a new drive is visible to the kernel.

lsblk

blkid prints the UUID, label, and filesystem type of a partition. UUIDs are stable identifiers that survive renaming, so you use the UUID rather than /dev/nvme0n1p1 in /etc/fstab.

sudo blkid /dev/nvme0n1p1

free, df, du — the three quick health checks for memory and disk usage.

free -h          # memory + swap usage
df -h /mnt/nvme  # show free space on the NVMe
sudo du -sh /var/lib/docker  # how big is this folder?

4.2 Partitioning and formatting

parted — partition table editor:

sudo parted /dev/nvme0n1 --script mklabel gpt
sudo parted /dev/nvme0n1 --script mkpart primary ext4 0% 100%

The first line wipes the disk and creates a fresh GPT partition table. The second creates one partition spanning the entire disk, hinting at ext4. The --script flag makes parted run non-interactively so it doesn't prompt.

mkfs.ext4 — create the filesystem:

sudo mkfs.ext4 -L jetson-nvme /dev/nvme0n1p1

Formats the new partition as ext4 (Linux's standard journaling filesystem) with the label jetson-nvme. The label is a friendly name; the UUID is what fstab uses.

4.3 Mounting and /etc/fstab

sudo mkdir -p /mnt/nvme
sudo mount /dev/nvme0n1p1 /mnt/nvme

Persistent mount via fstab:

echo "UUID=fa4e... /mnt/nvme ext4 defaults,noatime,nofail 0 2" | sudo tee -a /etc/fstab
sudo mount -a    # apply all fstab entries now

Anatomy of an fstab line

UUID=...

What to mount. UUID survives device renaming.

/mnt/nvme

Where to mount it.

ext4

Filesystem type.

defaults

Sane defaults (rw, exec, suid, etc.).

noatime

Don't update last-access timestamps. Faster, less SSD wear.

nofail

Don't block boot if drive is missing.

0

Dump flag (legacy, almost always 0).

2

fsck order at boot (0=skip, 1=root only, 2=other).

4.4 Taking ownership

sudo chown -R $USER:$USER /mnt/nvme

Recursively changes the owner and group of /mnt/nvme to your user. The shell expands $USER to your username before running the command. The -R flag means "recursive" — apply to everything inside.

4.5 Creating a swapfile

sudo fallocate -l 8G /mnt/nvme/swapfile
sudo chmod 600 /mnt/nvme/swapfile
sudo mkswap /mnt/nvme/swapfile
sudo swapon /mnt/nvme/swapfile

Step by step:

• fallocate -l 8G — instantly reserve 8 GB on disk (no zero-fill, fast).
• chmod 600 — make it owner-only readable/writable. Mandatory — mkswap refuses otherwise.
• mkswap — write swap-format header so the kernel recognizes it.
• swapon — activate it now. Adding a fstab entry auto-activates at boot.

4.6 Copying with rsync

sudo rsync -aP /var/lib/docker/ /mnt/nvme/docker/

rsync is a smart copy tool. -a means "archive mode" — preserve permissions, ownership, timestamps, and symlinks. -P combines progress display and resume support. The trailing slash on the source (/var/lib/docker/) means "copy the contents of this directory" rather than the directory itself.

4.7 Editing config files via heredoc

sudo tee /etc/docker/daemon.json > /dev/null <<'EOF'
{ ... json content ... }
EOF

This is a heredoc — everything between <<'EOF' and the closing EOF is fed to tee as input, which writes it to the file. The > /dev/null silences the echo back to terminal. Useful for atomic config writes without nano typos.

4.8 Adding yourself to a group

sudo usermod -aG docker $USER
groups $USER          # verify
newgrp docker         # activate in current shell

-aG: a = append (don't replace existing groups), G = supplementary group. Without -a, you would replace ALL your other groups with just "docker" and lock yourself out of sudo.

Group changes only take effect after login, so newgrp docker gives the current shell the new permissions immediately. A logout/login makes it permanent everywhere.

4.9 Controlling services with systemctl

sudo systemctl status docker --no-pager
sudo systemctl stop docker
sudo systemctl stop docker.socket
sudo systemctl stop containerd
sudo systemctl start docker

The --no-pager flag prevents systemctl from opening less — useful when piping output to head or capturing it in a script.

4.10 Installing software with apt

sudo apt install -y nano

The -y flag answers "yes" to the confirmation prompt. Use carefully — it commits to the install without showing you the package list first.

4.11 Docker quick-reference

5.1 Keyboard shortcuts that change your life

5.2 Tab completion is your best friend

Almost every modern shell command supports Tab completion. Type the first few letters and press Tab — the shell will fill in file names, command names, package names, even Git branches. If there are multiple matches, Tab twice shows them all.

5.3 Read the manual

Almost every command has a manual page accessible via man:

man ls
man chmod
man fstab

Inside man, / searches, n / N jumps to next/previous match, q quits. For a brief built-in help, most commands also accept --help:

ls --help | less

5.4 Common pitfalls

• Forgetting sudo. If a command says "permission denied" while modifying system files, you probably need sudo.
• Putting sudo in front of a pipe / redirect. sudo echo x > /etc/fstab doesn't work because the redirect is performed by your shell, not by sudo. Use sudo tee instead.
• Spaces in arguments. rm my file tries to delete two files. Quote it: rm "my file".
• Hidden files. Files starting with . (like .bashrc) are hidden from ls by default. Use ls -a.
• Case sensitivity. Documents and documents are different folders.
• Deleting symbolic link contents. rm -rf link/ with the trailing slash can follow the link and delete its target. Drop the slash to delete just the link.
• Editing files without backups. Before editing important configs, copy them: sudo cp /etc/fstab /etc/fstab.bak.
• Forgetting && vs ;. With ; the second command runs even if the first failed. With && it only runs on success — much safer for sequences.

5.5 Ten habits to build

1. Read what's on screen before pressing Enter. The shell does not protect you.
2. Use Tab completion for every path. Less typing, fewer mistakes.
3. Test rm with ls first. Replace rm with ls to verify the same glob matches the right files.
4. Back up before editing system configs. A .bak copy costs nothing and saves hours.
5. When in doubt, man <cmd> or add --help. Faster than Googling.
6. Keep notes. A file like ~/notes/setup.md pays for itself a hundred times.
7. Use history to recover "what did I just do?" Especially after a long debugging session.
8. Prefer absolute paths in scripts. Relative paths break when cd gets involved.
9. Read error messages slowly. They almost always tell you what's wrong.
10. Never paste a command from the internet without understanding what each part does. Especially anything starting with sudo.

5.6 Going deeper

When you're ready for the next level, look into:

Bash scripting

Automate repetitive sequences. The "Bash Guide for Beginners" is a good start.

Vim or Neovim

Once you climb the learning curve, editing speed jumps dramatically.

tmux

Keep sessions alive across SSH disconnects, run multiple panes side by side.

SSH keys

Passwordless secure login between machines.

git

Version control. The universal tool of modern development.

cron / systemd timers

Schedule tasks to run automatically.

Regular expressions

Supercharge grep, sed, find, and almost every text tool.