Click any module to expand. This is NOT a "read about Linux commands" module — every topic is hands-on. Students execute commands on a live Linux terminal, write shell scripts that run, and troubleshoot real problems. The goal: by the end, the terminal feels like home.
What Linux is, how the filesystem is organised, and navigating with confidence
Linux kernel vs distributions (Ubuntu, CentOS, Debian, Arch). Open source model. Where Linux runs: servers (90%+ of the internet), cloud (AWS/Azure/GCP = Linux), Android, embedded systems, supercomputers. Why every tech company uses Linux and why every developer must know it.
/ (root), /home (user data), /etc (configuration), /var (logs, variable data), /tmp (temporary), /proc (virtual — process info), /dev (devices), /bin & /usr/bin (commands), /opt (optional software). "Everything is a file" philosophy. Why knowing the hierarchy matters: where to find logs, configs, and executables.
pwd (where am I), ls (what's here — ls -la for details, ls -lh for human-readable sizes), cd (go there — cd ~, cd -, cd ..). Absolute vs relative paths. tree for directory visualisation. Tab completion and command history (↑, Ctrl+R reverse search).
Creating files (touch), directories (mkdir -p for nested). Copying (cp -r for recursive), moving/renaming (mv), deleting (rm -rf — the dangerous one). Why rm -rf / is the scariest command and how to prevent it. Wildcards: *, ?, [abc], {a,b,c} for batch operations.
Hard link = another name for the same inode (same data). Symbolic (soft) link = pointer to a filename (like a shortcut). ln for hard links, ln -s for symbolic. When links break: deleting the target. "What's the difference between hard and soft links?" — a standard Linux interview question. Inodes explained.
cat (display entire file), less (paginated viewing — search with /), head -n (first N lines), tail -n (last N lines), tail -f (live follow — watching logs in real-time). wc (word count: lines, words, characters). These are used hundreds of times daily in any Linux role.
Who can read, write, and execute what — the Linux security model
Three permission types (r=4, w=2, x=1) for three groups (owner, group, others). Reading -rwxr-xr-x: owner can read+write+execute, group and others can read+execute. Directories: r = list contents, w = create/delete files, x = enter directory. The permission string every Linux user must read instantly.
Symbolic: chmod u+x file (add execute for owner), chmod go-w file (remove write for group+others). Octal: chmod 755 file (rwxr-xr-x), chmod 644 file (rw-r--r--). Common permissions: 755 for scripts/directories, 644 for config files, 600 for private keys. Why 777 is almost always wrong.
chown user:group file — change ownership. chgrp group file — change group. umask: default permission mask (umask 022 means new files get 644, new dirs get 755). Why umask matters for security. sudo chown for privileged operations.
setuid (4xxx): file executes as the FILE OWNER, not the user running it. Why /usr/bin/passwd has setuid — it needs root to modify /etc/shadow. setgid (2xxx): new files in directory inherit the directory's group. Sticky bit (1xxx): only file owner can delete in shared directories (/tmp has sticky bit). Security implications of each.
useradd, userdel, usermod — creating and managing users. groupadd, groupdel, gpasswd. /etc/passwd (user info), /etc/shadow (encrypted passwords), /etc/group (group memberships). sudo and the sudoers file. Why root login is disabled on production servers. su vs sudo — the distinction.
ssh user@host — connect to remote servers. SSH key-based authentication: ssh-keygen, ssh-copy-id, ~/.ssh/authorized_keys. Why keys are better than passwords (no brute-force, no typing). scp for file transfer, rsync for efficient synchronisation. SSH config file (~/.ssh/config) for shortcuts. Every developer uses SSH daily.
grep, sed, awk, find, sort, cut, uniq — the command-line data processing toolkit
grep "pattern" file — find lines matching a pattern. grep -i (case-insensitive), -r (recursive), -n (line numbers), -c (count), -v (invert — lines NOT matching), -l (filenames only). grep -E for extended regex. egrep shortcuts. "Find all ERROR lines in all log files" — the daily task grep solves.
Basic regex: . (any char), * (zero or more), ^ (start), $ (end), [abc] (character class), [^abc] (negation). Extended regex: + (one or more), ? (zero or one), {n} (exactly n), | (alternation), () (grouping). Regex is used in grep, sed, awk, and every programming language. The 10 patterns that cover 90% of real-world regex use.
sort (alphabetical, -n numeric, -r reverse, -k field, -t delimiter). cut -d',' -f2 (extract fields from CSV). uniq (remove adjacent duplicates — always sort first). tr (translate/delete characters: tr 'a-z' 'A-Z'). tee (write to file AND stdout simultaneously). Combining these with pipes for data processing.
find /path -name "*.log" (by name). -type f (files), -type d (directories). -mtime -7 (modified in last 7 days), -size +100M (larger than 100MB). -exec command {} \; (execute command on each result). find + xargs for parallel execution. "Find all Python files modified today larger than 1MB" — one find command.
sed 's/old/new/' file — substitute first occurrence per line. sed 's/old/new/g' — all occurrences. sed -i for in-place editing. Address ranges: sed '5,10d' (delete lines 5–10). sed '/pattern/d' (delete matching lines). Practical: update config files, fix formatting, batch text replacement. sed is the command-line find-and-replace.
awk '{print $1, $3}' file — extract columns 1 and 3. Field separator: awk -F',' (CSV parsing). Patterns: awk '$3 > 100' (filter by condition). Built-in variables: NR (line number), NF (field count), $NF (last field). BEGIN/END blocks. Calculations: awk '{sum+=$3} END{print sum}'. awk turns structured text into analysed data — the command-line equivalent of a spreadsheet.
Connecting commands together and managing running programs
File descriptors: 0 (stdin), 1 (stdout), 2 (stderr). Redirect output: command > file (overwrite), command >> file (append). Redirect errors: command 2> errors.log. Redirect both: command > output.log 2>&1. /dev/null — the black hole for unwanted output. Redirect input: command < file.
cmd1 | cmd2 — stdout of cmd1 becomes stdin of cmd2. Building pipelines: cat access.log | grep "404" | awk '{print $7}' | sort | uniq -c | sort -rn | head. Command chaining: && (run next if success), || (run next if failure), ; (run regardless). The Unix philosophy: small tools combined into powerful workflows.
ps aux (all processes with details), ps -ef (full format). top (real-time process monitor — CPU, memory, PID). htop (better top — colour-coded, interactive). Identifying resource-heavy processes. Reading top output: %CPU, %MEM, VIRT, RES, SHR. "Which process is consuming the most CPU?" — the first question when a server is slow.
kill PID (send SIGTERM — polite termination). kill -9 PID (SIGKILL — forced). killall name (kill by name). nice -n 10 command (start with lower priority). renice (change priority of running process). Background: command & (start in background), Ctrl+Z (suspend), bg (resume in background), fg (bring to foreground). jobs (list background jobs).
echo $PATH (where the shell finds commands), $HOME, $USER, $SHELL, $? (exit code of last command), $$ (current PID). Setting variables: export VAR=value. .bashrc (runs on every new terminal), .bash_profile (runs on login). Customising the prompt (PS1). Adding directories to PATH. Why understanding PATH matters: "command not found" errors.
Debian/Ubuntu: apt update, apt install, apt remove, apt search. RHEL/CentOS: yum install / dnf install. Adding repositories. Checking installed packages. Why package managers exist: dependency resolution, version management, security updates. snap and flatpak for cross-distribution packages. Building from source: ./configure && make && make install.
Automating tasks with scripts — variables, control flow, functions, and real automation
#!/bin/bash (shebang line — tells the system which interpreter). Making scripts executable: chmod +x script.sh. Variables: name="value" (no spaces around =). Accessing: $name or ${name}. Read-only variables: readonly. Command substitution: result=$(command). Quoting: "double" (expands variables) vs 'single' (literal).
if [ condition ]; then ... fi. Test operators: -eq, -ne, -lt, -gt (numeric), = , != (string), -f (file exists), -d (directory exists), -z (empty string), -n (non-empty). [[ ]] for advanced tests (regex, &&, ||). case statement for multi-branch. The [ vs [[ distinction — a common scripting bug source.
for i in {1..10}; for file in *.log; for i in $(seq 1 100). C-style for: for ((i=0; i<10; i++)). while read line; do ... done < file (process file line by line). while true for infinite loops (daemons, watchers). until (opposite of while). break and continue. Processing files, batch renaming, iterating over servers.
function_name() { ... } for reusable code blocks. local keyword for local variables. Return values ($?). Positional parameters: $1, $2, $@ (all args), $# (count). shift to process arguments one at a time. getopts for parsing flags (-f, --file). Building scripts that accept arguments like real command-line tools.
$? — exit code of last command (0 = success, non-zero = failure). set -e (exit on first error), set -u (error on undefined variables), set -o pipefail (pipe failure propagation). trap for cleanup on exit/error. The "set -euo pipefail" header every production script should have. Here documents: <
Arithmetic: $((expression)), let, expr. String operations: ${#str} (length), ${str:offset:length} (substring), ${str/old/new} (replace), ${str##pattern} (strip prefix), ${str%%pattern} (strip suffix). Parameter expansion: ${var:-default} (default if unset). Arrays: arr=(a b c), ${arr[0]}, ${arr[@]}, ${#arr[@]}.
sed + awk in scripts, cron scheduling, debugging, and real-world automation patterns
Combining sed/awk into scripts for data pipelines. Parsing CSV/TSV files with awk. Extracting fields from log files. Generating reports from raw data. sed for config file modifications in deployment scripts. Real automation: "parse nginx access logs, count 404s per URL, email the report."
crontab -e to edit scheduled tasks. Cron syntax: minute hour day month weekday command. Examples: "0 2 * * * /backup.sh" (daily at 2 AM), "*/5 * * * *" (every 5 minutes). cron gotchas: PATH issues, output handling, timezone. at for one-time scheduling. systemd timers as a modern cron alternative.
bash -x script.sh (trace mode — shows every command before execution). set -x / set +x for selective tracing within scripts. ShellCheck for static analysis. Common bugs: unquoted variables with spaces, missing shebang, wrong comparison operators. Best practices: use functions, quote variables, handle errors, add comments, use meaningful variable names.
Log rotation script: archive logs older than 7 days, compress, delete old archives. Backup script: rsync to remote server, verify, send notification. Deployment script: pull code, install dependencies, restart service, check health. Monitoring script: check disk/CPU/memory, alert if thresholds exceeded. Students build 4–5 real scripts during this module.
Network tools, disk management, log analysis, and diagnosing server problems
ping (connectivity check), traceroute (path to destination), ifconfig / ip addr (network interfaces), netstat / ss (active connections — ss is modern replacement). nslookup / dig (DNS resolution). curl (HTTP requests — GET, POST, headers, response codes) and wget (file download). "Is the server reachable? What's its IP? Is port 80 open?" — these commands answer those questions.
ufw (Uncomplicated Firewall — Ubuntu): ufw allow 22 (SSH), ufw allow 80 (HTTP), ufw enable. iptables concepts: chains (INPUT, OUTPUT, FORWARD), rules (ACCEPT, DROP, REJECT). Why firewalls matter: blocking unauthorised access. "Allow SSH and HTTP, block everything else" — a standard server hardening task.
df -h (disk free space per filesystem). du -sh (directory size). mount (attach filesystems). fdisk / parted (partition management). lsblk (list block devices). Identifying "disk full" situations and finding the large files. "Server says 'No space left on device' — how do you fix it?" — a classic troubleshooting scenario.
free -h (RAM usage — total, used, free, available, swap). vmstat (virtual memory statistics — processes, memory, swap, I/O, CPU). iostat (disk I/O statistics). uptime (system load averages). load average: what 1.0 means on a 4-core system. "The server is slow — diagnose it" — starts with top, free, iostat, vmstat.
/var/log/syslog (system messages), /var/log/auth.log (authentication — login attempts, sudo), /var/log/nginx/access.log (web server). journalctl for systemd-managed logs: journalctl -u nginx (unit logs), journalctl --since "1 hour ago". dmesg for kernel messages (hardware, boot). Log analysis = first step in any troubleshooting workflow.
systemctl start/stop/restart/status service. systemctl enable/disable (auto-start on boot). systemctl list-units --type=service. Creating custom systemd service files. journalctl -u service for service-specific logs. Why systemd replaced init.d — the modern Linux service manager. "Restart nginx and verify it's running" — daily DevOps workflow.
Developer tools that live on the command line — version control, containers, and build systems
git init, clone, add, commit, push, pull, branch, checkout, merge, log, diff, stash. Git is a command-line tool first — GUI clients are wrappers. Branching strategy: feature branches, pull requests, merge conflicts. .gitignore for excluding files. git log --oneline --graph for visualising history. Every developer uses git daily from the terminal.
docker pull (download image), docker run (create container), docker ps (list running containers), docker exec -it (enter a running container), docker build (build from Dockerfile), docker-compose up. What containers ARE (isolated processes sharing the host kernel — not VMs). Building and running a simple web app in Docker. Why Docker changed deployment forever.
What Make does: define targets, dependencies, and commands for building projects. Simple Makefile: target: dependencies → command. Variables in Makefile. make clean, make all, make install patterns. Why Makefiles matter: C/C++ projects, automation, reproducible builds. Used in embedded systems, kernel development, and open-source projects.
curl for HTTP requests: GET, POST (with -d), headers (-H), authentication (-u), saving responses (-o). jq for JSON parsing: jq '.data[0].name' (extract fields from API responses). Combining curl + jq: fetch API data, parse JSON, extract fields — all from the command line. The terminal as an API testing tool — faster than Postman for quick checks.
tmux: multiple terminal sessions in one window. Split panes (horizontal/vertical), create windows, detach/reattach sessions. Why tmux matters: SSH into a server, start a long-running process in tmux, disconnect, reconnect later — the process keeps running. screen as an alternative. Essential for remote server work.
Navigate the filesystem, find specific files using find/grep, answer questions about file properties. All from the terminal.
Given a web server access log, extract top IPs, most requested URLs, error counts — using pipes, grep, awk, sort, uniq.
Write 5 real scripts: backup, log rotation, disk monitor, user management, deployment. Each solves a real sysadmin problem.
Set up a server: create users, configure permissions, set up SSH keys, configure firewall, disable root login. Security through configuration.
Pull an image, run a container, map ports, execute commands inside, build a custom Dockerfile. Containerisation hands-on.
"The website is down. Diagnose and fix it." Check services, ports, logs, disk space, memory — systematic troubleshooting on a live system.
Trainers demonstrate commands on a real Linux terminal — students follow along on their own. No PowerPoint presentations. The terminal IS the classroom. Screen sharing + live coding for every topic.
Students get access to a Linux terminal environment (cloud-based or VM). Practice commands, write scripts, break things, fix them. Available 24/7 for self-practice between sessions.
Timed challenges: "Find all files larger than 10MB modified in the last 24 hours" — write the command in under 60 seconds. Weekly challenges track speed and accuracy improvement.
Pre-broken systems where students must diagnose and fix the problem. "Website is returning 502." "Disk is 98% full." "SSH access stopped working." Real scenarios, real fixes.
AWS, Azure, GCP — the cloud runs Linux. Netflix, Google, Facebook, Amazon — their backends run Linux. Every backend developer, DevOps engineer, and cloud engineer works on Linux daily. Students who can't use a terminal are disqualified from 90% of server-side roles.
TCS, Infosys, Wipro, Cognizant include Linux questions in their technical MCQ sections. "What does chmod 644 mean?" "How do you find a process by name?" "What is the difference between hard and soft link?" Students who skip Linux lose marks.
The DevOps toolchain lives on the command line: Git for version control, Docker for containers, Kubernetes for orchestration, Terraform for infrastructure — all managed from a Linux terminal. Cloud certifications (AWS, Azure) assume Linux proficiency. DevOps is one of the highest-paying career paths.
A developer who can navigate the terminal, write shell scripts, read logs, and troubleshoot servers is productive from day one. A developer who needs a GUI for everything requires weeks of hand-holding. Companies hire the first type. Linux proficiency is a productivity multiplier that every employer values.
E-305, Industrial Area, Sahibzada Ajit Singh Nagar, Punjab 160055, IN
