Bits on Wires and Waves: The Physical Layer

The Question You Never Asked

Every time someone hits your Rails app, something magical happens. Your server generates HTML, JSON, whatever - and somehow it arrives on someone's phone in Tokyo, a laptop in Berlin, a desktop in São Paulo.

But how?

Not "how does HTTP work" or "how does routing work" - I mean, how does the actual stuff get there? Your response is just data - 1s and 0s. How do those travel through a cable? Through the air? Across an ocean?

This is the physical layer. It's the foundation everything else stands on. And once you see it, you'll never look at an Ethernet cable the same way again.

Let's Start With a Thought Experiment

Imagine you need to send a message to your friend across a field. You have a flashlight. How would you do it?

You'd probably do something like: flashlight ON means 1, flashlight OFF means 0. Flash it in patterns. Your friend watches and decodes.

Congratulations - you just invented digital communication.

That's literally what's happening in every cable and wireless signal. We're just flashing lights (or electrical pulses, or radio waves) really, really fast.

Copper Cables: Electricity as Messenger

The Ethernet cable plugged into your server? It's got copper wires inside. Copper conducts electricity. And here's the trick:

Voltage = Information

• Higher voltage = 1
• Lower voltage = 0

(The actual encoding is more sophisticated, but this is the mental model.)

Your network card does this:
```
Data to send: 01001000 01101001 (that's "Hi" in ASCII)

Translates to: low-high-low-low-high-low-low-low low-high-high-low-high-low-low-high
↓ ↓
Electrical pulses racing down the wire at ~2/3 the speed of light
```

The wire doesn't "know" it's carrying a greeting. It's just conducting electrical patterns. The network card on the other end reads the voltage changes and reconstructs the bytes.

The speed limit: Modern Ethernet can pulse billions of times per second. A 1 Gbps connection? That's 1 billion voltage transitions per second. Your "Hi" (16 bits) takes 0.000000016 seconds to transmit.

Fiber Optics: Light as Messenger

Copper has a problem - electrical signals weaken over distance and pick up interference. For long distances (like undersea cables connecting continents), we use light.

Fiber optic cables are thin glass tubes. Inside, a laser pulses:
- Light on = 1
- Light off = 0

The light bounces down the glass tube through total internal reflection (the same physics that makes a swimming pool look shiny from underwater). It can travel hundreds of kilometers with minimal signal loss.

Your Rails response leaving a data center:
┌─────────────────────────────────────────────────────────────┐
│  LASER: on-off-on-on-off-off-on-off...                      │
│         ════════════════════════════▶                       │
│         Light pulses at 186,000 miles/second                │
│         bouncing through glass thinner than a human hair    │
└─────────────────────────────────────────────────────────────┘

When you load a website hosted in another country, your data probably crossed an ocean through one of these:

Undersea Fiber Optic Cables (simplified):

  🌎 ─────────────═══════════════════════───────────── 🌍
     California                                    London

  That ═══ is a bundle of glass fibers on the ocean floor.
  Your HTTP response literally travels as pulses of light
  through glass tubes under the Atlantic.

There are about 400 of these cables crisscrossing the world's oceans right now. They carry 99% of intercontinental internet traffic.

WiFi: Invisible Flashlights

No wires? No problem. We use radio waves.

Your WiFi router is essentially a very fast, invisible flashlight broadcasting in all directions. It oscillates electromagnetic waves at specific frequencies (usually 2.4 GHz or 5 GHz).

What 2.4 GHz means:
The wave oscillates 2,400,000,000 times per second.

          /\    /\    /\    /\
         /  \  /  \  /  \  /  \    ← This pattern, 2.4 billion times/sec
        /    \/    \/    \/    \

To encode 1s and 0s, we modify properties of this wave:
- Change the height (amplitude): bigger wave = 1, smaller = 0
- Change the timing (phase): shifted wave = 1, unshifted = 0

- Change the frequency: slightly faster = 1, slightly slower = 0

Modern WiFi uses all of these simultaneously to pack more data into each transmission.

