Build the mental model behind the command.

Build a reliable model of how a shell reads commands and resolves paths. These foundations make later work with pipelines, scripts, and remote systems predictable.

1. 1Command anatomy
2. 2Current working directory
3. 3Absolute vs relative paths
4. 4Files and directories
5. 5Home, current, and parent paths
6. 6Manual pages and built-in help

Learn the byte-stream model that lets command-line programs work together. Route data, react to status, search text, and build inspectable pipelines.

1. 1Standard input, output, and error
2. 2Redirection
3. 3Pipelines
4. 4Exit status
5. 5Conditional command execution
6. 6Text search with grep

Find files safely and reshape text or structured data with focused command-line tools. Learn where record boundaries, quoting, and format-aware parsing matter.

1. 1Finding files with find
2. 2Building arguments with xargs
3. 3Null-delimited filenames
4. 4Command substitution
5. 5Shell parameter expansion
6. 6Stream editing with sed

Turn reliable commands into maintainable scripts and control long-running work from an interactive shell. Practice explicit arguments, failures, jobs, and cleanup.

1. 1Shell script and shebang
2. 2Executable permission
3. 3Positional and special parameters
4. 4Shell functions
5. 5Shell conditionals
6. 6Shell loops

Understand how Unix-like systems identify running programs and connect names, metadata, permissions, and open files. These concepts explain what common process and filesystem commands are actually inspecting or changing.

1. 1Process and PID
2. 2Parent and child processes
3. 3Filesystem hierarchy
4. 4Inode and file metadata
5. 5Hard link
6. 6Symbolic link

Trace network communication from local interfaces and addresses through DNS, transport protocols, URLs, HTTP, and encrypted remote access. The final lessons turn that model into practical curl and SSH diagnostics.

1. 1IP address and network interface
2. 2Localhost and loopback
3. 3Port and socket
4. 4Domain Name System (DNS)
5. 5TCP vs UDP
6. 6URL anatomy

Build a precise model of how programs represent integers and structured state, then use it to reason about scope, aliasing, mutation, pure functions, and recursion. Language-specific behavior is called out where no universal rule exists.

1. 1Bits, bytes, and integer width
2. 2Binary representation
3. 3Hexadecimal
4. 4Bitwise operators
5. 5Endianness
6. 6Variables and scope

Follow source code into calls, memory, execution engines, types, and object design. The track replaces misleading either-or slogans with mechanisms that hold across modern compilers, interpreters, virtual machines, and runtimes.

1. 1Call stack and stack frame
2. 2Stack vs heap memory
3. 3Stack overflow
4. 4Compiler, interpreter, and JIT
5. 5Bytecode and virtual machine
6. 6Static vs dynamic typing

Learn how data layout determines the cost of access, insertion, deletion, and traversal. Build a practical vocabulary for comparing structures by workload rather than by habit.

1. 1Algorithmic complexity: O, Ω, and Θ
2. 2Array and dynamic array
3. 3Linked list
4. 4Stack
5. 5Queue
6. 6Hash table

Practice the recurring search, traversal, sorting, and state-reuse patterns behind many programming problems. Focus on the invariant that makes each technique correct.

1. 1Binary search
2. 2Bubble sort
3. 3Merge sort vs quicksort
4. 4Breadth-first search
5. 5Depth-first search
6. 6Two pointers

Understand how independently progressing tasks interact through shared resources, and how systems remain correct when timing, duplication, delay, and failure are unavoidable.

1. 1Concurrency vs parallelism
2. 2Thread vs process
3. 3Race condition
4. 4Atomicity
5. 5Mutex
6. 6Semaphore

Connect storage guarantees, API boundaries, version-control history, and automated integration. Learn what each layer promises and where correctness still belongs to the application.

1. 1Database transaction and ACID
2. 2Database index
3. 3Caching and LRU eviction
4. 4Strong and eventual consistency
5. 5Throughput vs latency
6. 6HTTP API and REST semantics