Learn Linux - The Full Course

Main ideas, concepts, and lessons

Purpose and scope of the course

• The course is framed as “Learn Linux,” but the real focus is using shells and terminals in a Unix-like environment.
• It targets practical command-line skills useful for:
  • software engineering jobs generally
  • DevOps / automation / internet-adjacent work
• It is not:
  • a course on the Linux kernel
  • a course on operating system internals
  • a course on server administration
• It serves as a prerequisite for later backend/server-focused material.

How to complete the course (method)

• Follow along by actually using your computer’s terminal:
  • If you watch without pausing, you’re doing it wrong.
  • Make sure you can run commands and answer in-course questions/assignments.
• Course content is free on Boot.dev; interactive features requiring paid membership exist after a point, but you can take the course without paying.

---

Detailed methodology / instruction lists presented

1) Setup options for different operating systems

• Mac/Linux: use your existing Unix-like terminal environment.
• Windows: install WSL (Windows Subsystem for Linux) so you can follow along with Ubuntu.
• Expected shells for the lessons:
  • bash and zsh (and the concepts are similar across Unix-like systems)

2) Early terminal assignments (intro to shells/CLI)

• Assignment: print a greeting
  • Run: echo hello world
  • Then answer: what happened when pressing Enter (the text printed to console).
• Assignment: print current user
  • Run: whoami
  • Then answer: output (username printed).

3) Terminal usage basics: history, navigation, and screen clearing

• Use history to view previously typed commands.
• Use Arrow keys:
  • Up arrow: move backward through command history
  • Down arrow: move forward
• Use clear:
  • clears the terminal screen
  • does not erase command history

4) File system navigation and working directory

• Identify current directory:
  • Use pwd
• Understand paths:
  • Absolute paths start with / (from the filesystem root)
  • Relative paths do not start with / (from current working directory)
• Change directories:
  • Use cd <dir>
  • Use cd .. to go up one level
• Use tab autocomplete to reduce typing errors.

5) Viewing file contents and inspecting large files

• View full file:
  • cat <file>
• For large files:
  • head -n <N> <file> (first N lines; default is 10)
  • tail -n <N> <file> (last N lines)

6) Interactive paging with less

• Open a file interactively:
  • less <file-path>
• In less:
  • Enter scrolls line-by-line
  • Q quits
  • Space scrolls a page
  • B goes back a page
  • Use less -N <file> to show line numbers

7) File creation and basic filesystem actions

• Create empty file or update timestamps:
  • touch <filename>
• Create directory:
  • mkdir <dirname>
• Move/rename:
  • mv <source> <destination>
  • moving across directories is treated like changing the file path
• Copy:
  • cp <source> <destination>
  • copy directories with cp -R ...
• Remove/delete:
  • rm <file>
  • remove directories recursively with rm -r <dir> (or rm -R)

8) Text searching with grep (finding patterns in files)

• Basic usage:
  • grep <pattern> <file>
• Common advanced modes used:
  • Search multiple files: provide multiple file paths
  • Recursive search:
    • grep -r <pattern> <directory>
  • Recursive current directory uses .:
    • e.g., grep -r <pattern> <relative-path>
• Special matching logic:
  • grep -v <pattern>: invert match (select lines that do NOT match)

9) Finding files by name with find

• Basic usage:
  • find <start-dir> -name "<pattern>"
• Wildcards:
  • * matches any characters
• Example pattern logic:
  • *joint* matches filenames containing “joint”.

10) Permissions: users, groups, and the chmod / chown workflow

• Permission representation:
  • A 10-character string like drwxr-x---
  • Owner/group/others each get r, w, x (or -)
• Viewing permissions:
  • ls -l
• Changing permissions (chmod):
  • Uses symbolic or numeric modes; symbolic shown:
    • recursive permission changes:
      • chmod -R ... <dir>
  • Example intent shown in-course:
    • owner: read/write/execute
    • group: none
    • others: none
• Changing ownership (chown) (conceptually introduced via “pseudo” ownership change):
  • needed when you must transfer ownership of directories/files to root (superuser)

11) When commands need elevated privileges: sudo / sudo-like behavior

• Use sudo (“pseudo” pronounced in the talk):
  • temporarily run as superuser (root) after password prompt
• Key cautions:
  • sudo can cause irreversible harm if used incorrectly
  • examples of dangerous patterns emphasized:
    • sudo rm -rf / (catastrophic deletion)

