Adversarial Beginnings

If you’re going to learn a new language, it’s probably important to get an idea of the culture. After all, culture defines the vocabulary and the level of abstraction of a country’s language. Certainly that’s true of networking.

Computer networks began largely because of the ways humans segregate their sharing, not out of a desire to share freely. TCP/IP – and a lot of its underlying structure – evolved to meet a specific need: how can we keep a computer network functioning in the event of a nuclear war? When nodes go offline, randomly, how can surviving nodes keep the communication going? If Boise is destroyed, how can we still communicate with Seattle? Wiping out Kansas should not imply that we can’t connect with Nebraska. Gruesome beginnings, indeed.

Over time, though, those same TCP/IP networks evolved to meet a less bellicose need: How can we keep a network functioning efficiently if some of the paths are bottle-necked or even out-of-service? Well, the answer is, “build the ARPAnet” – now called the Internet – which relies heavily on TCP/IP networks. The OSI model underlying TCP/IP can adapt to changing loads, handle significant failures, and strictly limit the network “blast radius” (yes, sadly, that’s what it’s called) when things go wrong. TCP/IP networks distil the core of human sharing into (arguably) a much simpler and more predictable form.

Happily, the threat of nuclear war has dropped off substantially in the meantime, though it sometimes raises an ugly eyebrow. Also happily, the TCP/IP network has survived even the loss of its original purpose. This tutorial is about the surviving network. Full disclosure: I used to work in the WMD industry, but one day, I walked away and chose to promote sharing with other humans, instead of dividing and cloistering them. And I changed my official term for network failures from “blast radius” to “cone of silence” (CoS), probably my happiest choice of all.

Focusing on architecture

With complicated subjects, it’s always hard to know where to start. There’s a huge chicken-and-egg problem with TCP/IP when trying to define terms. I prefer to take Isaac Newton’s approach to physics, as he did in the Principia – create some definitions that start from common things we’re all likely to understand. For example, Newton begins with mass; slightly paraphrasing his definition: - The quantity of matter is defined as the density of that matter and the volume that it takes up, conjointly. In other words, m = ρ x V, or “mass equals density times volume”. That doesn’t seem like much, but it’s an astounding starting point. Hint: If you haven’t read an English translation of the Principia (it’s natively in Latin), you should take the time out to do so: it’ll change your understanding. Anyway, back to our story.

Network architecture

It’s very easy to just dive in, of course, and some fair percentage of my readers will get what I’m saying, but that isn’t good enough for this tutorial. Instead, imagine two computers, “SanDiego” and “Bangor”, located at opposite corners of the country. They want to communicate via available networks. How do they do it? Well, we could just hook up a wire between SanDiego and Bangor. People probably did that, at one point, back in the day. It might have even worked, until someone with a backhoe cut a cable. No problem! We’ll just use two wires. Surely we can get the first one fixed before somebody cuts the second one, right?

Of course, it wouldn’t take long to figure out that messages are getting lost and garbled. After all, it’s a long wire, which has lots of impedance. Some signals will disappear into the noise long before they get there. No problem! We’ll just build repeaters, little boxes that read the incoming signal and duplicate it at full voltage on the outgoing line: (Forgive the weird choice of cities, but I’m trying to work from memory here.) And if memory serves, leasing this space all over the country to add repeaters – especially at military bases like Redstone (Huntsville), Fort Hood, and Point Mugu – can get really expensive, really fast.

The AAC network model

By far a much easier way is to create and use the Internet. As the Internet became “the network”, it evolved into what some call the “access-aggregation-core” network. In the AAC model, SanDiego sends a message, labelled for Bangor, to some router on the Internet (which one doesn’t matter so much). If this router doesn’t know where Bangor is, it just sends it on to another router, until the message finds a router that knows where to forward the message: Theoretically, this works great, but from a practical standpoint, there are “short circuits” all over this network: These “sideways paths” are there mostly for performance reasons, like latency, redundancy, and so on. Sometimes they’re there because someone can get a better deal, so the reasoning is financial, too.

