Computer Science › Systems
The Internet as two parts — end systems at the edge running applications, and a mesh of routers and links in the core moving their data — and packet switching, the core's strategy of chopping messages into small units and forwarding each one independently instead of reserving an end-to-end circuit.
Splitting the impossibly complex job of networking into five layers — application, transport, network, link, physical — each hiding its own machinery behind a fixed service to the layer above, the exact same information-hiding discipline already covered as a software-design principle, now applied to protocol design.
Four kinds of delay a packet accumulates at every hop — processing, queuing, transmission, propagation — plus loss from full buffers and throughput as the actual rate data moves, with the bandwidth-delay product giving the real numbers behind why a single slow link anywhere on a path can dominate an entire connection's performance.
Two structural answers to "who talks to whom": a client-server architecture with an always-on server all clients address, versus a peer-to-peer architecture where intermittently-connected end systems serve each other directly — a real design choice with real scalability tradeoffs, not just a historical curiosity.
HTTP's request-response cycle, its deliberate statelessness (and cookies as the bolted-on workaround), and persistent versus non-persistent connections — the concrete application-layer protocol every worked example later in this discipline traces down through every lower layer.
A distributed, hierarchical database — root, top-level-domain, and authoritative servers — that translates a human-readable name into the IP address every lower layer actually needs, resolved through a chain of iterative and recursive queries and made fast in practice almost entirely by caching.
The transport layer's job is process-to-process delivery on top of the network layer's host-to-host delivery — multiplexing/demultiplexing via port numbers, and a real choice between UDP (bare-minimum, no guarantees) and TCP (reliable, ordered, congestion-controlled), with real applications on each side of that choice.
Building reliability on top of an unreliable channel from first principles — acknowledgments, sequence numbers, timers, and retransmission — then pipelining multiple in-flight packets for throughput, with Go-Back-N and Selective Repeat as the two real strategies for what a receiver does when packets arrive out of order.
TCP's real segment header (sequence and acknowledgment numbers, SYN/ACK/FIN flags, window size), and the three-way handshake — SYN, SYN-ACK, ACK — that establishes a connection's initial sequence numbers before a single byte of application data moves.
How the general reliable-data-transfer principles become TCP's actual mechanism: cumulative acknowledgments, fast retransmit on triple duplicate ACKs, and adaptive timeout computed from a running estimate of round-trip time — real formulas, not just the concept of "retransmit if it's late".
Flow control protects a slow receiver from a fast sender — the receiver advertises how much free buffer space it has, and the sender's window shrinks or grows to match, a distinct concern from congestion control (which protects the network, not the receiver) even though both use the word "window".
TCP treats the network itself as fragile and infers congestion from loss — slow start grows the congestion window exponentially until a loss event, then additive-increase/multiplicative-decrease (AIMD) probes gently and backs off hard, a real cwnd-over-time sawtooth traced across several round trips, and the reason independently-run TCP connections converge toward sharing a bottleneck link fairly.
Forwarding (the data plane: a router's per-packet, local decision of which outgoing link to use, made in nanoseconds by consulting a table) is a fundamentally different job from routing (the control plane: the network-wide, much slower algorithm that computes what that table should contain) — a distinction every following concept in this cluster depends on keeping straight.
A 32-bit address split into a network prefix and a host suffix, with CIDR notation (e.g. 128.11.3.0/24) replacing the old rigid class-based scheme with an arbitrary-length prefix — worked subnetting arithmetic showing exactly how many usable host addresses a given prefix length leaves, and why address space had to be rationed this carefully before IPv6.
A router forwards a packet by finding, among every prefix in its table, the longest one that matches the destination address — worked by hand against a small concrete forwarding table — the rule that lets one entry cover millions of addresses while a more specific entry still takes precedence when it applies.
A NAT router rewrites every outgoing packet's private source address and port into its own single public address and a fresh port, keeping a translation table to route replies back to the right internal host — a pragmatic, widely-deployed fix for address scarcity that also, honestly, breaks the end-to-end principle the Internet was originally designed around.
The two families of routing algorithm are not new graph theory — link-state routing runs Dijkstra's algorithm, already covered in full, over a globally-known topology graph, while distance-vector routing runs the Bellman-Ford algorithm, also already covered, with each router knowing only its neighbors' costs; distance-vector's real, honest weakness is the count-to-infinity problem when a link fails.
The Internet is not one flat routing domain but thousands of independently-administered autonomous systems — OSPF (link-state) runs the routing algorithm already covered inside one AS, while BGP (path-vector, a policy-driven cousin of distance-vector) glues autonomous systems together at the Internet's actual scale, where routing decisions are as much about business agreements as about shortest paths.
One hop below the network layer, the link layer moves a frame across a single physical link — framing marks where one frame ends and the next begins, and a checksum (a cyclic redundancy check, in practice) lets the receiver detect, though not always correct, bit errors introduced by real, noisy physical media.
When many hosts share one physical medium, something has to decide who transmits when — CSMA/CD (carrier sense, collision detection, exponential random backoff) is classic Ethernet's answer, and a switch's ability to isolate each link into its own collision domain is the real reason modern switched Ethernet barely needs it anymore.
IP addresses route a packet across networks, but a link-layer frame needs the destination's MAC address for this one hop — ARP resolves one into the other by broadcasting a query and caching the answer, and that cache is, mechanically, exactly the hash table already covered: IP address as key, MAC address as value, with a real timeout instead of an eviction policy.
Wireless breaks a quiet assumption of wired Ethernet — that every node can hear every collision — so CSMA/CA (collision avoidance, not detection) and the hidden-terminal problem replace CSMA/CD, and mobility adds the further question of how a moving host keeps its connections alive as it hands off between access points.
One `GET` request, typed into a browser, walked down through every layer this discipline covered and back up again — DNS resolution, TCP's three-way handshake, HTTP's request/response, IP forwarding hop by hop guided by routing's precomputed tables, ARP resolving the final hop, and framing/error-detection on the wire — naming, at each step, exactly which concept explains it, and closing with an honest scope boundary against `distributed-systems-i`.
Part of the Computer Science curriculum.
The Internet as two parts — end systems at the edge running applications, and a mesh of routers and links in the core moving their data — and packet switching, the core's strategy of chopping messages into small units and forwarding each one independently instead of reserving an end-to-end circuit.
Splitting the impossibly complex job of networking into five layers — application, transport, network, link, physical — each hiding its own machinery behind a fixed service to the layer above, the exact same information-hiding discipline already covered as a software-design principle, now applied to protocol design.
Four kinds of delay a packet accumulates at every hop — processing, queuing, transmission, propagation — plus loss from full buffers and throughput as the actual rate data moves, with the bandwidth-delay product giving the real numbers behind why a single slow link anywhere on a path can dominate an entire connection's performance.
Two structural answers to "who talks to whom": a client-server architecture with an always-on server all clients address, versus a peer-to-peer architecture where intermittently-connected end systems serve each other directly — a real design choice with real scalability tradeoffs, not just a historical curiosity.
HTTP's request-response cycle, its deliberate statelessness (and cookies as the bolted-on workaround), and persistent versus non-persistent connections — the concrete application-layer protocol every worked example later in this discipline traces down through every lower layer.
A distributed, hierarchical database — root, top-level-domain, and authoritative servers — that translates a human-readable name into the IP address every lower layer actually needs, resolved through a chain of iterative and recursive queries and made fast in practice almost entirely by caching.
The transport layer's job is process-to-process delivery on top of the network layer's host-to-host delivery — multiplexing/demultiplexing via port numbers, and a real choice between UDP (bare-minimum, no guarantees) and TCP (reliable, ordered, congestion-controlled), with real applications on each side of that choice.
Building reliability on top of an unreliable channel from first principles — acknowledgments, sequence numbers, timers, and retransmission — then pipelining multiple in-flight packets for throughput, with Go-Back-N and Selective Repeat as the two real strategies for what a receiver does when packets arrive out of order.
TCP's real segment header (sequence and acknowledgment numbers, SYN/ACK/FIN flags, window size), and the three-way handshake — SYN, SYN-ACK, ACK — that establishes a connection's initial sequence numbers before a single byte of application data moves.
How the general reliable-data-transfer principles become TCP's actual mechanism: cumulative acknowledgments, fast retransmit on triple duplicate ACKs, and adaptive timeout computed from a running estimate of round-trip time — real formulas, not just the concept of "retransmit if it's late".
Flow control protects a slow receiver from a fast sender — the receiver advertises how much free buffer space it has, and the sender's window shrinks or grows to match, a distinct concern from congestion control (which protects the network, not the receiver) even though both use the word "window".
TCP treats the network itself as fragile and infers congestion from loss — slow start grows the congestion window exponentially until a loss event, then additive-increase/multiplicative-decrease (AIMD) probes gently and backs off hard, a real cwnd-over-time sawtooth traced across several round trips, and the reason independently-run TCP connections converge toward sharing a bottleneck link fairly.
Forwarding (the data plane: a router's per-packet, local decision of which outgoing link to use, made in nanoseconds by consulting a table) is a fundamentally different job from routing (the control plane: the network-wide, much slower algorithm that computes what that table should contain) — a distinction every following concept in this cluster depends on keeping straight.
A 32-bit address split into a network prefix and a host suffix, with CIDR notation (e.g. 128.11.3.0/24) replacing the old rigid class-based scheme with an arbitrary-length prefix — worked subnetting arithmetic showing exactly how many usable host addresses a given prefix length leaves, and why address space had to be rationed this carefully before IPv6.
A router forwards a packet by finding, among every prefix in its table, the longest one that matches the destination address — worked by hand against a small concrete forwarding table — the rule that lets one entry cover millions of addresses while a more specific entry still takes precedence when it applies.
A NAT router rewrites every outgoing packet's private source address and port into its own single public address and a fresh port, keeping a translation table to route replies back to the right internal host — a pragmatic, widely-deployed fix for address scarcity that also, honestly, breaks the end-to-end principle the Internet was originally designed around.
The two families of routing algorithm are not new graph theory — link-state routing runs Dijkstra's algorithm, already covered in full, over a globally-known topology graph, while distance-vector routing runs the Bellman-Ford algorithm, also already covered, with each router knowing only its neighbors' costs; distance-vector's real, honest weakness is the count-to-infinity problem when a link fails.
The Internet is not one flat routing domain but thousands of independently-administered autonomous systems — OSPF (link-state) runs the routing algorithm already covered inside one AS, while BGP (path-vector, a policy-driven cousin of distance-vector) glues autonomous systems together at the Internet's actual scale, where routing decisions are as much about business agreements as about shortest paths.
One hop below the network layer, the link layer moves a frame across a single physical link — framing marks where one frame ends and the next begins, and a checksum (a cyclic redundancy check, in practice) lets the receiver detect, though not always correct, bit errors introduced by real, noisy physical media.
When many hosts share one physical medium, something has to decide who transmits when — CSMA/CD (carrier sense, collision detection, exponential random backoff) is classic Ethernet's answer, and a switch's ability to isolate each link into its own collision domain is the real reason modern switched Ethernet barely needs it anymore.
IP addresses route a packet across networks, but a link-layer frame needs the destination's MAC address for this one hop — ARP resolves one into the other by broadcasting a query and caching the answer, and that cache is, mechanically, exactly the hash table already covered: IP address as key, MAC address as value, with a real timeout instead of an eviction policy.
Wireless breaks a quiet assumption of wired Ethernet — that every node can hear every collision — so CSMA/CA (collision avoidance, not detection) and the hidden-terminal problem replace CSMA/CD, and mobility adds the further question of how a moving host keeps its connections alive as it hands off between access points.
One `GET` request, typed into a browser, walked down through every layer this discipline covered and back up again — DNS resolution, TCP's three-way handshake, HTTP's request/response, IP forwarding hop by hop guided by routing's precomputed tables, ARP resolving the final hop, and framing/error-detection on the wire — naming, at each step, exactly which concept explains it, and closing with an honest scope boundary against `distributed-systems-i`.