reqHow Computers Work CS Basics
CPU,
RAM, storage, binary, instructions — the foundation underneath everything.
Why: Without this you write code that works by accident. With it, you debug performance issues you cannot see.
reqHow the Internet Works CS Basics
Packets,
DNS,
HTTP,
IP,
TCP, ports — what happens when you type a
URL.
Why: You are building web apps. Not understanding
HTTP is like being a chef who has never seen a kitchen.
recMemory Hierarchy CS Basics
Registers, L1/L2/L3 cache,
RAM, disk, network. Why locality matters.
Why: Why is your loop slow? Often the answer is cache misses, not your algorithm.
recThreading vs Async CS Basics
Threads, processes, async I/O, the event loop. CPU-bound vs I/O-bound.
Why: You'll write async code daily. Without the model, it's magic that breaks.
recOS Basics CS Basics
Processes vs threads, file descriptors, signals, environment variables, exit codes.
Why: You will
SSH into Linux boxes and debug processes. This is the layer below your runtime.
optNetwork Protocols Beyond HTTP CS Basics
WebSocket,
gRPC, MQTT,
UDP — when to reach for each.
Why: You'll mostly use
HTTP, but knowing alternatives shapes your choices.
reqVariables, Types, Control Flow Python
Basic building blocks: assignment, conditionals, loops.
Why: Every program is built from these. No shortcuts.
reqFunctions Python
Defining, calling, parameters, return values, default args, *args, **kwargs.
Why: Functions are how you stop repeating yourself. The single most important programming construct.
reqLists, Dicts, Tuples, Sets Python
Core data structures and when to use each.
Why: Choosing the right collection makes code 10x faster and clearer.
reqFile I/O & Error Handling Python
Read/write files, try/except, custom exceptions.
Why: Real programs work with files and the outside world fails constantly. Handle it gracefully.
reqModules & Virtual Envs Python
Organizing code into files, importing, isolating dependencies with
uv/venv.
Why: No project lives in one file. Virtual envs prevent global Python from becoming a graveyard.
recComprehensions & Iterators Python
List/dict/set comprehensions, generators, the iteration protocol.
Why: Python becomes elegant once these click. Learn before OOP — you use comprehensions every day; OOP is more conceptual.
recClasses & OOP Python
Classes, instances, methods, inheritance, dunder methods.
Why: You will see OOP everywhere in libraries.
reqVariables, Types, Functions JavaScript
let/const, primitives, function declarations vs arrows, hoisting.
Why: JS has gotchas Python does not (== vs ===, hoisting, this). Learn them once.
reqArrays & Objects JavaScript
Methods like map/filter/reduce, object literals, destructuring, spread.
Why: You will use map/filter/reduce thousands of times. Master them now.
recClosures & Scope JavaScript
Lexical scope, closures, the this keyword.
Why: Closures power most React patterns AND make async callbacks make sense. Learn before Promises.
reqPromises & async/await JavaScript
The event loop, promises, async functions, error handling in async code.
Why: Every
API call, every database query, every file read in
JS is async.
reqES Modules JavaScript
import/export, default vs named, module resolution.
Why: Modern
JS is module-based. Required for everything that comes next.
reqTerminal Navigation CLI & Git
cd, ls, mkdir, touch, cat, rm, pipes, redirection.
Why: You will live in the terminal. Fluency here saves hours every week.
reqGit Basics CLI & Git
init, add, commit, status, log, diff, push, pull.
Why: Every job, every project, every collaboration. Not optional.
reqBranches & Merging CLI & Git
Creating branches, switching, merging, resolving conflicts.
Why: You cannot work on a real codebase without this.
recRebasing CLI & Git
Interactive rebase, squashing, history rewriting.
Why: Keeps Git history clean. Required at most companies.
recPro Git Workflow CLI & Git
Conventional Commits, branch naming,
PR descriptions, code review etiquette.
Why: Junior devs are filtered out by sloppy Git. Hiring managers read commit history.
recCode Review Skills CLI & Git
How to give useful
PR feedback. How to receive it without ego. What to flag vs. let go.
Why: You'll review others' code daily on the job. Bad reviewers tank teams.
recTechnical Writing CLI & Git
READMEs,
API docs, architecture decision records (ADRs), runbooks.
Why: Code is read 10x more than written. Docs are read 100x more.
reqBig O Notation Data Structures & Algorithms
Time and space complexity. O(1), O(log n), O(n), O(n²), O(n log n).
Why: Required for every technical interview. Shapes how you think about scale.
reqArrays & Strings Data Structures & Algorithms
Two pointers, sliding window, prefix sums, in-place modifications.
Why: Most common interview pattern. Underlies half of all coding questions.
reqHash Tables Data Structures & Algorithms
Hashmap/dictionary operations, collision handling, when to use vs arrays.
Why: O(1) lookups solve many interview problems. Most underused data structure by beginners.
reqRecursion & Backtracking Data Structures & Algorithms
Base case, recursive case, call stack, backtracking pattern.
Why: Recursion clicks slowly but is the foundation for trees, graphs, DP.
recSorting & Searching Data Structures & Algorithms
Merge sort, quicksort, binary search. Built-in sorts in Python/JS.
Why: Binary search alone appears in ~10% of interview questions.
recTrees & Graphs Data Structures & Algorithms
Binary trees, BSTs, BFS, DFS, traversals.
Why: Common in mid-level interviews. Underlies real systems (file systems, dependency graphs).
optDynamic Programming Data Structures & Algorithms
Memoization, tabulation, optimal substructure.
Why: Hard but only matters for senior/FAANG interviews. Skip for now if targeting junior roles.
reqHow to Read Official Docs Learning Skills
Strategies for reading MDN, Python docs, language references — without drowning. Skim → scan → deep-read; navigate Type signatures; use the search; ignore the "old" docs Google surfaces.
Why: Most beginners can't read docs efficiently and end up on slow YouTube tutorials instead. Fluency with docs is a 5x productivity multiplier that compounds for your whole career.
reqAsking For Help Productively Learning Skills
How to ask a question on Stack Overflow, Discord, or to a mentor so people actually want to answer. Minimal reproducible example, what you tried, what you expected, what happened.
Why: A well-asked question gets answered in minutes; a poorly-asked one gets ignored or downvoted. This single skill saves you hundreds of stuck hours over your career.
reqReading Stack Traces Calmly Learning Skills
Errors aren't personal — they're information. How to read a Python/JS traceback top-to-bottom, find YOUR code in the noise, isolate the root cause, and resist the panic urge to "try random fixes".
Why: Beginners panic on errors and rerun blindly. The unstuck dev reads the trace once, locates the offending line, and moves on. The most important debugging skill.
reqBoolean Logic & Truth Tables Math & Logic Fundamentals
AND, OR, NOT, XOR, NAND. Truth tables. De Morgan's laws. Short-circuit evaluation. Bitwise operators in code.
Why: Every if-statement, every filter, every guard clause is Boolean logic. Misunderstanding it is the #1 cause of off-by-one + edge-case bugs.
reqSets, Relations & SQL Joins Math & Logic Fundamentals
Set membership, union, intersection, difference, symmetric difference. Cartesian product. Relations as sets of tuples. Why
SQL joins are set operations.
Why: Sets are the mental model behind databases, dedup, type unions, and most "find the overlap between X and Y" problems.
reqBasic Statistics (Mean / Median / Stddev) Math & Logic Fundamentals
Mean, median, mode, range, variance, standard deviation. When to use each. Normal vs skewed distributions. Outliers.
Why: Performance benchmarks lie if you use mean instead of p50/p95. Logs lie without distribution awareness. A/B tests fail without stats.
recProbability Fundamentals Math & Logic Fundamentals
Independent vs dependent events. Conditional probability. Bayes' theorem (intuition, not memorization). Expected value.
Why: AB tests, ML model evaluation, risk estimation, recommendation systems — all sit on probability.
recDiscrete Math (Graphs, Recurrences, Counting) Math & Logic Fundamentals
Graph theory basics (nodes, edges, paths). Counting (permutations, combinations). Recurrence relations (Fibonacci, factorial).
Why: Graphs power dependency resolvers, route finders, social networks, knowledge graphs. Counting drives complexity analysis.
reqProblem-Solving Framework (Polya) Math & Logic Fundamentals
1) Understand the problem 2) Devise a plan 3) Carry out the plan 4) Look back / review. The disciplined alternative to "stare at the code until it works".
Why: Most coding interview failures aren't coding failures — they're problem-solving framework failures. Same on the job.
recMental Math & Fermi Estimation Math & Logic Fundamentals
Back-of-the-envelope calculation. Latency numbers every programmer should know (L1 cache ~1ns,
RAM ~100ns, SSD ~100µs, network ~10ms). Order-of-magnitude estimation.
Why: System design interviews. Capacity planning. Spotting "this can't possibly be right" performance bugs. Cost estimation.