Step through the call stack, runtime APIs, microtasks, tasks, and rendering opportunities—and see why asynchronous JavaScript can still freeze an app.
See how cache lines, locality, access order, and finite capacity make two algorithms with the same Big O behave differently on real hardware.
Follow a virtual address through the TLB and page table to physical memory, including page faults, protection, and the limits of the model.
See how processes isolate resources, threads share state, schedules interleave, and synchronization prevents races while creating new tradeoffs.
A careful conceptual model of call frames, dynamic allocation, ownership, lifetime, and what managed runtimes can change.
Change table size, selectivity, and available indexes to see a conceptual planner choose scans and joins—and learn to read EXPLAIN ANALYZE safely.
Interleave two transactions and see lost updates, snapshots, row locks, deadlocks, and PostgreSQL serialization failures as they happen.
Explore page-oriented B-Tree indexes, splits, range scans, composite keys, selectivity, and the tradeoff between faster reads and more expensive writes.
Send traffic through fixed-window, sliding-window, and token-bucket limiters to compare bursts, fairness, state, 429 responses, and refill behavior.
Inspect trace waterfalls, correlated logs, span errors, latency, throughput, and retries to find where a distributed request actually failed.
Send requests through memory, browser, CDN, API, and database layers while changing TTL, capacity, frequency, staleness, and revalidation.
Watch producers, queues, workers, retries, duplicate deliveries, backpressure, and dead-letter handling change under real failure scenarios.
Use trust boundaries, authorization, validation, idempotency, transactions, and server-owned rules to keep mobile games and APIs correct under tampering and retries.
Follow fetch through DNS, connection security, edge infrastructure, authentication, cache, database, serialization, retries, and the final UI update.
Trace a notification from an Expo backend through APNs or FCM into foreground, background, and terminated app states—and then into a deep link.
See how JavaScript, React rendering, native/UI work, lists, images, and state updates compete for a frame—and which optimizations actually help.
How the organization of linear data makes indexing, insertion, removal, and traversal cheap or expensive.
From repeated recursion to carefully defined states, memoization, tabulation, and the tradeoffs behind dynamic programming.
Why a binary heap keeps the next priority at the root, maps naturally to an array, and supports efficient scheduling.
Recursion explained as ordinary function calls, pending stack frames, base cases, and a controlled return journey.
Tree vocabulary, binary-search-tree invariants, deletion cases, traversals, and why balance determines performance.
What Big O actually measures, how each growth class behaves as input grows, and when complexity decides your architecture versus when it is the wrong thing to optimize.
A step-by-step guide to binary search, including the core invariant, common implementation bugs, and why halving the search interval changes performance completely.
Visualize shortest paths with Dijkstra's algorithm and understand dependency resolution with Topological Sort (Kahn's algorithm).
A visual guide to exploring graphs using Breadth-First Search (BFS) and Depth-First Search (DFS), and understanding how traversal strategy affects performance and behavior.
A visual guide to how hash tables really work: hashing, collisions, probing, resizing, and why performance can collapse if you ignore the details.
Explore non-comparison sorting algorithms and selection algorithms including QuickSelect, Counting Sort, and Lexicographic Counting Sort.
A visual guide to understanding common sorting algorithms including Bubble Sort, Selection Sort, Insertion Sort, Quick Sort, and Merge Sort.
Manipulate a simplified commit graph to see how Git objects, branches, HEAD, merge, rebase, reset, and cherry-pick fit together.