Networks Explained

The input and output post named the network card as a device that is input and output at the same time, and left it there. The operating system post showed the kernel talking to that card like it talks to a keyboard or a disk. Neither post asked the obvious question: who is on the other end? This post opens the world outside the machine. What a network actually is, why machines share a road instead of owning it, and the problem that every layer of the next nine posts exists to solve.

What a network is

A computer network¹ is two or more machines connected together, able to exchange information. That is the whole definition, and it sounds trivial until you count what it hides.

A node is any machine with a network address: your laptop, a phone, a printer, a router, a server in a data center. A link is the road between two nodes: a cable, a radio wave, a fiber strand, a satellite hop. A protocol² is the agreement on how bits turn into meaning on that road. Two machines speaking different protocols on the same wire hear only noise.

A network is not the cable. The cable is just copper or glass. The network is the agreement plus the addressing plus the machinery that delivers bytes to the right machine.

node ──── link ──── node
 │                      │
 └── same protocol ─────┘

The machine inside your laptop is already a full computer with its own memory and CPU. A network does not merge those machines into one super-computer. It gives each one a way to say “send these bytes over there” and to receive bytes meant for it. Isolation stays; communication is added.

Real example: when you print a document, your laptop does not become part of the printer. It sends bytes to the printer’s address, and the printer pulls them out of its own memory buffer. Two computers, two memories, one agreed road.

Why not connect every machine to every machine

The naive way to link five machines is a dedicated cable between each pair: 5 × 4 ÷ 2 = 10 cables. Twenty machines need 190. A thousand machines need half a million. Every port and every cable is a cost, a failure point, and a configuration headache. No network ever shipped this way.

The fix is the same idea as a street system: do not build a private road between every pair of houses. Build shared roads, give every house an address, and let the roads carry everyone’s traffic.

naive:      A ─ B   A ─ C   A ─ D   B ─ C   B ─ D   C ─ D
shared:     A ─┐
                ├─ shared road ─┬─ B
             C ─┘               └─ D

Now the number of links grows with the number of machines, not with its square. Somebody still has to do the work of reading the destination address and forwarding each message: that somebody is a router³, and the machine that gives your laptop its first step onto the road is a switch. The rest of this series is about the layers of machinery that make one shared road serve millions of machines at once, reliably.

Two ways to share a road

When many senders want one road, there are two classic answers.

Circuit switching⁴ reserves the road for one conversation at a time. You get a dedicated path for the whole call, nobody else can use it, and the order of your data is guaranteed. The telephone network worked this way for a century. The cost is obvious once you notice it: the reserved parts sit idle whenever you are not talking. A voice call uses maybe 20% of a reserved circuit in each direction, and the other 80% is wasted capacity that no one else is allowed to touch.

Packet switching⁵ shares the road by chopping the data into small pieces called packets⁶. Each packet carries its destination address and travels independently. Many senders interleave their packets on the same road, and the receiver reassembles them in order.

circuit switching:
sender ────────────────► receiver      (the whole road, reserved)

packet switching:
A: [p1][p2][p3]   B: [q1][q2]   C: [r1]
   [p1] [q1] [p2] [r1] [p3] [q2]      (one road, many senders)

Packet switching wins because it never reserves anything. The road carries whatever anyone has to send, and idle capacity is used by the next packet. It also lets packets from the same sender take different routes across the internet, a property that turns out to be a feature rather than a bug.

But the freedom has a price, and this price is the reason the internet needed most of this series:

• Packets can be lost. Memory and queues are finite; a burst of traffic overruns a router and something has to be dropped.
• Packets can arrive out of order. Two packets take two paths or two turns in a queue.
• Packets can be duplicated. A router unsure whether a packet arrived may send it again.
• Packets can be corrupted. Noise on the wire flips bits.

So the network itself is best effort: it makes no promises. It carries what it can and shrugs at the rest. Every layer above it exists to build the guarantees that best effort refuses to give.

The internet is not a reliable network that sometimes fails. It is an unreliable network that applications have learned to make reliable.

Topology: how machines are wired together

