Computer science and photography, made clear.

Interactive tools

Search and explore interactive visualizations alongside their related guides.

• Fourier Lab Mathematics

  Build periodic signals from sine and cosine harmonics. Explore 54 waveforms, motion, and the frequency spectrum.

  Open interactive tool · Read the guide
• Binary Search Playground Algorithms

  Step through comparisons on a sorted list and watch the search interval shrink.

  Open interactive tool · Read the guide
• Sorting Playground Algorithms

  Compare adjacent values and watch bubble sort move the largest remaining value into place.

  Open interactive tool · Read the guide
• Min-Heap Playground Data Structures

  Insert values and remove the minimum while seeing the heap property restored.

  Open interactive tool · Read the guide
• Dijkstra Shortest Path Playground Algorithms

  Settle vertices one at a time and follow tentative shortest-path distances across a weighted graph.

  Open interactive tool · Read the guide
• HTTP Cache and CDN Playground Computer Networks

  Simulate browser and edge-cache hits, expiration, and ETag revalidation.

  Open interactive tool · Read the guide
• Dynamic Arrays Explorer Data Structures

  A dynamic array stores items contiguously and grows its backing storage when capacity is exhausted. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Singly Linked Lists and Pointer Traversal Explorer Data Structures

  A singly linked list stores each value with a pointer to the next node, allowing local insertions without shifting later values. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Circular Buffers for Bounded Streams Explorer Data Structures

  A circular buffer reuses a fixed array by wrapping its read and write positions to the beginning. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Hash Collisions: Chaining and Open Addressing Explorer Data Structures

  A collision occurs when distinct keys map to the same hash-table slot, so a table needs a collision-resolution strategy. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Designing Hash Functions for Data Structures Explorer Data Structures

  A hash function distributes keys across a table's integer range so common key patterns do not cluster. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Red-Black Trees: Balanced Search with Color Rules Explorer Data Structures

  A red-black tree uses coloring invariants and rotations to keep its height logarithmic as keys are inserted or removed. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Radix Trees: Compressing Paths in a Trie Explorer Data Structures

  A radix tree merges chains of single-child trie nodes into labeled edges to reduce pointer and node overhead. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Union-Find: Tracking Connected Components Explorer Data Structures

  Disjoint-set union maintains groups under merge and connectivity-query operations using parent pointers. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Segment Trees for Range Queries Explorer Data Structures

  A segment tree stores summaries over intervals, combining child intervals to answer range queries and point updates. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Skip Lists: Probabilistic Ordered Search Explorer Data Structures

  A skip list adds randomized express links over a sorted linked list to reduce expected search steps. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• LRU Caches: Evicting the Least Recently Used Explorer Data Structures

  An LRU cache combines a key lookup table with an ordered list so reads and writes can refresh recency efficiently. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Persistent Data Structures and Shared Versions Explorer Data Structures

  A persistent structure preserves older versions after updates, often by copying only the nodes on a changed path. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Skip-Block Lists and Ordered Range Navigation Explorer Data Structures

  Block-based ordered lists group neighboring values so searches skip blocks before scanning a small local range. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Recurrence Relations for Algorithm Analysis Explorer Algorithms

  A recurrence describes an algorithm's cost using the costs of smaller input sizes plus the work done at the current level. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Insertion Sort and Nearly Sorted Data Explorer Algorithms

  Insertion sort builds a sorted prefix by shifting larger prefix values to make room for each next value. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Counting Sort for Bounded Integer Ranges Explorer Algorithms

  Counting sort counts how often each key occurs and uses cumulative counts to place values without comparisons. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Tail Recursion and Explicit Stacks Explorer Algorithms

  Tail recursion makes the recursive call the final action, while an explicit stack stores pending work in an ordinary loop. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• N-Queens: Constraint Search on a Chessboard Explorer Algorithms

  The N-Queens problem places one queen per row while excluding shared columns and diagonals. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Interval Scheduling and Earliest-Finish Selection Explorer Algorithms

  Selecting compatible intervals by increasing finish time maximizes the number of non-overlapping intervals for the standard unweighted problem. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• 0/1 Knapsack and State Design Explorer Algorithms

  The 0/1 knapsack dynamic program tracks the best value achievable for item prefixes and capacity limits. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Edit Distance and Minimum String Repairs Explorer Algorithms

  Edit distance finds the minimum number of insertions, deletions, and substitutions needed to transform one string into another. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Minimum Spanning Trees: Connect at Minimum Cost Explorer Algorithms

  A minimum spanning tree connects every vertex of a connected weighted undirected graph with minimum total edge weight. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• KMP String Search and Prefix Information Explorer Algorithms

  Knuth-Morris-Pratt search reuses matched-prefix information so a mismatch does not restart comparison at the next text character. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Two Pointers for Ordered Pair Problems Explorer Algorithms

  Two pointers move through an ordered sequence from opposite ends or in the same direction to avoid checking every pair. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Prefix Sums for Constant-Time Range Totals Explorer Algorithms

  A prefix-sum array stores cumulative totals so a range sum is the difference of two prefix values. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Propositional Logic and Truth Tables Explorer Mathematics

  Propositional logic represents statements as true or false and combines them with operators such as AND, OR, and NOT. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Set Operations: Union, Intersection, and Difference Explorer Mathematics

  Set operations describe which elements belong to combined collections and underpin database and query reasoning. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Permutations and Combinations Explorer Mathematics

  Permutations count ordered selections, while combinations count selections where order does not matter. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Conditional Probability and the Sample Space Explorer Mathematics

  Conditional probability restricts attention to outcomes where a condition is true, then measures the event inside that smaller space. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Expected Value for Randomized Algorithms Explorer Mathematics

  Expected value is the probability-weighted average outcome and helps describe randomized algorithm behavior. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Markov Chains and State Transitions Explorer Mathematics

  A Markov chain models transitions among states where the next-state distribution depends on the current state. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• The Sieve of Eratosthenes for Prime Tables Explorer Mathematics

  The Sieve of Eratosthenes marks multiples of each discovered prime to list all primes up to a bound. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Vector Magnitude and Normalization Explorer Mathematics

  A vector's magnitude is its Euclidean length, and normalization scales a nonzero vector to length one. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Matrix Inverses and Reversible Transformations Explorer Mathematics

  A square matrix has an inverse when it represents a reversible linear transformation with nonzero determinant. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Derivatives as Local Rates of Change Explorer Mathematics

  A derivative measures the limiting rate at which a function changes near an input value. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Logarithms as Inverse Exponents Explorer Mathematics

  A logarithm answers which exponent produces a value, turning multiplicative growth into additive reasoning. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Floating-Point Precision and Rounding Explorer Mathematics

  Floating-point formats approximate many real numbers with finite binary precision, so some decimal fractions cannot be represented exactly. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Coordinate Transforms and Change of Basis Explorer Mathematics

  A coordinate transform changes how a vector is represented, while the underlying geometric vector can remain the same. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• The TCP/IP Layers and Encapsulation Explorer Computer Networks

  Network layers divide communication responsibilities, and each layer wraps data with metadata needed by the next one. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Subnet Masks and Address Capacity Explorer Computer Networks

  A subnet mask marks which IP address bits identify a network and which identify hosts. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• DHCP and Automatic Network Configuration Explorer Computer Networks

  Dynamic Host Configuration Protocol leases network settings such as an address, gateway, and DNS resolver to a client. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• TCP Sequence and Acknowledgment Numbers Explorer Computer Networks

  TCP sequence numbers identify byte positions in a stream, while acknowledgments report the next expected byte. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• UDP Datagrams and Application-Level Reliability Explorer Computer Networks

  UDP sends independent datagrams without TCP's built-in delivery, ordering, or retransmission guarantees. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• TLS Certificates and Domain Validation Explorer Computer Networks

  TLS certificates bind a public key to a domain identity through a chain that clients validate against trusted roots. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• HTTP Status Codes and Response Categories Explorer Computer Networks

  HTTP status codes summarize whether a request succeeded, needs more action, or encountered a client or server problem. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• REST Resources and Stateless Request Design Explorer Computer Networks

  REST-style APIs expose resources through consistent identifiers and HTTP operations while keeping each request self-contained. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Load Balancing Across Application Instances Explorer Computer Networks

  A load balancer distributes requests across healthy service instances using a routing policy. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Eventual Consistency Across Replicas Explorer Computer Networks

  Eventual consistency permits replicas to temporarily disagree while promising convergence after updates stop propagating. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• HTTP/3 and QUIC Connection Setup Explorer Computer Networks

  HTTP/3 carries HTTP semantics over QUIC, which uses UDP while implementing transport features including encryption and stream multiplexing. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide
