Linux

One command, a reboot, your own user. A real Linux environment next to Windows, no second computer and no manual VM setup.

Where to keep your files, why a project in a Windows folder is slow, how to open the code in an editor, and what to do about permissions.

Why DevOps runs on Linux, and why 99% of servers run it too.

What lives where: /etc, /var, /usr, /home, /opt. Why everything is a file.

A short quiz on the first two lessons. 5 questions, you can retake it.

Reinforce the filesystem: type the commands and run the drill on the topic.

PID, ps/top, what SIGTERM and SIGKILL mean, and how to stop a process cleanly.

rwx, octal, owners and groups. Why a script won't run even after chmod +x.

Chain commands together, send output to a file, and catch stderr along with stdout.

Six questions on processes, permissions, and pipes. Wraps up the first track.

An overview of the whole boot chain: from firmware to PID 1.

POST, BIOS vs UEFI, and MBR and GPT disk layouts.

What the bootloader does and where GRUB lives.

initramfs: a temporary root in memory.

systemd as init: targets, unit files, and parallel boot.

udev: how the system finds devices and populates /dev.

Quiz on the boot track. 5 questions, you can retake it.

How a process is born: fork, exec, exit, and the process tree.

Process states R/S/D/T/Z and where to find them.

Signals in depth: what gets caught and what doesn't.

Zombies and orphans: where they come from and how reaping clears them.

Daemons and background processes: setsid, nohup, disown.

Observing processes: ps, lsof, strace, /proc.

Quiz on the processes track. 5 questions, retakes allowed.

Seven file types in Linux and the first character in ls -l.

Hard and symbolic links, and inodes.

The virtual filesystems /proc and /sys.

tmpfs: a filesystem in memory.

Disk partitions and swap.

RAID 0, 1, 5, 10: fault tolerance and capacity.

A quiz for the filesystem track. 5 questions, retake anytime.

Why a process needs a virtual address space, and what pages, page tables, and the MMU are.

How anonymous memory differs from file-backed memory, what page cache is, and why free shows little free memory.

How swap works, what swappiness controls, and the rules the OOM killer uses to pick a victim.

Quiz on the memory track. 6 questions, retakes allowed.

namespaces: how the kernel hides the rest of the system from a process.

cgroups: how they limit CPU, memory, and IO.

A container as an ordinary process: namespaces + cgroups + capabilities.

Quiz on the isolation track. 5 questions, retakes allowed.

How systemd starts and keeps services running: unit files, systemctl, autostart, and dependencies.

Where systemd stores logs and how to read them: journalctl, filtering by unit, time, and priority, and following in real time.

How to install and update software across distros: repositories, update vs upgrade, and the difference between apt, dnf, and apk.

How to run jobs on a schedule: the five-field crontab format, common mistakes, and where the output goes.

What environment variables are, how processes set and inherit them, and why app config lives in the environment.

Where disk space goes and why you get "disk full": df vs du, mount points, inodes, and deleted-but-open files.

How to parse JSON in the shell: jq for filtering fields, arrays, and API output without eyeballing it.

What an inode is, why "there's space but the file won't create", and how a hard link differs from a symlink.

What an fd is, where "too many open files" comes from, and how to find a descriptor leak.

Soft and hard limits, the open-files limit under load, and where to raise them for services.

How key-based login replaces passwords: the key pair, authorized_keys, ssh-agent. Why it is more secure and how to set it up.

~/.ssh/config with host aliases, ProxyJump through a bastion, and why agent forwarding is dangerous.

How to protect the main entry point: disable passwords and root login, change the defaults, and close off the rest in sshd_config.

Where vulnerabilities in images come from, how scanners work, and why a scanner is a process and one signal among others, not a verdict.

The principle of least privilege in practice: roles instead of personal permissions, separation of duties, and why it limits the damage.

How users and groups work in Linux, where they are stored, and how sudo grants precise permissions without handing out root.

How to inspect a server's network setup: interfaces and addresses via ip, open ports via ss, and the routing table.

Basic regex syntax: anchors, classes, quantifiers, groups. Searching with grep -E and replacing with sed.

How to pack and unpack tar archives, how archiving differs from compression, and which formats you'll run into at work.

Open Linux in your browser, count the users in a prepared list, and save the number.

Check a file's size in kilobytes and save a single number.

Count the copies of one process and save the number.

Pick the largest of five files and save its name.

Count how many errors are in the application log and save the number.

Save only the ERROR-level lines from a log to a file.

Replace a value in a config with sed, without opening an editor.

Add up the numbers in a column with a one-liner using awk.

Remove all .tmp files from a directory, leaving everything else in place.

Get a sorted list of unique words from a file.

Create an executable script that prints hi.

Accept an argument in a script and write it to a file.

Read numbers from a file, add them up, print the result.

A script that behaves differently depending on whether a file exists.

Declare a function and call it with an argument.