12) Shell scripts vs executables; interpreters; shebang

• Two types of programs:
  • Compiled: run directly as binaries (e.g., system executables)
  • Interpreted: require an interpreter at runtime (e.g., shell scripts run by a shell interpreter)
• Shebang:
  • first line like #!/usr/bin/env <interpreter> or #!/bin/sh
  • tells the system which interpreter to use when executing a script
• Distinction checks done in-course:
  • cat /bin/sh looks like binary gibberish
  • scripts are plain text with shebang

13) Shell configuration (zshrc, bashrc) and environment variables

• Shell config files:
  • live in the user’s home directory and are hidden by dot-prefix
  • ~/.zshrc runs for zsh sessions
  • (bash equivalent implied: bashrc/profile)
• When editing config:
  • restart shell or source the file so changes take effect
• Environment variables:
  • list current env vars with env
  • set environment variables with export NAME=value
  • convention: environment variables are often ALL_CAPS
• Variables used by scripts:
  • script reads environment variables; missing values cause empty outputs or explicit error exits

14) PATH: why “command not found” happens and how to fix it

• PATH is an environment variable listing directories to search for executables.
• To diagnose:
  • use which <command> (shows where it is installed)
• Fix temporarily:
  • modify PATH for the current shell session via export PATH=...
• Fix permanently:
  • add export PATH=... to ~/.zshrc (or bash config)
  • then restart shell or source ~/.zshrc
• Example course concept:
  • adding the course’s World Bank/private/bin directory to PATH makes WorldBank.sh runnable from anywhere.

15) Documentation and flags: man and --help

• Use man <command> to read manuals:
  • can search within manual (e.g., /pattern)
• Use help flags (common options):
  • --help, -h, help
• Flag conventions:
  • short flags: -r
  • long flags: --recursive (as described via man pages)
• Important distinction:
  • flags/options order usually doesn’t matter
  • positional arguments order DOES matter

16) CLI behavior and automation: exit codes and streams

• Exit codes:
  • 0 = success
  • non-zero = error
  • you can check last command’s exit code via $?
• Standard streams:
  • STDOUT: normal output (default terminal printing)
  • STDERR: error output (sent separately)
• Redirect output:
  • > file (STDOUT to file)
  • 2> file (STDERR to file)
• Standard input:
  • STDIN comes from user input or piping
  • programs may block waiting for input
• Piping:
  • | sends STDOUT of left program into STDIN of right program
  • enables composition/automation (e.g., grep ... | wc -l)

17) Process management: stopping, killing, and finding PIDs

• Stop a running program in the terminal:
  • Ctrl+C sends SIGINT
• Kill stuck programs when SIGINT doesn’t work:
  • kill <PID>
• Find process IDs:
  • ps aux (and then filter with grep)
• In-course approach:
  • use ps aux | grep <process-name> to locate relevant PID(s)

18) Unix philosophy (how tools compose)

• Principle emphasized:
  • write/choose tools that do one thing well
  • use text interfaces and STDIN/STDOUT so programs can be composed together using piping
• Examples given:
  • cat prints data, grep searches, wc counts—combined via pipes

19) Package managers (installing software)

• Linux typical:
  • apt (in Ubuntu context)
• macOS typical:
  • brew
• Installation flow concept:
  • package managers:
    • check if installed
    • download packages
    • install dependencies
    • place binaries and (often) update PATH
• Installing a tool in-course:
  • Neovim via Homebrew (mac context used)
• Also introduced:
  • webby: an “anti-package-manager” style tool that fetches official install scripts via web interface (curl + remote script execution)
  • Security considerations discussed:
    • risks of “curl script and execute immediately”
    • mitigated by HTTPS and trust in the source

---

Speakers / sources featured

• Speaker/Instructor: Lane (creator of Boot.dev; the “Learn Linux - The Full Course” instructor persona)
• Platform/Source: Boot.dev (Boot.dev interactive course materials referenced)
• Named external sources mentioned:
  • WSL (Windows Subsystem for Linux)
  • xkcd (via a referenced XKCD “root user” comic)
  • Chuck Norris (mentioned humorously in the “root” discussion)
  • AJ (mentioned as a Webby maintainer who discussed security on the “Backend Banter” podcast)
  • HashiCorp (Ghostty mentioned as developed by Mitchell Hashimoto, founder of HashiCorp)
  • Windows / macOS / Ubuntu / Linux (as environments, not “speakers”)