Network topology⁷ is the shape of the connections: who is wired to whom. A few shapes recur.

bus:         A ─ B ─ C ─ D        (everyone shares one cable)
star:        A ─┐
                 ├─ (hub/switch)
              B ─┘
mesh:        A ─── B
             │  ╲ │  ╱
             │    ╳
             │  ╱ │  ╲
             C ─── D

The bus was the first cheap answer: one cable, every machine taps it, everyone hears everything. It collapses when a cable breaks or two machines transmit at once, because signals collide. The star fixes that with a central box, and it won. Modern home and office networks are stars: every machine has its own cable to a switch, which is a box that learns addresses and forwards each frame only where it is needed. The mesh survives any single failure because there is no single point of failure, which is why it shows up between routers and data centers rather than between laptops.

Note what the star really is: one shared medium, split into private lanes. Each machine gets a dedicated cable into the switch, and the switch makes sure no two machines speak at the same time on the wire. Contention does not disappear in a star; it moves inside the box, where it can be managed.

The core problem networks solve

Every network, from two laptops with one cable to the entire internet, is solving the same set of problems. It is worth naming them now, because each later post is the answer to one of these lines.

• Naming and addressing: who is the machine I want to talk to, and how does my data carry that answer?
• Delivery: given an address, how does the data travel across a road that may not lead there, over hops that belong to other people?
• Reliability: the road loses and reorders packets. Who notices, and who sends them again?
• Sharing: one road, many senders, and a way to take turns without anyone starving.
• Governance: no one owns the internet. Millions of independent networks agree to carry each other’s traffic and to be polite about it.
• Security: strangers share the same road. How do you keep them from reading or changing what is not theirs?

That last set is why a network is not just fast wires. Speed is the easy part.

Why a network is not one big machine

There is one more design decision before the layers, and it is the one this series is really about.

One plausible design: a single protocol that does everything. Name resolution, routing, reliability, encryption, the web. One code path, one place to debug.

It does not work. Every use is different: a video game cannot wait for lost packets, a file transfer must, a printer needs a language nobody else speaks. One protocol for all of them forces every case to pay for every feature.

So networks are built in layers. Each layer offers a service to the layer above and uses the layer below without knowing how it works. The link layer delivers bytes to the neighbor. The network layer finds a path across the world. The transport layer makes delivery reliable for one program. The application layer speaks the language your program actually wants.

your program:      "get me this page"
   ↓
application:       HTTP request
   ↓
transport:         reliable bytes to one program
   ↓
network:           packets across every hop
   ↓
link:              frames to the next machine
   ↓
physical:          volts on a wire

Each layer gets to be simple because it trusts the layer below. And each one can be replaced, improved, or ignored without rewriting the others, which is exactly why the internet kept working while everything got replaced.

The physical layer is not at the bottom of importance, only at the bottom of the stack. It still decides whether your video works.

Real example: when Wi-Fi got faster, the link changed and almost nothing above it did. When TCP was replaced by QUIC in HTTP/3, the physical layer never heard about it. Layering is not bureaucracy; it is what let the internet survive five decades of replacing every part.

The big picture

A network is machines plus roads plus agreements. Wiring every pair directly does not scale, so machines share roads with addresses, and routers do the forwarding. Sharing a road means chopping data into packets that may be lost, reordered, duplicated, or corrupted, so the network itself promises nothing. On top of that best effort, layers each add one guarantee, from “these bits reach the neighbor” up to “here is your web page”.

nodes + links + protocol
  ↓
shared roads, addressed (routers forward)
  ↓
packets: lossy, out of order, duplicated
  ↓
layers, each adding one guarantee
  ↓
programs that can rely on something

The next post opens the model that organizes those layers, the famous seven-floor list everyone half-remembers from school, and what actually happens to your data each time it crosses one.

Footnotes

1. Computer network - Wikipedia

2. Network protocol - Wikipedia

3. Router (computing) - Wikipedia

4. Circuit switching - Wikipedia

5. Packet switching - Wikipedia

6. Network packet - Wikipedia

7. Network topology - Wikipedia