Curriculum
A structured path from your first line of code to designing scalable systems. Each module includes interactive lessons with code you can run in Python, JavaScript, C++, and Java.
Programming Fundamentals
Start your coding journey. Learn variables, control flow, functions, and debugging — the building blocks of every program.
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.
Data Structures — Linear Collections
Master arrays, linked lists, stacks, and queues. Understand Big-O notation and choose the right structure for any problem.
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.
Object-Oriented Design
Model real-world systems with classes, inheritance, and polymorphism. Apply SOLID principles to write maintainable code.
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, Graphs & Hashing
Implement binary trees, BSTs, heaps, hash tables, and graphs. Learn traversals and solve connected-component problems.
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.
Algorithms — Sorting & Recursion
Implement merge sort, quicksort, binary search, and backtracking. Analyze complexity with recurrence relations.
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.
Databases & SQL
Design normalized schemas, write complex SQL queries, understand indexing, and compare SQL vs NoSQL approaches.
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.
Full-Stack Web Development
Build RESTful APIs, responsive frontends, and connect everything to a database. Deploy a working web application.
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.
Software Engineering Practices
Write effective tests, use Git workflows, set up CI/CD pipelines, and conduct code reviews like a professional.
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.
Advanced Algorithms
Tackle dynamic programming, shortest-path algorithms, minimum spanning trees, and NP-completeness.
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.
Systems Programming & Concurrency
Understand memory management, threads, synchronization, and async I/O. Build concurrent applications that don't deadlock.
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.
System Design & Architecture
Design scalable distributed systems. Learn caching, load balancing, message queues, and designing for failure.
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.
Capstone Project
Execute the full software lifecycle: requirements, design, implementation, testing, deployment, and monitoring.
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.