Later on in this tutorial, we’ll talk about some of these issues – and why network architectures have evolved. For now, though, let’s just say that they have evolved to a more monochromatic design known at the Clos architecture: This more scalable architecture can basically use the same switch for everything. There are leaf switches, known as “top of rack” (TOR) switches, and spine switches. As I’ve ghosted into the diagram, you scale horizontally by adding more racks, and vertically by adding more levels of spine switches. This architectural model is more economical to scale, so it discourages these little “side bets” that plagued the early Internet.

Yesterday’s phone network is today’s Internet

When learning a language, it also helps to get into some of the history of the people who speak that language. For instance, you may have noticed that a lot of Cajuns – who live in the humid swamps of the southern United States – often build houses in a unique way. They build a very sloped main roof, surrounding the house with a somewhat-elevated, wraparound porch. To be honest, this design makes *no* sense for a people living in “hurricane alley”. They’d be better off building houses out of concrete block, with a metal and concrete roof tied to the base with welded steel girders, and small windows instead of French doors. But they don’t, because of their *history*. The word “Cajun” is a lazy contraction of *Acadian*, the people who lived in Acadia, or “New France” in the 17th and 18th centuries.

If you look it up, you’ll find that Acadia included New Brunswick, Maine, and lots of Canadian maritime islands. They built houses with high-pitched roofs, with wraparound porches, so that the heavy *snow load* of winter would slide down the sloped roof, scoot off the porch roof, and land in the yard. This gave them a clear outside area to take care of outside business, such as chopping wood or skinning animals, without having to wade through the snow.

As a homework assignment, you can Google how the Acadians got to South Louisiana and South Mississippi; Wikipedia is largely accurate, if local folklore means anything.

Reusing what already works

In the same way, most of today’s modern networking is just a direct translation of the landline telephone system – [the “Plain Old Telephone Service (POTS)](https://networkencyclopedia.com/plain-old-telephone-service-pots/)” – into the digital space. Network switching is really just an outgrowth of crossbar, which is how local phone calls were “switched” or “routed” to the correct telephone line.

In most cases, every number dialled closed one more relay, with all seven relays making a connection to the target phone line. Small exchanges often “swallowed” dialled digits. For example, if every local phone number had the exchange “881”, those numbers wouldn’t trigger any relays beyond just sending the call to the “881” frameset. In some small exchanges, it wasn’t even necessary to dial the exchange, just the four digits of the phone number, if the caller had the same exchange. My grandparents had such an arrangement for many years, as did my partner’s parents. Essentially, these “shorthand numbers” were the early *subnets*.

Long distance and T1

In order to maintain call quality, the very early telephone system (about 1908) began to use repeaters and loading coils. A repeater receives a signal and regenerates a new signal of the same frequency, raising the signal back to the same power level. A loading coil adds inductance to the line, which resists changes in current, keeping the transmitted waveform more stable, that is, reducing the distortion introduced by the impedance of the long wires.

The next evolution, T1 lines, couldn’t compete with today’s fibre connections, but they did provide a speedy (at the time) 1.5Mbps connection. For example, in the oil and gas industry of the early 1990s, many of the city offices in New Orleans had wall after wall of T1 lines wired directly into the building, so that they could get high-speed data from the offshore oil platforms just a few miles away. T1 wasn’t originally designed for network traffic. The idea was to multiplex phone calls on one line via Time-Division Multiplexing. TDM split up the call traffic into little *digital* packets that were sent on a rotating basis.

The first T1 lines, which showed up around 1962, could handle about 24 calls without the average telephone user noticing. Telephone linemen, on the other hand, could usually tell by the “clipped” nature of the call, as there is a distinctive flatness to the conversation over a digital TDM circuit.

My first real job was telephone lineman, so I can attest to this “flatness”. In fact, I recall an actual training session in which we listened to the same call on two different lines in stereo headphones. In one ear, we heard the T1 call; in the other, the analog output of the same conversation. Listening to them in stereo, in sync, made it easy to learn the subtle differences. The real point is that these “little digital packets” formed the model for the *packet networking* we have today.