Your phone's WiFi chip is essentially doing this:
1. Receive electromagnetic waves from the router
2. Decode the wave modifications back into 1s and 0s
3. Hand those bytes up to the next layer

The "air" between your phone and router is carrying your Rails response as invisible light.

The Speed of Everything

Here's what blows my mind. When you click a link:

Medium	What Carries Data	Speed
Copper (Ethernet)	Electrical pulses	~200,000 km/s
Fiber Optic	Light pulses	~200,000 km/s
WiFi	Radio waves	300,000 km/s

These are all significant fractions of the speed of light. Your request to a server in London (let's say 8,000 km away) takes about 40 milliseconds just for the signal to get there - and that's mostly because it bounces through multiple routers and switches, not because light is slow.

This is latency - the time it takes for a signal to travel. No matter how much bandwidth you have, you can't beat physics.

Bandwidth vs Latency: The Highway Analogy

These two concepts confuse people, so let's nail them down:

Bandwidth = How wide is the highway?
- More lanes = more cars at once = more data per second
- Measured in bits per second (Mbps, Gbps)
- Your "100 Mbps connection" means 100 million bits can flow per second

Latency = How long is the highway?
- Distance from A to B = time to arrive
- Measured in milliseconds (ms)
- A request to a nearby server: ~10ms. To another continent: ~100-200ms

Here's the thing: you can't improve latency by adding bandwidth.

Scenario: Sending 1 bit to a server 1000km away

With 1 Mbps:   ──────●─────────────────▶  Arrives in ~5ms (speed of light)
With 1 Gbps:   ──────●─────────────────▶  Arrives in ~5ms (still speed of light!)

The bit doesn't go faster. You can just send MORE bits simultaneously.

This is why your Action Cable WebSocket connections care so much about proximity. Real-time features need low latency - and the only way to get that is being physically closer to your users.

Connecting Back to Your World

Remember Action Cable? When you broadcast a message to a channel:

ActionCable.server.broadcast("chat_#{room.id}", message: "Hello!")

Here's what happens at the physical layer:

1. Server → Ethernet cable: Your server's network card converts "Hello!" to electrical pulses
2. Data center switch: Pulses hit a switch, get routed to the right outbound cable
3. Fiber backbone: Converted to light pulses, shot across fiber optic cables
4. User's ISP: Light converted back to electricity, routed to their neighborhood
   
5. WiFi router: Converted to radio waves, broadcast into the air
6. Phone's WiFi chip: Radio waves decoded back to bytes
7. Browser: "Hello!" appears on screen

Your five-character string traveled as electricity → light → radio waves → and back to bytes. Across potentially thousands of kilometers. In under 100 milliseconds.

That's the physical layer. Everything else - TCP, HTTP, WebSockets, Rails - is just agreeing on what patterns of 1s and 0s mean.

The Mental Model to Keep

┌─────────────────────────────────────────────────────────────┐
│  YOUR RAILS APP                                             │
│  render json: { status: "ok" }                              │
└─────────────────────────┬───────────────────────────────────┘
                          │
                          ▼ (bytes)
┌─────────────────────────────────────────────────────────────┐
│  PHYSICAL LAYER                                             │
│                                                             │
│  Copper:  ⚡ voltage pulses in wires                         │
│  Fiber:   💡 light pulses in glass                          │
│  WiFi:    📡 radio waves in air                             │
│                                                             │
│  All just different ways to represent 1s and 0s            │
└─────────────────────────────────────────────────────────────┘

Challenge: Trace Your Own Request

Next time you load your app:

1. Open DevTools → Network tab
2. Look at the "Time" column for any request
3. That time includes: physical transmission (speed of light), processing (server), and everything in between

Try hitting a server in a different country. Notice how latency jumps by 50-200ms? That's literally the time it takes light to cross an ocean and come back.

You can't code your way around physics. But now you understand the physics.

Next up: We've got 1s and 0s moving through wires and air. But how does your data find its way across a network of billions of devices? That's where IP addresses and packets come in - the internet's postal system.