Routing: How Packets Cross the World

Routing: How Packets Cross the World

What you'll learn

• Explain hop-by-hop forwarding: what every router does with every packet, independently
• Read a routing table — networks, next hops, interfaces, metrics — and predict a router's decision
• Contrast static and dynamic routing, and know when each fits
• Name the protocol cast at awareness level: OSPF and IS-IS inside organizations, BGP between them — and place RIP, EGP and EIGRP historically
• Build a two-network routed topology in Packet Tracer, then read a real traceroute like a professional

This lesson builds on Chapter 6 of Dr. Tahseen Al-Doori's Network Essentials, whose routing sections supply three keepers: the map analogy that makes routing intuitive, the hop-by-hop walk-through this lesson retells, and the distinction between routable and routing protocols. Chapter 10 contributes the traceroute craft the lab ends with. One scope note, set by this course's design: you will learn to recognize and place the routing protocols, not to configure them — protocol operation belongs to certification courses (CCNA and beyond), and an essentials course serves you better by making the fundamentals unshakable.

The map and the roads

A classic analogy from Dr. Al-Doori's course opens the topic better than any definition. Unfold a road map of a region. The towns scattered across it are networks — each one a LAN, a broadcast domain, a place where local delivery works by itself (a switch can handle a town). The highways connecting the towns are the links between networks. And notice what the map makes obvious: between most towns there is more than one way to drive. Which route is best depends on what you are optimizing — the fastest road, the shortest, the most scenic, the cheapest in fuel. Different criteria, different best paths, same map.

A router is the device that owns this map. Where a switch asks "which of my ports leads to this MAC address?" — a question about one town's streets — a router asks "which direction leads toward this network?" — a question about the highway system. Its job, packet by packet, is to choose the next stretch of highway: not the whole trip, just the best next road out of town. That restraint — deciding one leg at a time — is the heart of everything below.

Hop by hop across the world

Follow one packet from your laptop to a server three networks away, and watch the same small procedure repeat.

Your laptop, as Module 4 taught, checks the destination against its own network: not local → frame it to the default gateway. The gateway router receives the frame, strips it (Module 2: frames live one hop), and now performs the routing procedure — the loop at the center of this lesson:

