Curriculum

Understand what programming is, how computers execute instructions, and write your very first program.

Learn how to store and manipulate data using variables. Understand strings, numbers, booleans, and type systems.

Make your programs smart with if/else decisions and powerful with loops that repeat actions.

Organize your code into reusable functions. Learn parameters, return values, and scope.

Learn how arrays store data in contiguous memory and how dynamic arrays grow automatically.

Understand linked lists — nodes connected by pointers. Compare with arrays and learn when each is better.

Two fundamental linear structures: stacks (LIFO) and queues (FIFO). Used everywhere from undo buttons to BFS.

Reason about how your code scales. Learn O(1), O(log n), O(n), and O(n^2) and how to spot them.

A decision guide for picking arrays, linked lists, stacks, or queues based on the operations you need.

Learn object-oriented programming — model real-world things with classes, create instances, and encapsulate data.

Build new classes on top of existing ones. Learn base/derived classes, super, and method overriding.

One interface, many implementations. Use polymorphism to write code that works with any subclass.

Five design principles that keep object-oriented code flexible and maintainable as it grows.

Trees branch instead of going in a line. Learn the BST property and core operations: insert, search, traverse.

A heap is a tree that always keeps the smallest (or largest) value at the root. Powers priority queues.

The structure behind dictionaries and sets. Learn hashing, collisions, and why lookup is O(1) on average.

Graphs model networks: cities, friends, web pages. Learn adjacency lists, BFS, and DFS.

Implement and compare bubble sort, merge sort, and quicksort. Understand why O(n log n) is the gold standard.

Functions that call themselves. Master base cases, recursive steps, and the call stack.

The classic O(log n) search on a sorted array. Halve the search space each step. Mind the off-by-one bugs.

Try, recurse, undo. Backtracking explores choices systematically. Powers subsets, N-queens, and Sudoku.

Understand how relational databases organize data into tables with rows, columns, and keys.

Learn the core SQL clauses for retrieving data: SELECT, WHERE, ORDER BY, and LIMIT.

Combine data from multiple tables with JOIN and summarize it with GROUP BY.

Why indexes make queries fast, when to add them, and how to read a query plan.

How web requests work: methods, status codes, headers, and the REST conventions that shape modern APIs.

How HTML, CSS, and JavaScript work together to build interactive web pages.

Build server endpoints, route requests to handlers, and respond with JSON.

From localhost to the internet: environments, environment variables, and deployment platforms.

Unit, integration, and end-to-end tests, plus the Arrange-Act-Assert pattern.

Branching, merging, rebasing, and the pull request flow that powers modern team development.

What to look for, how to leave useful comments, and how automated checks fit in.

Continuous integration and continuous delivery: pipelines, stages, and how teams ship safely.

Solve problems with overlapping subproblems using memoization and tabulation.

Find shortest paths in weighted graphs with Dijkstra's algorithm and a priority queue.

Make the locally optimal choice at each step and arrive at a globally optimal answer.

P vs NP, reductions, and what it means for a problem to be intractable.

Understand how programs allocate and free memory. Stack vs heap, manual vs automatic management, and reference counting vs garbage collection.

Run code concurrently with threads. Learn about race conditions, locks, and how each language handles concurrency.

Run many I/O tasks concurrently without threads. Learn the event loop, promises, and futures.

Learn what causes deadlocks, how race conditions slip past tests, and how a consistent lock order prevents the worst problems.

Learn how systems grow with load. Vertical vs horizontal scaling, stateless services, and finding bottlenecks.

Speed up systems by remembering recent results. Learn cache hits, TTL, LRU eviction, and write strategies.

Distribute requests across servers. Compare round-robin, least-connections, weighted, and learn about health checks.

Decouple producers from consumers with queues. Learn pub/sub, ordering, and delivery guarantees.

Build systems that tolerate things going wrong. Retries, exponential backoff, circuit breakers, and graceful degradation.

Turn fuzzy ideas into a backlog. Gather requirements, write user stories, and sketch the architecture before you code.

Plan how you will build the system. Milestones, MVPs, and ordering tasks by their dependencies.

Ship safely. Pre-deploy checks, smoke tests, and rollback plans for when something goes wrong.

Watch your system in production. Metrics, logs, alerts, post-mortems, and the loop that keeps systems improving.