28 articles

#cs

All articles tagged with #cs.

Caching and CDNs: why the second load is instant

How Cache-Control headers control browser caching, what a CDN actually does, and why cache invalidation is one of the two hard problems in computing.

Aug 29, 20266 min

Project: trace a real request end to end

Use dig, curl -v, and openssl s_client to trace a real HTTPS request through every layer this series covered: DNS, TCP, TLS, and the HTTP exchange.

Aug 29, 20266 min

Cookies and how sites remember you

HTTP has no memory between requests. Cookies fix that: how Set-Cookie works, session tokens vs stored data, and the flags that keep cookies secure.

Aug 28, 20265 min

CORS: why the browser blocked your request

Why the browser, not the server, blocks cross-origin requests by default, what a preflight request checks, and how to actually fix a CORS error.

Aug 28, 20266 min

Why HTTP got rewritten twice

HTTP/1.1's head-of-line blocking problem, how HTTP/2 fixed it with multiplexing, and why HTTP/3 had to leave TCP behind entirely to fix it again.

Aug 27, 20265 min

HTTPS and TLS: how the padlock works

How TLS encrypts a connection, why TLS 1.3 needs one round trip instead of two, and what the browser padlock does and doesn't protect.

Aug 27, 20266 min

HTTP: the request and response contract

The anatomy of an HTTP request and response: methods, headers, bodies, and status codes. Inspect real request/response pairs interactively.

Aug 26, 20265 min

Status codes and headers that actually matter

The HTTP status codes worth memorizing (200, 201, 204, 400, 401, 404, 409, 500) and the headers that control caching, content, and auth.

Aug 26, 20266 min

DNS: how names become addresses

How DNS resolves a domain name to an IP address, step by step: stub resolvers, recursive resolvers, root servers, and why caching makes the second lookup free.

Aug 25, 20266 min

TCP vs UDP: reliable or fast, pick one

How TCP's three-way handshake builds a reliable connection, what UDP skips to go faster, and why video calls and web pages make opposite trade-offs.

Aug 25, 20266 min

IP addresses and packets: how data finds you

What an IP address actually is, why data travels in packets instead of one stream, and how routers pass them along. The layer under DNS and TCP.

Aug 24, 20267 min

What happens when you type a URL and hit enter

The full journey from keystroke to rendered page: DNS, TCP, TLS, HTTP, and rendering. The map this whole networking series fills in, piece by piece.

Aug 24, 20267 min

Project: Build an LRU Cache

Combine a hash map with an ordering structure to build an LRU cache with O(1) get and put that evicts the least-recently-used item, with live visualizers.

Aug 18, 20266 min

Intro to Dynamic Programming: Memoization

Why naive recursive Fibonacci is exponential, how overlapping subproblems cause it, and how memoization makes it linear, with a live call-stack visualizer.

Aug 18, 20266 min

Binary Search Trees: Ordered in O(log n)

How the BST rule (left < node < right) gives O(log n) search, why inorder traversal comes out sorted, and the skewed worst case, with a live tree visualizer.

Aug 17, 20267 min

Graphs & Traversal: BFS and DFS

Graphs, adjacency lists, and the two ways to visit every node: BFS with a queue for shortest hops, and DFS with recursion to go deep, shown with live visualizers.

Aug 17, 20266 min

Linked Lists: Pointers, Nodes & Trade-offs

Linked lists chain nodes with next pointers for O(1) inserts but O(n) indexing. See the trade-offs vs arrays with an interactive visualizer and runnable Python.

Aug 16, 20265 min

Trees & Binary Trees: Traversals

Trees model hierarchies with roots, children, and leaves. Learn binary trees and the four traversals (in/pre/post-order and BFS) with visualizers and Python.

Aug 16, 20266 min

Binary Search: Halving the Haystack

Search a sorted array in O(log n) by halving it every step. Watch lo, mid, and hi close in on the target with an interactive visualizer and runnable Python.

Aug 15, 20265 min

Stacks & Queues: LIFO vs FIFO, Explained

Stacks (LIFO) and queues (FIFO) drive undo, the call stack, and task processing. See their core ops with interactive visualizers and runnable Python.

Aug 15, 20265 min

Sorting II: Merge Sort & Quicksort

Divide and conquer sorting: merge sort's stable O(n log n) and quicksort's partitioning, average O(n log n) and worst O(n²), with a live visualizer and runnable Python.

Aug 14, 20266 min

Sorting I: Bubble, Selection & Insertion

The three quadratic sorts explained: how bubble, selection, and insertion sort each work, why they're O(n²), with a live visualizer and runnable Python.

Aug 14, 20265 min

Recursion & the Call Stack

How recursion actually works: base case vs recursive case, and how the call stack grows and unwinds, visualized step by step with runnable Python you can edit.

Aug 13, 20265 min

Two Pointers & the Sliding Window

Two interview-favorite patterns that turn O(n²) brute force into O(n): two pointers and the sliding window, shown live and in runnable Python you can edit.

Aug 13, 20265 min

Arrays & Strings: The Workhorse Data Structure

How arrays use contiguous memory for O(1) indexing but O(n) search and insert, and why strings are immutable arrays of characters, with a live two-pointer scan and Python.

Aug 12, 20266 min

Hash Maps & Sets: O(1) Lookups Explained

How hashing maps a key to a bucket for average O(1) lookups, what collisions and chaining are, and why order isn't guaranteed, with a live visualizer and runnable Python.

Aug 12, 20266 min

Big-O Notation: Measuring How Code Scales

Big-O is the language of growth: constant, linear, quadratic, log and linearithmic explained. Drop the constants, read any snippet's cost, with a live chart and Python.

Aug 11, 20266 min

Why Data Structures & Algorithms (and How to Think About Speed)

What DSA really is, why 'it works' and 'it works at scale' are different problems, and how to reason about cost, with a live growth chart and runnable Python.

Aug 11, 20266 min