1. Extract the destination network. From the packet's destination IP address, using masks/prefixes exactly as you learned in subnetting: which network is this address in?
2. Look it up in the routing table. The table lists known networks and the best next step toward each.
3. Forward to the next hop. Build a fresh frame (new MAC addresses for this one link — the packet inside rides unchanged) and send it to the neighboring router the table names.
4. Or drop it. If no table entry matches — no route — the packet is discarded, and the router sends back an ICMP "destination unreachable" note. No flooding, no guessing. A switch floods when ignorant; a router refuses. (This difference is why the whole Internet doesn't drown in lost packets looking for a home.)

The next router does exactly the same, with its table. And the next. Each router decides independently — no router knows the whole path, no reservation is made end to end, and nobody is in charge of the journey. The book names this the hop-by-hop paradigm, and it explains behaviors that surprise beginners: the reply can travel a different path than the request (each direction is decided hop by hop too); a path can change mid-conversation if a link fails; and no single failure kills the system, because every router simply picks its next-best road — the resilience the map analogy promises.

One safeguard from Module 2 completes the picture: the IP header's TTL field, the hop budget. Every router decrements it; at zero, the packet is discarded and an ICMP "time exceeded" message goes back to the sender. Without TTL, a routing mistake that forms a loop would circulate packets forever. Hold that thought — the lab's traceroute trick is built entirely out of this safeguard.

Reading the map: routing table anatomy

Here is the routing table of a small business router — authored for this lesson, simplified to the columns every real format shares. The router connects two internal networks and one link to its ISP:

Read it row by row, because each row type recurs in every router you will ever meet:

• Connected routes appear automatically: the router is on 192.168.1.0/24 and 192.168.2.0/24, so it needs no help reaching them — deliver directly out the named interface.
• The static route is a typed instruction: "to reach the 10.40.0.0/16 networks, hand packets to the neighbor router at 192.168.2.254" — evidently another router sits on LAN2 leading deeper into the building.
• The default route — 0.0.0.0/0, the match-everything prefix you decoded in Module 4 — is the router's own "anywhere else": everything unknown goes toward the ISP. Your host's default gateway line and this row are the same idea at different scales; routers have gateways of last resort too.
• The metric column is the map's cost figure — the number that ranks competing routes to the same destination (by hop count, bandwidth or a composite, depending on who filled the table). Lowest wins.

And one rule governs the whole table, the same one you met in the host's table: the most specific match wins. A packet for 192.168.2.77 matches both 192.168.2.0/24 and 0.0.0.0/0 — the /24 is more specific, so it is delivered locally, not shipped to the ISP. Longest prefix first, always.

Filling the map: static vs dynamic

Where do table rows come from? Connected routes write themselves. For everything else, two philosophies:

Static routing — a human types each route. Perfectly predictable, zero protocol chatter, nothing to misbehave — and utterly blind: if a link dies, the static route keeps pointing into the void until a human edits it. Static routing fits small and simple: a home (one route: everything → ISP), a branch office with a single way out, a lab like the one you will build shortly. The default route to an ISP is the most common static route on Earth.

Dynamic routing — routers run a routing protocol and tell each other what they can reach: "I can reach these networks, at these costs." Each router folds what it hears into its table, and — the decisive advantage — reacts to change: a link fails, the news spreads, tables update, traffic shifts to the next-best path, no human awake. The cost is complexity and trust: routers believe their neighbors, chatter consumes some bandwidth, and misconfiguration can propagate as efficiently as truth. Every network beyond a handful of routers runs dynamic routing; the Internet could not exist without it.

From the textbook to 2026: the protocol cast

The book's era debated which protocol suites could be routed at all; 2026 needs one paragraph of that history and a short, honest cast list for the rest. Awareness level throughout — recognize the names, place them, move on.

First, a distinction from the book worth preserving exactly, because the names confuse everyone: routable protocols versus routing protocols. A routable protocol is one whose addresses contain a network part — so routers can act on it. IP is routable (all of Module 4 was about its network part). A routing protocol is one routers use to fill their tables — it acts on routable traffic. One is cargo with an address; the other is the mapmakers' conversation. In the book's day the cargo question was live: IPX (NetWare's suite) was routable and everywhere; NetBEUI — a small LAN protocol of the era — famously had no network address, could never leave its own LAN, and died with that limitation. Today the cargo question is settled — IP won, IPv4 and IPv6 both — and only the mapmakers' side still has a cast:

Inside an organization (interior protocols — one administration, one "autonomous system"):

• OSPF (Open Shortest Path First) — the standard interior protocol, current, everywhere from mid-size businesses to carriers.
• IS-IS — its equally capable sibling, current, favored in large service-provider backbones.
• RIP (Routing Information Protocol) — the book's era's workhorse, now legacy. RIP judged every path by hop count alone and capped the world at 15 hops — anything farther was declared unreachable and the packet discarded. Dr. Al-Doori's course teaches the cap with a pun students never forget: a packet past its limit may rest in peace — RIP. Keep the mnemonic; retire the protocol. Its simplicity, charming in 2007, is disqualifying at modern scale, and the pun now fits the protocol itself: RIP rests in peace, worth knowing only so you recognize the name.
• EIGRP — one line, as promised: Cisco's own interior protocol, proprietary for decades, published openly in 2016 as RFC 7868 — an informational document, not an Internet standard; real in Cisco networks, absent elsewhere.

Between organizations (exterior — between autonomous systems, where no one administration is in charge):

• BGP-4 (Border Gateway Protocol) — the Internet's only exterior routing protocol, current and irreplaceable. Every ISP, cloud and large enterprise announces which address blocks it can reach, and BGP's conversations among tens of thousands of autonomous systems are the Internet's map. The book lists two exterior protocols, BGP and EGP; time has simplified the answer. EGP — an actual early protocol, not just a category name — is formally classified Historic, the standards world's way of saying retired with honors. The exterior answer in 2026 is exactly one name: BGP-4. (This lesson's video comes from people who speak it for a living.)

Two paragraphs of taxonomy complete the cast, because the book's classification survives as vocabulary. Distance-vector protocols (RIP's family) work by rumor: each router tells its neighbors its own table — "I can reach these networks, this far away" — and each neighbor adds a hop and passes it on. Nobody sees the map; everybody trusts the gossip; and with hop count as the only measure, a two-hop path over fast fiber loses to a one-hop path over a slow link. Simple, chatty, gullible — and prone, in its pure form, to loops the protocol then needs tricks to escape.

Link-state protocols (OSPF, IS-IS) work by cartography: each router describes only its own links — who am I connected to, at what cost — and those descriptions are flooded to every router in the same area, so each of them assembles the complete map of that area (large networks split into several areas and summarize between them, so the shared map is per-area rather than network-wide) and computes its own best paths over real costs like bandwidth. More memory, more math, far better decisions, loop-resistant by construction: this is why link-state runs today's interiors. (BGP fits neither family — it is a path-vector protocol, advertising whole AS-by-AS paths, with decisions driven as much by business policy as by distance. Recognizing that phrase is all this course asks.)

Watch: What is BGP? The Routing Protocol of the Internet Explained

Why this video earns its place. It comes from LINX — the London Internet Exchange, one of the world's largest interconnection points, where many hundreds of member networks meet to exchange traffic. BGP is what those members speak to each other across the exchange, which makes this the rare explainer produced by an institution for which the subject is daily operational reality.

Watch one segment, not the whole thing. Be clear about what this is: a full operator-level LINX session running an hour and forty minutes. Your assignment is the opening stretch — 1

to 12

— which covers exactly the awareness level this course intends: what BGP is, autonomous systems, BGP between autonomous systems, and who does and does not need it. That is roughly ten minutes.

Everything after 12

— BGP messages, neighbour states, attributes, communities, timers, the decision process — is genuine operator material and entirely optional. It is there if this subject grabs you, and skipping it costs you nothing in this course. Interior routing, not BGP, is where a beginner's effort belongs.

In the assigned segment, notice:

• The Internet presented as it really is: not one network but many independent ones — autonomous systems — agreeing to exchange reachability. Our exterior-protocol paragraphs, from the operator's mouth.
• Routes being announced and learned between neighboring networks — the mapmakers' conversation, at the scale where no single administration is in charge.
• Why networks choose paths for reasons beyond distance — relationships and policy between organizations — the flavor that separates BGP from every interior protocol you met.
• The exchange-point setting itself: LINX naturally explains BGP through peering at an exchange, one lens among several — inside organizations, remember, OSPF and IS-IS do the mapmaking, and much BGP also runs over private links between providers.
• Numbers with a shelf life: any member counts, route totals or traffic figures quoted reflect the video's production date and grow stale quickly — treat the mechanics as the durable content. And the video stays introductory by design: how BGP is secured against false announcements (a real 2026 concern) is beyond both its scope and this course's — awareness that the problem exists is enough today.

The video reinforces visually what you just learned — the lesson is complete without it.

Lab: Packet Tracer #3 — Two Networks, One Router · Then Read a Real Traceroute

Two parts, one arc: first you build routing in the simulator — two networks that cannot talk until your router connects them — then you read routing in the wild, tracing a real path across the Internet and interpreting every hop.

Objective. Configure a router joining two networks, verify cross-network delivery, and interpret a real traceroute hop by hop.

Setup. Packet Tracer installed (the Module 3 device lab covers the free download via Cisco Networking Academy). Any real computer with Internet access for Part B. Start Packet Tracer with a new blank file.

Part A — build the routed network.

1. Place devices: one 1941 router, two 2960 switches, and three PCs — PC0 and PC1 on the left, PC2 on the right.

2. Cable with Copper Straight-Through: PC0 → Switch0 port Fa0/1, PC1 → Switch0 Fa0/2, PC2 → Switch1 Fa0/1. Then the highways: Switch0 Fa0/24 → Router GigabitEthernet0/0, and Switch1 Fa0/24 → Router GigabitEthernet0/1. Wait out the amber lights (you know what they are since Module 3).

3. Plan before configuring — the professional habit. Left network: 192.168.1.0/24, router's interface .1. Right network: 192.168.2.0/24, router's interface .1. Two networks, two towns; the router will stand at the edge of both.

4. Configure the router's left interface: click the router → Config tab → GigabitEthernet0/0: set IP address 192.168.1.1, subnet mask 255.255.255.0, and tick Port Status → On (router ports start switched off — a router forwards nothing it isn't explicitly told to). The link lights to Switch0 turn green.

5. Configure the right interface the same way: GigabitEthernet0/1 → 192.168.2.1, mask 255.255.255.0, Port Status On.

6. Address the PCs (Desktop tab → IP Configuration, as in every lab since Module 3) — and this time fill in the Default Gateway field, the star of Module 4's gateway lesson: PC0 → 192.168.1.10, mask 255.255.255.0, gateway 192.168.1.1 · PC1 → 192.168.1.11, same mask, same gateway · PC2 → 192.168.2.10, mask 255.255.255.0, gateway 192.168.2.1. Each machine's gateway is its own town's router door — a wrong-side gateway is this lab's classic planted error, and you will diagnose it in the questions.

7. Baseline, local: from PC0's Command Prompt, ping 192.168.1.11 (PC1). Same network — the switch alone delivers; the router is a bystander.

8. The moment of truth, remote: from PC0, ping 192.168.2.10 (PC2). Success — and be forgiving of a first lost reply while ARP warms up (Module 4 habits). Two networks are talking through your router.

9. See the machinery: switch to Simulation mode, filter to ICMP, and repeat the remote ping stepping packet by packet. Watch the journey — PC0 → Switch0 → Router → Switch1 → PC2 — and click the packet at the router stage: the In Layers / Out Layers panel shows the frame being stripped and rebuilt (new MACs for the new link) around the unchanged IP packet. Module 2's promise — frames hop, packets travel — visible in the machine.

10. Ask the router for its map: click the router → CLI tab, press Enter, type enable, then:

    codeCopy

    show ip route
    

    Amid the report you will find two lines flagged C (connected) — 192.168.1.0/24 and 192.168.2.0/24, each tied to its Gigabit interface. Your router wrote its own first two table rows the moment you switched the ports on — connected routes, exactly as the anatomy section said. No static routes, no protocols: with only two networks, both directly connected, the map is already complete.

11. Save as m5-pt3 — the capstone reuses this pattern at full scale.

Part B — read a real path.

12. On your real computer, open a terminal and trace the route to a distant site — ideally one on another continent (a foreign university's website works well):

    • Windows: tracert example.com
    • Linux/macOS: traceroute example.com

13. Watch the rows appear, one per hop, three time measurements each. An authored example of the shape (yours will differ):

    codeCopy

    Tracing route to example.com [96.7.128.175]
    over a maximum of 30 hops
    
      1     2 ms     1 ms     2 ms   192.168.10.1
      2    12 ms    11 ms    12 ms   100.64.12.1
      3    14 ms    13 ms    15 ms   81.52.187.33
      4    18 ms    17 ms    19 ms   core7.example-isp.net [81.52.190.7]
      5     *        *        *      Request timed out
      6    24 ms    23 ms    24 ms   96.7.128.175
    
    Trace complete
    

14. Interpret, row by row — this is the reading skill:

    • Hop 1 — a private address you recognize instantly: your own router. Every journey starts at the default gateway.
    • Hop 2 — in this example, an address from 100.64.0.0/10: the CGNAT range from Module 4's NAT lesson, live in the wild — you are inside the ISP's translated zone. (Yours may show an ordinary public address instead.)
    • Hops 3–4 — the ISP's backbone; when names appear, they often hint at role and place (a name like core7.example-isp.net is a core router announcing itself).
    • Hop 5 — three asterisks, and here is the professional reading: not a failure. This router forwarded the packet perfectly well but declined to send the "time exceeded" report (many are configured to deprioritize or drop such replies). The proof it forwarded: hop 6 answered. Asterisks mid-path with later hops answering mean a shy router; asterisks from some point onward, forever, mean the trail truly went cold there.
    • Hop 6 — the destination replies: journey mapped.

15. Now connect the tool to the mechanism, because it is this lesson's TTL safeguard used backwards — the book's Chapter 10 explains the trick with an image worth retelling: asking directions from someone who has made the trip, and writing down each turn they recount. The command sends probes with TTL=1 (the first router's decrement kills it — its ICMP "time exceeded" reveals hop 1), then TTL=2 (revealing hop 2), and so on until the destination itself answers. Each "turn" in the printout is one router confessing its existence. The path was always there; traceroute makes it tell you about itself.

Expected result. Part A: local and cross-network pings succeed; show ip route shows two connected routes; the simulation shows re-framing at the router. Part B: a hop-by-hop listing you can narrate from your own chair to a distant network, asterisks included.

Verify. You can answer, from evidence on your screen: which device made cross-network delivery possible (disconnect a router cable and the remote ping dies — reconnect it); which rows of the router's table wrote themselves; and, for your real trace, where your home ends, where your ISP begins, and which hops declined to report.

Questions.

1. In Part A, what exactly would break if PC2's gateway were mistyped as 192.168.1.1 — and, subtly, what would the symptom be at PC0 when it pings PC2?
2. Your router's table has no 0.0.0.0/0 row, yet all pings in the lab work. Why is a default route unnecessary here — and what first event would create the need?
3. In your real traceroute, hop 5 shows asterisks but hops 6 and beyond answer normally. A colleague declares "hop 5's router is down." Correct them with the reasoning from step 14.
4. Traceroute to a site shows 22 hops. How many routers did your packet cross, and why is TTL the reason you can know?

(Answers: 1 — PC2 would hold a gateway address from the wrong network, unreachable from its own LAN; outbound remote replies could never leave. The symptom at PC0: its pings arrive at PC2 — the router delivers them fine — but every reply dies at PC2's broken gateway, so PC0 sees timeouts. One-way delivery with a healthy network in between: the classic wrong-gateway signature. 2 — every existing destination in the topology is directly connected, so the table is complete; the moment a third network appears (say, a link to the Internet or another router), packets for it would match nothing and be dropped — the event that demands a static or default route. 3 — a down router at hop 5 would end the trace: nothing beyond it could ever answer. Later hops answering proves hop 5 forwards traffic; it merely declines to send TTL-expiry reports — a shy router, not a dead one. 4 — 21 routers, plus the destination on the final line. Each of the first 21 lines is a router that discarded a probe when its TTL hit zero and confessed with an ICMP time-exceeded message; the last line is the destination itself, which does not discard the probe but answers it directly, so the count is exact by construction.)

If it goes wrong.

• Part A: remote ping fails but local works. Check the three usual suspects in order: both router interfaces show Port Status On (the top omission); each PC's gateway is its own side's router address; masks read 255.255.255.0 everywhere. show ip route confirms both C-routes exist — if one is missing, its interface is down or unaddressed.
• Part A: even the local ping fails. Recable check: PCs to their own side's switch, straight-through throughout — and give the amber lights their half minute.
• Part B: the first hop already shows asterisks. Some home routers don't send TTL-expiry reports; later hops will still appear. On Windows, add -d (tracert -d ...) to skip name lookups if the trace crawls — names are cosmetic to the exercise.
• Part B: the trace never completes, asterisks to the end. The destination or its network filters the probes (increasingly common). Try another distant site; the interpretation skill transfers unchanged.
• Your Linux traceroute shows very different hops from a friend's Windows tracert to the same site. Real and instructive: the tools probe differently (and paths genuinely differ across directions and moments — hop-by-hop routing at work). Compare the shape of the story, not row by row.

Reset/cleanup. Packet Tracer: save and close; nothing real was touched. Real machine: traceroute changed nothing. Keep m5-pt3 and your annotated trace — both are rehearsals for the capstone's build and documentation phases.

Check yourself

1. A packet for 172.20.9.14 arrives at a router whose table holds: 172.20.0.0/16 via next hop A · 172.20.9.0/24 via next hop B · 0.0.0.0/0 via next hop C. Which next hop wins, and by what rule?
2. A packet arrives for a network the router's table does not contain at all, and there is no default route. State what the router does, contrast it with what a switch does when it is ignorant, and name the message the sender receives.
3. A five-site company connected in a ring of routers currently uses static routes everywhere; each link failure requires an engineer to retype routes at multiple sites. Make the case for dynamic routing in two sentences, and name the two standard interior protocols they would shortlist.
4. Sort the cast into the correct bins — current interior · current exterior · legacy/historic: BGP-4 · RIP · OSPF · EGP · IS-IS. Where does EIGRP fit, in one sentence?
5. A colleague studying from an older book says: "NetBEUI was a routing protocol that failed." Give the two-part correction using the routable-versus-routing distinction.
6. In a traceroute, hops 1–8 answer with rising times, and from hop 9 onward every row is asterisks with no final answer. Contrast this with the mid-path asterisks of the lab, and say where you would focus the investigation.

Answers

1. Next hop B — longest prefix (most specific match) wins: /24 beats /16 beats /0, regardless of the order the table lists them.
2. The router drops the packet — routers refuse when ignorant, they never flood — and returns an ICMP "destination unreachable" to the sender. A switch in the same position floods the frame out every port; the opposite instinct, safe only inside one network.
3. With dynamic routing the routers themselves announce reachability and reroute around a failed link in seconds, unattended — turning every outage from a multi-site manual edit into a non-event. Shortlist: OSPF and IS-IS, the standard link-state interior protocols.
4. Current interior: OSPF, IS-IS. Current exterior: BGP-4 — the only one. Legacy/historic: RIP (legacy — the 15-hop world is over) and EGP (formally Historic). EIGRP is Cisco's own interior protocol, openly documented as informational RFC 7868 but not an Internet standard — real in Cisco shops, absent elsewhere.
5. NetBEUI was not a routing protocol at all — it was cargo, a LAN protocol suite. And it was not even routable cargo: its addresses contained no network part, so no router could ever forward it beyond its own LAN — the limitation that killed it. (Routing protocols are the mapmakers' conversation; NetBEUI never qualified for either role.)
6. The lab's mid-path asterisks were a shy router — proven forwarding because later hops answered. Here nothing past hop 8 ever answers: the trail goes cold, meaning packets stop being forwarded (or all reports beyond that boundary are filtered) — investigate at and beyond hop 9: the boundary between hop 8's network and whatever lies next, not your own side, which demonstrably works for eight hops.

Key terms

• Router — the device that connects networks and forwards packets between them by consulting a routing table; refuses (drops) when it has no route.
• Hop — one router-to-router (or host-to-router) leg of a journey; hop-by-hop forwarding — each router independently choosing only the next leg.
• Routing table — the router's map: destination networks, next hops, interfaces, metrics, and how each row was learned.
• Connected / static / dynamic routes — rows written automatically for attached networks · typed by a human · learned from a routing protocol.
• Default route (0.0.0.0/0) — the router's "anywhere else" rule; match of last resort.
• Longest prefix match — the most specific route always wins.
• Metric — the cost figure ranking competing routes; lowest wins.
• Routable vs routing protocol — cargo whose addresses have a network part (IP) vs the mapmakers' protocols that fill tables (OSPF, BGP...).
• Interior vs exterior protocols — mapmaking inside one autonomous system (OSPF, IS-IS) vs between autonomous systems (BGP-4, the only one).
• RIP — legacy distance-vector interior protocol; hop-count metric, 15-hop limit — remembered by its rest-in-peace pun, retired in practice.
• Distance-vector / link-state / path-vector — routing by neighbors' rumors · by a flooded map each router computes over · by whole-path announcements with policy (BGP).
• Autonomous system (AS) — one administration's network as the Internet sees it; the unit BGP connects.
• traceroute / tracert — the tool that maps a path by sending probes of increasing TTL and collecting each router's expiry report.

Summary

• Routing is the map-and-roads problem: networks are towns, links are highways, and the router's whole job is choosing the best next road — one hop at a time, each router deciding independently, TTL guarding against endless circles.
• The routing table is the map: connected routes write themselves, static routes are typed, dynamic routes are learned; longest prefix wins, metrics break ties, and no-match means drop plus an ICMP notice — routers refuse where switches flood.
• Static routing fits the small and stable; dynamic routing reacts to failure unattended and runs everything beyond a few routers.
• The 2026 cast at awareness level: OSPF and IS-IS inside organizations (link-state — everyone computes over a shared map); BGP-4 between them — the Internet's only exterior protocol, path-vector, policy-driven; RIP is legacy (its rest-in-peace mnemonic outliving it), EGP formally Historic, EIGRP Cisco's own (RFC 7868, informational).
• The routable-vs-routing distinction survives the era that needed it: IP is the cargo, routing protocols are the mapmakers; NetBEUI (unroutable) and IPX (routable, defeated) are one-line history.
• You built a routed internetwork — two networks, connected routes, cross-network pings, re-framing watched packet by packet — and read a real traceroute like a professional, shy routers and all.

Next lesson

Module 5 completes the wired story: addressed machines, named services, leased configurations, routed packets. Module 6 cuts the cord — how radio carries frames through the air, why Wi-Fi needs different rules than cable, and what those antenna symbols on your router actually do.

Sources and further study

• Al-Doori, T., Network Essentials, Chapters 6 and 10 — the map analogy, the hop-by-hop walk-through, routable-vs-routing, and the traceroute craft this lesson retells.
• RFC 4271, "A Border Gateway Protocol 4 (BGP-4)" — https://www.rfc-editor.org/info/rfc4271/ — the protocol holding the Internet's map together.
• RFC 7868, "Cisco's Enhanced Interior Gateway Routing Protocol (EIGRP)" — https://www.rfc-editor.org/info/rfc7868/ — the informational publication of Cisco's interior protocol.
• RFC 904, "Exterior Gateway Protocol Formal Specification" — https://www.rfc-editor.org/info/rfc904/ — EGP, preserved in the archive with Historic status; the retired half of the book's exterior pair.
• Cloudflare Learning Center, "What is BGP?" — https://www.cloudflare.com/learning/security/glossary/what-is-bgp/ — a maintained plain-language companion to the video, including the security concerns both leave out.
• LINX, "Learn with LINX" — https://www.linx.net/resources/learn-with-linx/ — the video producer's written glossary and explainers on BGP and peering.
• Download: OSI and TCP/IP Model Reference (routing is the internet layer earning its name — keep the map at hand into Module 6).