Concept index

How endpoints detect a busy network and slow down so shared links do not collapse into congestive failure, including classic TCP dynamics and modern signal debates.

The distributed naming system that turns human-readable names into machine-routable addresses and other records, via hierarchy, caching, and delegation.

The internet's control and error messaging companion to IP: how hosts and routers report problems, probe reachability, and discover path limits.

Numeric locators that identify network interfaces for routing: how address structure, prefixes, and public versus private space make a global map computable.

How neighboring machines on a local segment deliver frames using MAC addresses, shared media rules, and link-specific framing before IP routing enters the picture.

How private address spaces and network address translation stretch IPv4 and hide internal topology, at the cost of true end-to-end addressing.

Why the internet is built as stacked contracts (link, internet, transport, application) so each problem can be solved once and reused, and where those contracts deliberately leak.

Why networks chop data into small, independently routable pieces instead of one continuous stream, and what that choice forces every higher layer to confront.

How transport-layer port numbers multiplex many conversations on one host, and how the socket abstraction turns those numbers into a programming interface.

How packets find a path: local forwarding decisions at each hop, guided by routes learned or configured across independently operated networks.

The internet's core contracts: IP for addressing and forwarding, TCP for reliable byte streams on top of an unreliable network, including handshake, ACK, and windowing mechanics.

A minimal transport: multiplex apps with ports, deliver datagrams, and leave reliability, ordering, and congestion response to the application when that is the right tradeoff.

Hide details that do not matter for the current question so you can think at the right altitude, and know when to drop altitude because the abstraction leaked.

Explain systems with mechanisms and counterfactuals: what would change if this part failed, so debugging becomes structured rather than vibes-based.

Reason from irreducible truths instead of analogies, slogans, or inherited procedures, especially when learning technical systems like networks.

Authentication answers who you are. Authorization answers what you may do. Mixing them creates real security bugs even when login "works."

A conceptual map of frequent attack classes (injection, spoofing, abuse of trust) and how each maps to assets, adversaries, and trust boundaries you already named in a threat model.

Transforming data so only holders of the right secrets can read or forge it: confidentiality, integrity, and authenticity on public networks.

How HTTP rides inside an authenticated, encrypted transport: certificates, handshakes, and what the lock icon actually promises.

Why security is never absolute: you state who might attack, what you protect, and where trust stops, then choose controls against that model.

An API is a boundary with a contract: allowed inputs, promised outputs, and failure rules. Implicit contracts break silently. Explicit ones fail loudly and evolvable.

The dominant networked application pattern: clients initiate requests, servers listen and respond, and responsibilities split across an asymmetric relationship.

Why a server must handle many clients at once, how processes, threads, and async overlap conceptually, and how race conditions appear when shared state meets overlapping work.

Why servers must remember things across requests, how memory and disk trade latency for durability, and how that general problem sits under web sessions and API resources.

The universal web client: how browsers fetch, parse, sandbox, and render, tying DNS, TLS, HTTP, and HTML/CSS/JS into one user-facing machine.

How copies of content near users cut latency and origin load, and how cache validators and CDNs keep those copies just fresh enough.

How the web layers state onto a largely stateless protocol: cookies as client-stored tokens, sessions as server-side memory keyed by those tokens.

The three native web languages: structure (HTML), presentation (CSS), and behavior (JavaScript), and why separating them remains a useful discipline.

The application protocol of the web: structured requests and responses for transferring documents and calling APIs, including methods, status codes, and caching metadata.

Resources and representations over HTTP: designing networked interfaces around nouns, uniform methods, and evolvable contracts rather than ad-hoc RPC soup.