• Polling, Server-Sent Events, and WebSockets Explorer Computer Networks

  Applications can receive updates by periodic polling, one-way server-sent events, or bidirectional WebSocket messaging. Experiment with a small example and see each step update.

  Open interactive tool · Read the guide

No tools match that search.

Articles

• Arrays vs. Linked Lists: Choosing the Right Sequence — Both store ordered data, but their memory layouts make different operations fast. Learn when each structure fits.
• Stacks and Queues: Two Simple Rules, Many Uses — Explore last-in-first-out and first-in-first-out structures, with real examples from browsers, scheduling, and search.
• Hash Maps Explained: Fast Lookups from Keys — See how hashing turns a key into a storage location, why collisions happen, and what good hash maps promise.
• Trees and Binary Search Trees, One Node at a Time — Understand roots, leaves, traversals, and the ordering rule that makes a balanced search tree useful.
• Graphs: Modeling Connections Between Things — From maps to social networks, learn graph vocabulary and compare adjacency lists with adjacency matrices.
• Heaps and Priority Queues: Getting the Next Best Item — Learn how a compact tree keeps its smallest or largest value ready, and why schedulers and graph algorithms rely on heaps.
• Dynamic Arrays — A dynamic array stores items contiguously and grows its backing storage when capacity is exhausted. This guide works through a concrete example and the trade-offs to remember.
• Amortized Analysis: The Cost Across Many Operations — Amortized analysis bounds a sequence of operations rather than averaging across random inputs. This guide works through a concrete example and the trade-offs to remember.
• Singly Linked Lists and Pointer Traversal — A singly linked list stores each value with a pointer to the next node, allowing local insertions without shifting later values. This guide works through a concrete example and the trade-offs to remember.
• Doubly Linked Lists: Forward and Backward Links — A doubly linked list stores both next and previous pointers so a known node can be removed or traversed in either direction. This guide works through a concrete example and the trade-offs to remember.
• Circular Buffers for Bounded Streams — A circular buffer reuses a fixed array by wrapping its read and write positions to the beginning. This guide works through a concrete example and the trade-offs to remember.
• Deques: Efficient Operations at Both Ends — A deque supports insertion and removal at both the front and back, often using a circular array or linked blocks. This guide works through a concrete example and the trade-offs to remember.
• Hash Collisions: Chaining and Open Addressing — A collision occurs when distinct keys map to the same hash-table slot, so a table needs a collision-resolution strategy. This guide works through a concrete example and the trade-offs to remember.
• Hash-Table Load Factor and Resizing — Load factor is the ratio of stored entries to table capacity and helps estimate collision pressure. This guide works through a concrete example and the trade-offs to remember.
• Designing Hash Functions for Data Structures — A hash function distributes keys across a table's integer range so common key patterns do not cluster. This guide works through a concrete example and the trade-offs to remember.
• AVL Trees and Balance Factors — An AVL tree maintains a height difference of at most one between each node's left and right subtrees. This guide works through a concrete example and the trade-offs to remember.
• Red-Black Trees: Balanced Search with Color Rules — A red-black tree uses coloring invariants and rotations to keep its height logarithmic as keys are inserted or removed. This guide works through a concrete example and the trade-offs to remember.
• Tries for Prefix Search and Autocomplete — A trie represents keys as paths of characters, sharing common prefixes among stored strings. This guide works through a concrete example and the trade-offs to remember.
• Radix Trees: Compressing Paths in a Trie — A radix tree merges chains of single-child trie nodes into labeled edges to reduce pointer and node overhead. This guide works through a concrete example and the trade-offs to remember.
• B-Trees and Database Page Access — A B-tree groups many sorted keys in each node so one node can fit into a disk or database page. This guide works through a concrete example and the trade-offs to remember.
• Union-Find: Tracking Connected Components — Disjoint-set union maintains groups under merge and connectivity-query operations using parent pointers. This guide works through a concrete example and the trade-offs to remember.
• Path Compression and Union by Rank — Path compression shortens parent chains during find, while union by rank attaches a shallower tree below a deeper one. This guide works through a concrete example and the trade-offs to remember.
• Segment Trees for Range Queries — A segment tree stores summaries over intervals, combining child intervals to answer range queries and point updates. This guide works through a concrete example and the trade-offs to remember.
• Fenwick Trees for Prefix Sums — A Fenwick tree stores partial sums in an array where each index covers a range determined by its least significant set bit. This guide works through a concrete example and the trade-offs to remember.
• Skip Lists: Probabilistic Ordered Search — A skip list adds randomized express links over a sorted linked list to reduce expected search steps. This guide works through a concrete example and the trade-offs to remember.
• Bloom Filters for Space-Efficient Membership Tests — A Bloom filter uses several hash functions to set bits and can answer membership queries with possible false positives. This guide works through a concrete example and the trade-offs to remember.
• LRU Caches: Evicting the Least Recently Used — An LRU cache combines a key lookup table with an ordered list so reads and writes can refresh recency efficiently. This guide works through a concrete example and the trade-offs to remember.
• Sparse Matrices and Coordinate Storage — A sparse matrix stores only its nonzero values to avoid memory proportional to mostly empty cells. This guide works through a concrete example and the trade-offs to remember.
• Persistent Data Structures and Shared Versions — A persistent structure preserves older versions after updates, often by copying only the nodes on a changed path. This guide works through a concrete example and the trade-offs to remember.
• Rope Data Structures for Large Text Editing — A rope stores text in a balanced tree of string chunks so edits avoid repeatedly copying one huge string. This guide works through a concrete example and the trade-offs to remember.
• Skip-Block Lists and Ordered Range Navigation — Block-based ordered lists group neighboring values so searches skip blocks before scanning a small local range. This guide works through a concrete example and the trade-offs to remember.
• Big O Notation Without the Mystery — Describe how an algorithm scales as input grows, without getting distracted by machine-specific timing.
• Binary Search: Halve the Search Space — A sorted collection can answer search questions quickly. Learn the invariant that keeps binary search correct.
• Merge Sort: Divide, Sort, and Combine — Break a big sorting problem into smaller ones, then combine sorted halves in a predictable number of steps.
• BFS vs. DFS: Two Ways to Explore a Graph — Use a queue to explore by distance or a stack to follow a path deep. Learn what each search guarantees.
• Dynamic Programming: Remember Work You Already Did — Turn repeated subproblems into a table or cache, starting with a small recurrence you can reason about.
• Dijkstra's Algorithm: Finding the Cheapest Route — Use a priority queue and repeated edge relaxation to find shortest paths in a graph with non-negative weights.
• Recurrence Relations for Algorithm Analysis — A recurrence describes an algorithm's cost using the costs of smaller input sizes plus the work done at the current level. This guide works through a concrete example and the trade-offs to remember.
• Quicksort and Partitioning Around a Pivot — Quicksort partitions values around a pivot, then recursively sorts the smaller regions. This guide works through a concrete example and the trade-offs to remember.
• Insertion Sort and Nearly Sorted Data — Insertion sort builds a sorted prefix by shifting larger prefix values to make room for each next value. This guide works through a concrete example and the trade-offs to remember.
• Heap Sort: Selection with a Heap — Heap sort repeatedly removes the maximum from a heap and places it at the end of the array. This guide works through a concrete example and the trade-offs to remember.
• Counting Sort for Bounded Integer Ranges — Counting sort counts how often each key occurs and uses cumulative counts to place values without comparisons. This guide works through a concrete example and the trade-offs to remember.
• Radix Sort: Sorting Digits One Pass at a Time — Radix sort orders fixed-width keys by successive digits, using a stable inner sort for each digit. This guide works through a concrete example and the trade-offs to remember.
• Linear Search and Early Exit — Linear search checks values in sequence until it finds a target or reaches the end. This guide works through a concrete example and the trade-offs to remember.
• Tail Recursion and Explicit Stacks — Tail recursion makes the recursive call the final action, while an explicit stack stores pending work in an ordinary loop. This guide works through a concrete example and the trade-offs to remember.
• Backtracking: Explore and Undo Choices — Backtracking builds a candidate solution one choice at a time and undoes choices that cannot lead to a valid answer. This guide works through a concrete example and the trade-offs to remember.
• N-Queens: Constraint Search on a Chessboard — The N-Queens problem places one queen per row while excluding shared columns and diagonals. This guide works through a concrete example and the trade-offs to remember.
• Greedy Algorithms and the Exchange Argument — A greedy algorithm commits to a locally attractive choice and needs a proof that this choice can belong to an optimal solution. This guide works through a concrete example and the trade-offs to remember.
• Interval Scheduling and Earliest-Finish Selection — Selecting compatible intervals by increasing finish time maximizes the number of non-overlapping intervals for the standard unweighted problem. This guide works through a concrete example and the trade-offs to remember.
• Memoization vs. Tabulation in Dynamic Programming — Memoization caches recursive subproblem results, while tabulation fills a table in a chosen dependency order. This guide works through a concrete example and the trade-offs to remember.
• 0/1 Knapsack and State Design — The 0/1 knapsack dynamic program tracks the best value achievable for item prefixes and capacity limits. This guide works through a concrete example and the trade-offs to remember.
• Longest Increasing Subsequence: Two Useful Approaches — The longest increasing subsequence can be computed with a quadratic dynamic program or a patience-sorting-style tails array. This guide works through a concrete example and the trade-offs to remember.
• Edit Distance and Minimum String Repairs — Edit distance finds the minimum number of insertions, deletions, and substitutions needed to transform one string into another. This guide works through a concrete example and the trade-offs to remember.
• Topological Sorting and Dependency Order — A topological ordering places every directed acyclic graph vertex before the vertices that depend on it. This guide works through a concrete example and the trade-offs to remember.
• Minimum Spanning Trees: Connect at Minimum Cost — A minimum spanning tree connects every vertex of a connected weighted undirected graph with minimum total edge weight. This guide works through a concrete example and the trade-offs to remember.
• A-Star Search and Admissible Heuristics — A-star ranks frontier states by path cost so far plus a heuristic estimate of remaining cost. This guide works through a concrete example and the trade-offs to remember.
• Bellman-Ford and Negative Edge Weights — Bellman-Ford relaxes every edge repeatedly and can detect reachable negative-weight cycles. This guide works through a concrete example and the trade-offs to remember.
• KMP String Search and Prefix Information — Knuth-Morris-Pratt search reuses matched-prefix information so a mismatch does not restart comparison at the next text character. This guide works through a concrete example and the trade-offs to remember.
• Rolling Hashes for Fast Substring Candidates — A rolling hash updates a window hash as one character leaves and another arrives, making substring candidates cheap to compare. This guide works through a concrete example and the trade-offs to remember.
• Two Pointers for Ordered Pair Problems — Two pointers move through an ordered sequence from opposite ends or in the same direction to avoid checking every pair. This guide works through a concrete example and the trade-offs to remember.
• Sliding Windows for Contiguous Subarrays — A sliding window maintains state for a moving contiguous range, adding new values and removing values that leave. This guide works through a concrete example and the trade-offs to remember.
• Prefix Sums for Constant-Time Range Totals — A prefix-sum array stores cumulative totals so a range sum is the difference of two prefix values. This guide works through a concrete example and the trade-offs to remember.
• Sets, Functions, and Relations: The Language of CS — A gentle introduction to describing collections, mappings, and relationships precisely.
• Proof by Induction: Climb an Infinite Ladder — Prove a statement for every natural number by checking one starting step and showing how each step follows.
• Modular Arithmetic and the Euclidean Algorithm — Work with remainders like clock numbers, then use repeated division to find the greatest common divisor.
• Probability for Computer Science Beginners — Reason about random outcomes with sample spaces, events, and conditional probability.
• Vectors and Matrices: Transformations in Disguise — Represent data as vectors and see how matrix multiplication can rotate, scale, and combine it.
• Fourier Series: Building Signals from Simple Waves — See how sine and cosine waves combine to approximate complex periodic signals, then experiment with an interactive Fourier Lab.
• Propositional Logic and Truth Tables — Propositional logic represents statements as true or false and combines them with operators such as AND, OR, and NOT. This guide works through a concrete example and the trade-offs to remember.
• Boolean Algebra and Logic Simplification — Boolean algebra applies identities to simplify expressions while preserving their truth values. This guide works through a concrete example and the trade-offs to remember.
• Set Operations: Union, Intersection, and Difference — Set operations describe which elements belong to combined collections and underpin database and query reasoning. This guide works through a concrete example and the trade-offs to remember.
• Combinatorics and the Product Rule — The product rule counts sequences of independent choices by multiplying the number of options at each step. This guide works through a concrete example and the trade-offs to remember.
• Permutations and Combinations — Permutations count ordered selections, while combinations count selections where order does not matter. This guide works through a concrete example and the trade-offs to remember.
• The Binomial Theorem and Pascal Structure — The binomial theorem expands powers of two-term sums using coefficients that count how many ways terms are selected. This guide works through a concrete example and the trade-offs to remember.
• Conditional Probability and the Sample Space — Conditional probability restricts attention to outcomes where a condition is true, then measures the event inside that smaller space. This guide works through a concrete example and the trade-offs to remember.
• Bayes’ Theorem and Updating Beliefs — Bayes’ theorem reverses a conditional relationship by combining prior probability with how likely the evidence is under each case. This guide works through a concrete example and the trade-offs to remember.
• Expected Value for Randomized Algorithms — Expected value is the probability-weighted average outcome and helps describe randomized algorithm behavior. This guide works through a concrete example and the trade-offs to remember.
• Variance and Measuring Spread — Variance measures the average squared distance from a distribution's mean, emphasizing outcomes far from the center. This guide works through a concrete example and the trade-offs to remember.
• Markov Chains and State Transitions — A Markov chain models transitions among states where the next-state distribution depends on the current state. This guide works through a concrete example and the trade-offs to remember.
• Modular Inverses and Solving Congruences — A modular inverse of a modulo m is a value x for which ax leaves remainder one when divided by m. This guide works through a concrete example and the trade-offs to remember.
• The Sieve of Eratosthenes for Prime Tables — The Sieve of Eratosthenes marks multiples of each discovered prime to list all primes up to a bound. This guide works through a concrete example and the trade-offs to remember.
• Complex Numbers on the Plane — A complex number a+bi corresponds to point (a,b), where multiplication combines scaling and rotation. This guide works through a concrete example and the trade-offs to remember.
• Vector Magnitude and Normalization — A vector's magnitude is its Euclidean length, and normalization scales a nonzero vector to length one. This guide works through a concrete example and the trade-offs to remember.
• The Dot Product and Angle Between Vectors — The dot product combines corresponding vector components and relates direction alignment to the cosine of their angle. This guide works through a concrete example and the trade-offs to remember.
• Matrix Inverses and Reversible Transformations — A square matrix has an inverse when it represents a reversible linear transformation with nonzero determinant. This guide works through a concrete example and the trade-offs to remember.
• Eigenvectors and Stable Directions — An eigenvector keeps its direction under a matrix transformation and is scaled by its associated eigenvalue. This guide works through a concrete example and the trade-offs to remember.
• Derivatives as Local Rates of Change — A derivative measures the limiting rate at which a function changes near an input value. This guide works through a concrete example and the trade-offs to remember.
• Limits and Continuity at a Point — A limit describes the value a function approaches as its input gets close to a point, even when the function value differs or is undefined there. This guide works through a concrete example and the trade-offs to remember.
• Logarithms as Inverse Exponents — A logarithm answers which exponent produces a value, turning multiplicative growth into additive reasoning. This guide works through a concrete example and the trade-offs to remember.
• Linear Recurrences and Characteristic Roots — A linear recurrence defines each sequence value as a weighted combination of earlier values and can often be solved using characteristic roots. This guide works through a concrete example and the trade-offs to remember.
• Entropy and Information Content — Entropy measures uncertainty in a probability distribution and is largest when outcomes are evenly likely. This guide works through a concrete example and the trade-offs to remember.
• Floating-Point Precision and Rounding — Floating-point formats approximate many real numbers with finite binary precision, so some decimal fractions cannot be represented exactly. This guide works through a concrete example and the trade-offs to remember.
• Coordinate Transforms and Change of Basis — A coordinate transform changes how a vector is represented, while the underlying geometric vector can remain the same. This guide works through a concrete example and the trade-offs to remember.
• What Happens When You Type a URL? — Follow a web request from the address bar through DNS, the network, and the browser as a page appears on your screen.
• DNS: The Internet's Address Book — Learn how domain names become IP addresses and how DNS resolvers find answers efficiently.
• HTTP Requests and Responses, Explained — Understand methods, status codes, headers, and the request-response cycle behind websites and APIs.
• TCP vs. UDP: Choosing How Data Travels — Compare reliable, ordered delivery with lightweight datagrams and see where each transport fits.
• TLS and HTTPS: Securing a Web Connection — See how certificates and encryption help browsers communicate privately with the right server.
• HTTP Caching and CDNs: Serving Pages Closer and Faster — Understand browser and shared caches, freshness rules, validators, and how a CDN reduces latency without serving stale content.
• The TCP/IP Layers and Encapsulation — Network layers divide communication responsibilities, and each layer wraps data with metadata needed by the next one. This guide works through a concrete example and the trade-offs to remember.
• IPv4 Addresses and Network Prefixes — An IPv4 prefix separates network bits from host bits so routers can group destinations by shared address ranges. This guide works through a concrete example and the trade-offs to remember.
• Subnet Masks and Address Capacity — A subnet mask marks which IP address bits identify a network and which identify hosts. This guide works through a concrete example and the trade-offs to remember.
• ARP and Finding a Neighbor on a Local Network — Address Resolution Protocol maps a local IPv4 address to a link-layer address needed to send a frame on the local network. This guide works through a concrete example and the trade-offs to remember.
• DHCP and Automatic Network Configuration — Dynamic Host Configuration Protocol leases network settings such as an address, gateway, and DNS resolver to a client. This guide works through a concrete example and the trade-offs to remember.
• Routing Tables and Next-Hop Decisions — A routing table maps destination prefixes to next hops or interfaces, allowing each router to forward one packet at a time. This guide works through a concrete example and the trade-offs to remember.
• The TCP Three-Way Handshake — TCP establishes a connection by exchanging SYN, SYN-ACK, and ACK segments that synchronize sequence state in both directions. This guide works through a concrete example and the trade-offs to remember.
• TCP Sequence and Acknowledgment Numbers — TCP sequence numbers identify byte positions in a stream, while acknowledgments report the next expected byte. This guide works through a concrete example and the trade-offs to remember.
• TCP Congestion Control and the Sending Window — TCP adjusts its sending rate in response to network feedback to avoid overwhelming shared paths. This guide works through a concrete example and the trade-offs to remember.
• UDP Datagrams and Application-Level Reliability — UDP sends independent datagrams without TCP's built-in delivery, ordering, or retransmission guarantees. This guide works through a concrete example and the trade-offs to remember.
• DNS Caching, TTLs, and Resolver Behavior — DNS resolvers cache records for their time-to-live so repeated name lookups can avoid another full hierarchy traversal. This guide works through a concrete example and the trade-offs to remember.
• TLS Certificates and Domain Validation — TLS certificates bind a public key to a domain identity through a chain that clients validate against trusted roots. This guide works through a concrete example and the trade-offs to remember.
• HTTP Methods and Their Intended Semantics — HTTP methods communicate the intended operation, such as retrieving a representation or submitting a change. This guide works through a concrete example and the trade-offs to remember.
• HTTP Status Codes and Response Categories — HTTP status codes summarize whether a request succeeded, needs more action, or encountered a client or server problem. This guide works through a concrete example and the trade-offs to remember.
• HTTP Headers and Negotiating Representations — HTTP headers carry metadata about requests and responses, including content type, caching policy, and accepted formats. This guide works through a concrete example and the trade-offs to remember.
• REST Resources and Stateless Request Design — REST-style APIs expose resources through consistent identifiers and HTTP operations while keeping each request self-contained. This guide works through a concrete example and the trade-offs to remember.
• WebSockets and Persistent Bidirectional Messages — WebSockets upgrade an HTTP connection into a persistent channel that supports messages in both directions. This guide works through a concrete example and the trade-offs to remember.
• Load Balancing Across Application Instances — A load balancer distributes requests across healthy service instances using a routing policy. This guide works through a concrete example and the trade-offs to remember.
• Rate Limiting and Token-Bucket Behavior — Rate limiting constrains request volume, and a token bucket allows short bursts while limiting the long-term average. This guide works through a concrete example and the trade-offs to remember.
• Exponential Backoff and Jitter for Retries — Exponential backoff increases delay between retries, while jitter randomizes timing to avoid clients retrying in lockstep. This guide works through a concrete example and the trade-offs to remember.
• Eventual Consistency Across Replicas — Eventual consistency permits replicas to temporarily disagree while promising convergence after updates stop propagating. This guide works through a concrete example and the trade-offs to remember.
• Content Delivery Networks and Edge Caching — A CDN serves cacheable content from edge locations closer to users, reducing origin work and network distance. This guide works through a concrete example and the trade-offs to remember.
• HTTP/3 and QUIC Connection Setup — HTTP/3 carries HTTP semantics over QUIC, which uses UDP while implementing transport features including encryption and stream multiplexing. This guide works through a concrete example and the trade-offs to remember.
• Cookies, Sessions, and Browser Request State — Cookies let a server ask a browser to send small pieces of state with matching future requests. This guide works through a concrete example and the trade-offs to remember.
• Polling, Server-Sent Events, and WebSockets — Applications can receive updates by periodic polling, one-way server-sent events, or bidirectional WebSocket messaging. This guide works through a concrete example and the trade-offs to remember.
• The Exposure Triangle: Aperture, Shutter Speed, and ISO — Understand how aperture, shutter speed, and ISO work together to control brightness, motion, and depth of field.
• Aperture and Depth of Field — See why a smaller f-number means a wider opening and how aperture changes background blur and the amount of a scene in focus.
• Shutter Speed: Freeze or Show Motion — Learn how exposure time affects moving subjects, intentional blur, and camera shake, with practical starting points for common scenes.
• Rule of Thirds and Stronger Composition — Use a simple grid to place a subject, create visual balance, and guide attention without treating composition rules as strict laws.
• White Balance and Natural-Looking Color — Discover how white balance compensates for warm and cool light, and when to choose automatic, preset, or custom color temperature.