3 History of the Internet: From ARPANET to IoT
The People, Packets, and Protocols That Connected the World
fundamentals
history
of
internet
3.1 In 60 Seconds
The Internet did not appear as one invention. It grew from packet-switching research, ARPANET experiments, the TCP/IP split, DNS naming, the World Wide Web, and later mobile, cloud, and IoT protocols. The same choices that made a few research computers interoperate–open standards, layered protocols, fault-tolerant routing, and simple packet forwarding–still explain why constrained IoT devices can talk to cloud services today.
3.2 Start With the Story
Start with one deployed device that needs a sensor, firmware, a gateway, a network, a cloud service, an operator, and someone accountable when it fails. The core idea in History of the Internet: From ARPANET to IoT is simple: IoT is an ecosystem, so the useful question is not only what the device does, but who depends on each layer and how the layers stay interoperable. This page focuses that idea on Traces packet switching, ARPANET, TCP/IP, DNS, the Web, mobile/cloud growth, and open protocol choices that made IoT possible. In everyday IoT, maintenance plans, standards choices, data ownership, and lifecycle duties decide whether a pilot survives contact with the field. Start simple: name the actors, name the handoffs, and then add historical or governance detail where the handoff needs evidence.
Chapter Roadmap
This chapter follows the Internet as an engineering chain, not a list of dates:
- First we ask why survivable communication pushed researchers toward packet switching.
- Then we watch ARPANET prove the idea with four original nodes and a first “LO” message.
- Next we follow TCP/IP, DNS, and the Web as separate layers that made the network usable at scale.
- Finally we connect mobile, cloud, and IoT protocols back to the same open, layered design choices.
Checkpoints recap what you have covered, and collapsed calculations or deep dives are optional on a first read.
3.3 Learning Objectives
By the end of this chapter, you will be able to:
- Trace the Internet’s origin: Explain how ARPANET evolved from a Cold War research project into the global Internet
- Identify key pioneers: Describe the contributions of Vint Cerf, Bob Kahn, Tim Berners-Lee, and other Internet architects
- Compare switching paradigms: Differentiate packet switching from circuit switching and explain why packet switching was revolutionary for network resilience
- Map the timeline: Place key Internet milestones in chronological order from the 1960s to the present
- Connect history to IoT: Explain how each era of networking evolution–from ARPANET to TCP/IP to the Web–enabled today’s Internet of Things
- Evaluate architectural decisions: Assess how early design choices (open standards, layered protocols, end-to-end principle) shaped the modern IoT ecosystem
3.4 What To Watch For
- Packet switching: Messages are split into packets that share links and can route around failures.
- Layering: Link, internet, transport, and application responsibilities stay separate so each layer can evolve.
- Open standards: RFCs, freely usable protocols, and interoperable implementations let independent systems connect.
- The end-to-end principle: The network core forwards packets while reliability, identity, encryption, and application meaning mostly live at the endpoints.
- IoT consequence: MQTT, CoAP, 6LoWPAN, Thread, Matter, and cloud gateways build on those older Internet design choices rather than replacing them.
3.5 Minimum Viable Understanding
If you only have 5 minutes:
- 1969: ARPANET sends first message between UCLA and Stanford Research Institute — the first two “nodes” on what would become the Internet. The message was “LOGIN” but the system crashed after “LO”
- 1974: Vint Cerf and Bob Kahn publish the TCP/IP paper that defines how all Internet communication works — still in use today, 50+ years later
- 1983: January 1st–“Flag Day”–ARPANET switches from NCP to TCP/IP. This is the true “birthday” of the Internet
- 1991: Tim Berners-Lee launches the World Wide Web at CERN, making the Internet accessible to everyone
- 1999: Kevin Ashton coins the term “Internet of Things,” imagining a world where physical objects connect to the Internet
For Beginners: Why the Internet’s History Matters
Imagine you turn on a smart light bulb with your phone. That simple action uses ideas invented by dozens of brilliant people over 50 years:
- The packet that carries your command was shaped by packet-switching work from Paul Baran, Donald Davies, Leonard Kleinrock, and others in the 1960s
- The TCP/IP protocol that routes it was designed by Vint Cerf and Bob Kahn in the 1970s
- The web interface you tap was created by Tim Berners-Lee in the 1990s
- The wireless connection uses standards refined over decades
Every IoT device stands on those design choices. Understanding the story helps you understand why the Internet works the way it does, not just how to configure it.
Sensor Squad: The Amazing Story of How Computers Learned to Talk!
Sammy the Sensor says: “Hey Sensor Squad! Did you know the Internet started with just FOUR computers? And the very first message ever sent was supposed to be ‘LOGIN’ but the computer CRASHED after only two letters — ‘LO’! So the first Internet message was accidentally ‘LO’ — like ‘Lo and behold!’ Pretty funny, right?”
Lila the Light Sensor adds: “The people who built the Internet were really young! Vint Cerf was only 26 when he started working on ARPANET, and the team that sent that first message included a graduate student named Charley Kline who was just 21!”
Max the Motion Sensor explains: “Before the Internet, if you wanted to call someone, the phone company had to connect a WHOLE wire just for your call — like building a private road every time you wanted to visit a friend. Then a clever engineer named Paul Baran had an idea: what if we cut messages into tiny pieces (packets) and let them find their OWN way through the network? It’s like sending a puzzle — each piece takes a different road, and they all meet up at the destination and put themselves back together!”
Bella the Buzzer chimes in: “And now, 55 years later, there are more devices connected to the Internet than there are people on Earth! From those 4 computers to over 15 BILLION connected things. That’s what happens when really smart people share really great ideas!”
3.6 Prerequisites
No prior networking knowledge is required. This chapter tells the story chronologically and explains each concept as it appears. If you want to dive deeper into networking after reading this, see OSI and TCP/IP Models.
3.7 The Cold War Seeds (1957-1965)
The Internet wasn’t built to share cat videos — it was born from fear. When the Soviet Union launched Sputnik in 1957, the United States realized it was falling behind in science and technology. President Eisenhower responded by creating ARPA (Advanced Research Projects Agency) in 1958 — a small government agency tasked with making sure America would never be surprised by technological achievement again.
ARPA had an unusual approach: instead of building things itself, it funded brilliant researchers at universities and gave them freedom to explore radical ideas. This culture of open research and collaboration would become the DNA of the Internet itself.
3.7.1 The Problem of Survivable Communication
In the early 1960s, military planners faced a terrifying question: how do you maintain communication after a nuclear attack? The existing telephone system was centralized — if a few key switching centers were destroyed, the entire network could collapse.
Those switching centers were physical places, not just boxes in a diagram. A map of central-office sites shows how dense the public telephone network had become in cities and suburbs, while long-distance trunk maps show high-capacity routes concentrating traffic between regions. Packet switching did not merely replace a voice call with a data packet; it changed the geography of resilience. The design goal shifted from holding one reserved path through specific offices to letting many packets use available links and route around damaged or congested parts of the network.
Three researchers, working independently on three continents, arrived at the same revolutionary idea:
| Pioneer | Location | Year | Contribution |
|---|---|---|---|
| Paul Baran | RAND Corporation, USA | 1962 | Designed “distributed adaptive message block switching” — breaking messages into blocks that could route around damage |
| Donald Davies | National Physical Laboratory, UK | 1965 | Independently invented “packet switching” — the term we still use today |
| Leonard Kleinrock | MIT/UCLA, USA | 1961 | Published the first paper on queuing theory for packet networks — the mathematical foundation |
Putting Numbers to It
Baran’s insight was quantitative. He calculated that a distributed network with each node connected to just 3-4 neighbors could survive the destruction of up to 50% of its nodes and still maintain connectivity. The probability of a message getting through a distributed network with \(n\) independent paths is:
\[P(\text{delivery}) = 1 - \prod_{i=1}^{n} (1 - p_i)\]
With 3 redundant paths each having 90% reliability: \(P = 1 - (0.1)^3 = 99.9\%\). This was dramatically better than the centralized telephone network’s single point of failure.
Interactive Network Reliability Calculator: Explore how redundant paths improve reliability:
3.7.2 Circuit Switching vs Packet Switching
The telephone network used circuit switching — when you made a call, a dedicated physical circuit was established from your phone to the other person’s phone. This circuit was yours alone for the entire call, even during silences.
Packet switching was radically different:
- Break the message into small packets (typically 1,000-1,500 bytes each)
- Each packet travels independently — it can take any available route
- Packets are reassembled at the destination — the receiver puts them back in order
- The network is shared — many conversations use the same wires simultaneously
This is like the difference between hiring a private taxi (circuit switching) versus using a postal service (packet switching). The postal service is far more efficient because one mail truck carries hundreds of letters simultaneously.
Checkpoint: Packet Switching
You now know:
- The survivability problem was about avoiding a few centralized telephone switching centers.
- Packet switching breaks a message into independently routed packets, typically 1,000-1,500 bytes each.
- Baran’s quantitative example shows why redundancy matters: with 3 paths at 90% reliability, delivery rises to 99.9%.
3.8 ARPANET: The First Internet (1969-1983)
3.8.1 The First Message
On October 29, 1969, at 10:30 PM, a 21-year-old UCLA graduate student named Charley Kline sat at an SDS Sigma 7 computer and attempted to log in to a computer at Stanford Research Institute (SRI), 350 miles away. He typed “L”… then “O”… then “G”… and the system crashed.
The first message ever sent over ARPANET was “LO” — an accidental abbreviation that would be poetic only in hindsight. An hour later, they tried again and successfully transmitted “LOGIN.”
The four original ARPANET nodes were:
| Node | Institution | IMP Number | Connected |
|---|---|---|---|
| 1 | UCLA | IMP #1 | September 2, 1969 |
| 2 | Stanford Research Institute (SRI) | IMP #2 | October 1, 1969 |
| 3 | UC Santa Barbara | IMP #3 | November 1, 1969 |
| 4 | University of Utah | IMP #4 | December 1, 1969 |
The “IMP” (Interface Message Processor) was the ancestor of today’s router — a Honeywell DDP-516 minicomputer that weighed 900 pounds and cost $82,200 (about $680,000 in today’s money).
3.8.2 Growing the Network
ARPANET grew steadily through the 1970s:
- 1970: ALOHAnet in Hawaii pioneers wireless packet networking (ancestor of WiFi)
- 1971: Ray Tomlinson sends the first email and picks “@” to separate user from machine
- 1972: ARPANET demonstrated publicly at ICCC conference — 40 machines connected
- 1973: First international connections — University College London (UK) and NORSAR (Norwegian Seismic Array, Norway)
- 1974: Vint Cerf and Bob Kahn publish “A Protocol for Packet Network Intercommunication” — the TCP paper
That growth is easier to understand as a map than as a slogan. In December 1969, ARPANET was a four-node western U.S. experiment linking UCLA, SRI, UC Santa Barbara, and the University of Utah. By the mid-1970s, the map had spread across research sites, military labs, and international links. Later host-count curves make the same point on a log scale: the Internet grew by orders of magnitude because new hosts could join a shared packet network without redesigning the whole system around each pair of endpoints.
3.8.3 The Fathers of the Internet: Cerf and Kahn
Vint Cerf and Bob Kahn are often called the “Fathers of the Internet” for their 1974 paper defining TCP (Transmission Control Protocol). Their key insight was creating a universal protocol that could connect different types of networks — ARPANET, radio networks, satellite networks — into one seamless “inter-network” (which became shortened to “Internet”).
Their original TCP combined what we now know as TCP and IP into a single protocol. In 1978, they split it into two layers:
- IP (Internet Protocol): Handles addressing and routing — getting packets to the right destination
- TCP (Transmission Control Protocol): Handles reliability — making sure all packets arrive and are in order
This split was crucial. It meant that different applications could choose different transport protocols. Today, IoT devices often use UDP (User Datagram Protocol) instead of TCP because UDP is lighter weight — a choice made possible by this architectural decision from 1978.
Putting Numbers to It
The original TCP/IP design had to work with the constraints of 1970s hardware. An ARPANET IMP had just 12KB of memory — less than a single modern IoT sensor’s buffer. The maximum packet size was 1,008 bits (126 bytes). Today, a standard Ethernet frame carries 1,500 bytes — nearly 12x more data. Yet the fundamental protocol design from 1974 still works, scaling from kilobits to terabits per second. That’s a throughput increase of \(10^9\) (one billion times) without changing the core protocol.
3.9 The Internet Is Born (1983-1990)
3.9.1 Flag Day: January 1, 1983
The true birthday of the Internet is January 1, 1983 — “Flag Day” — when every machine on ARPANET simultaneously switched from the old NCP (Network Control Protocol) to TCP/IP. There was no gradual migration. At midnight, NCP stopped working and TCP/IP was the only option.
This was a massive coordinated effort. Every host on the network had to be ready. Buttons reading “I have TCP/IP — ask me how” were distributed at networking conferences. The transition went remarkably smoothly.
Quick Check: Test your understanding of the Internet’s “birthday”:
3.9.2 Domain Name System (1983-1984)
Before DNS, you had to know a computer’s numerical IP address to reach it. Paul Mockapetris invented the Domain Name System in 1983, allowing human-readable names like “usc.edu” instead of “128.125.253.136.”
For IoT deployments, DNS is not just a convenience. Resolver choice, cache TTLs, CNAME chains, and failover records determine how quickly devices recover when cloud endpoints move or regional services fail. A resilient design records which names the device resolves, how long it caches answers, what happens when DNS returns NXDOMAIN, and whether provisioning can update endpoint names without reflashing firmware.
The original top-level domains were:
| Domain | Purpose | Year |
|---|---|---|
| .com | Commercial | 1985 |
| .edu | Educational | 1985 |
| .gov | Government | 1985 |
| .mil | Military | 1985 |
| .org | Organizations | 1985 |
| .net | Network providers | 1985 |
The first .com domain ever registered was symbolics.com on March 15, 1985.
3.9.3 Key Developments
- 1983: BSD Unix includes TCP/IP — making it free and widely available
- 1984: ARPANET splits into ARPANET (research) and MILNET (military)
- 1986: NSFNET backbone created — connecting 5 supercomputing centers at 56 Kbps
- 1988: The Morris Worm — first major Internet security incident, infecting ~6,000 of the 60,000 connected computers
- 1989: Tim Berners-Lee proposes the World Wide Web at CERN
Checkpoint: TCP/IP and DNS
You now know:
- January 1, 1983 matters because ARPANET switched from NCP to TCP/IP in one coordinated Flag Day.
- DNS changed numeric addressing into names such as
usc.edu, while IoT deployments still need to plan cache TTLs and failover names. - The Internet became practical because BSD Unix, NSFNET, and open protocols let more hosts join without redesigning every application.
3.10 The World Wide Web (1991-1999)
3.10.1 Tim Berners-Lee’s Gift to Humanity
Tim Berners-Lee, a British scientist at CERN (the European particle physics laboratory), was frustrated that researchers couldn’t easily share documents across different computer systems. In 1989, he proposed a system combining three ideas:
- HTML (HyperText Markup Language) — a way to format documents
- HTTP (HyperText Transfer Protocol) — a way to request and send documents
- URLs (Uniform Resource Locators) — a way to address any document on any server
On August 6, 1991, he published the first website at CERN: http://info.cern.ch. Crucially, Berners-Lee and CERN made the technology free for everyone. They could have patented it and charged licensing fees, but they chose to give it away. This single decision — perhaps more than any technical achievement — is why the Web became universal.
3.10.2 The Browser Wars and Explosive Growth
- 1993: Marc Andreessen releases Mosaic — the first graphical web browser. Downloads increase 341,000% in one year
- 1994: Andreessen co-founds Netscape. Amazon and Yahoo are founded
- 1995: JavaScript created by Brendan Eich in 10 days. Internet Explorer launched. eBay founded
- 1996: Larry Page and Sergey Brin begin the BackRub project at Stanford (later renamed Google)
- 1998: Google incorporated. RFC 2616 defines HTTP/1.1 (still widely used)
- 1999: Kevin Ashton coins “Internet of Things” in a presentation at Procter & Gamble
Putting Numbers to It
The growth of the Web was unlike anything before:
| Year | Websites | Internet Users | Growth Rate |
|---|---|---|---|
| 1991 | 1 | ~4 million | — |
| 1993 | 130 | ~14 million | 130x sites |
| 1995 | 23,500 | ~40 million | 180x sites |
| 1997 | 1 million | ~120 million | 43x sites |
| 2000 | 17 million | ~413 million | 17x sites |
From 1 website to 17 million in just 9 years — compound annual growth rate of approximately \(\text{CAGR} = \left(\frac{17{,}000{,}000}{1}\right)^{1/9} - 1 \approx 574\%\) per year.
Interactive CAGR Calculator: Try calculating compound annual growth rate for different Internet metrics:
Quick Check: Test your understanding of the World Wide Web:
3.11 The Mobile and Cloud Era (2000-2015)
3.11.1 From Desktop to Pocket
- 2001: Wikipedia launches — collaborative knowledge on the Internet
- 2003: Skype launches — VoIP goes mainstream
- 2004: Facebook launches. Web 2.0 emerges (user-generated content)
- 2007: Apple iPhone released — the smartphone revolution begins
- 2008: Android launched. GitHub founded. First Bitcoin paper published
- 2010: Instagram launches. iPad introduced. “Cloud computing” enters mainstream vocabulary
- 2013: Cisco estimates 10 billion devices connected to Internet
3.11.2 The Seeds of IoT
Several parallel developments in this era made IoT possible:
- Cheap sensors: MEMS accelerometers dropped from $5 to $0.50
- Low-power wireless: Bluetooth Low Energy (BLE) standardized in 2010
- Cloud platforms: AWS IoT (2015), Azure IoT Hub (2015), Google Cloud IoT (2017)
- IPv6: With \(2^{128}\) addresses (\(3.4 \times 10^{38}\)), every grain of sand on Earth could have its own IP address
3.12 The IoT Era (2015-Present)
3.12.1 Kevin Ashton’s Vision Realized
When Kevin Ashton coined “Internet of Things” in 1999, he was working on RFID supply chain tracking at Procter & Gamble. His insight was simple but profound: computers depend on humans to input data, but most of the real world isn’t in any database. If machines could sense the physical world directly, they could manage things far more efficiently.
Today, that vision is becoming reality:
| Metric | 2015 | 2020 | 2025 (projected) |
|---|---|---|---|
| Connected IoT devices | 3.8 billion | 11.7 billion | 27 billion |
| Global IoT spending | $698 billion | $749 billion | $1.1 trillion |
| Data generated daily | 2.5 exabytes | 40 exabytes | 463 exabytes |
3.12.2 The People Behind IoT Protocols
The IoT revolution built on protocols designed by dedicated engineers:
| Protocol | Creator(s) | Year | Key Innovation |
|---|---|---|---|
| MQTT | Andy Stanford-Clark (IBM), Arlen Nipper | 1999 | Publish-subscribe for unreliable networks |
| CoAP | Zach Shelby, Carsten Bormann (IETF) | 2014 | REST for constrained devices |
| 6LoWPAN | Geoff Mulligan, Nandakishore Kushalnagar | 2007 | IPv6 over low-power wireless |
| LoRaWAN | Semtech, IBM Research | 2015 | Long-range, low-power wide-area |
| Matter | Google, Apple, Amazon, Samsung | 2022 | Universal smart home standard |
| Thread | ARM, Google/Nest, Samsung | 2014 | IPv6 mesh networking for IoT |
Checkpoint: Web to IoT
You now know:
- The Web is an application on top of the Internet, not the Internet itself.
- Web growth ran from 1 website in 1991 to 17 million in 2000, while IoT device counts grew from 3.8 billion in 2015 to 11.7 billion in 2020.
- MQTT, CoAP, 6LoWPAN, LoRaWAN, Matter, and Thread extend the older packet, layer, and open-standard pattern into constrained devices.
Quick Check: Test your understanding of Internet pioneers and their contributions:
3.13 Timeline: 55 Years of Networking
1957 ━━ Sputnik launched → ARPA created (1958)
1961 ━━ Kleinrock publishes packet network theory
1962 ━━ Baran designs distributed networks at RAND
1965 ━━ Davies coins "packet switching" at NPL
1969 ━━ ARPANET: first message "LO" (UCLA → SRI)
1971 ━━ Email invented by Tomlinson (@)
1973 ━━ First international ARPANET connections
1974 ━━ Cerf & Kahn publish TCP paper
1978 ━━ TCP split into TCP + IP
1983 ━━ "Flag Day" — TCP/IP becomes Internet standard
━━ DNS invented by Mockapetris
1985 ━━ First .com domain (symbolics.com)
1986 ━━ NSFNET backbone (56 Kbps)
1989 ━━ Berners-Lee proposes the World Wide Web
1991 ━━ First website goes live at CERN
1993 ━━ Mosaic browser — the Web goes graphical
1995 ━━ JavaScript, Internet Explorer, eBay
1998 ━━ Google incorporated
1999 ━━ Kevin Ashton coins "Internet of Things"
━━ MQTT protocol created at IBM
2004 ━━ Facebook launched
2007 ━━ iPhone released, 6LoWPAN standardized
2010 ━━ Bluetooth Low Energy standardized
2014 ━━ CoAP standardized (RFC 7252)
2015 ━━ LoRaWAN 1.0 released
2020 ━━ 11.7 billion IoT devices connected
2022 ━━ Matter 1.0 — universal smart home standard
2025 ━━ ~27 billion IoT devices projectedQuick Check: Place these Internet milestones in the correct chronological order:
3.14 The Unsung Heroes
Many crucial Internet pioneers rarely appear in popular histories:
- Radia Perlman — Invented the Spanning Tree Protocol (STP) that prevents network loops. Called “Mother of the Internet”
- Elizabeth Feinler — Ran the ARPANET Network Information Center, managing the naming system before DNS
- Bob Metcalfe — Invented Ethernet at Xerox PARC in 1973, connecting devices over local networks
- Jon Postel — Managed Internet Assigned Numbers Authority (IANA) for decades, edited most early Internet standards (RFCs)
- Steve Crocker — Wrote the first RFC (Request for Comments) in 1969, establishing the Internet’s open standards culture
- Geoff Huston — Pioneered Internet governance and routing analysis
How It Works: From ARPANET’s First Packet to Your IoT Sensor
The big picture: When your IoT temperature sensor sends a reading today, it follows the SAME fundamental process invented in 1969 — just billions of times faster.
Step-by-step breakdown:
- Your sensor generates data: A temperature reading of 23.5°C (just like Charley Kline typing “L-O-G-I-N”)
- TCP/IP wraps it in layers: Application data → TCP segment → IP packet → Ethernet frame (Cerf & Kahn’s 1974 design)
- DNS resolves the server name: “iot-server.example.com” → 93.184.216.34 (Mockapetris’s 1983 invention)
- Packets route through the Internet: Each packet finds its own path, just like Baran envisioned in 1962
- The server receives and processes: Using HTTP/MQTT/CoAP — protocols standing on 50+ years of evolution
Why this matters: The Internet wasn’t designed by one person or one company. It was built collaboratively by thousands of researchers who shared their work freely. That culture of openness — embodied in the RFC process started by Steve Crocker in 1969 — is why IoT protocols like MQTT and CoAP are also open standards that anyone can implement.
Concept Relationships: Internet History
| Concept | Relates To | Relationship |
|---|---|---|
| Packet switching | Circuit switching | Packet switching replaced circuit switching as the fundamental network paradigm |
| TCP/IP | OSI model | TCP/IP is the practical implementation that won over the theoretical OSI model |
| ARPANET | Internet | ARPANET was the prototype; the Internet emerged when TCP/IP connected multiple networks |
| World Wide Web | Internet | The Web runs ON the Internet — it’s an application, not the network itself |
| IoT protocols | TCP/IP | MQTT, CoAP, and 6LoWPAN are modern adaptations of the TCP/IP architecture for constrained devices |
Cross-module connection: The layered protocol architecture discussed here is formalized in OSI and TCP/IP Models. The constrained IPv6 adaptation used by many low-power networks is covered in IPv6 and 6LoWPAN.
3.15 See Also
- OSI and TCP/IP Models — Deep dive into the layered architecture Cerf and Kahn designed
- Systems Evolution to IoT — How computing economics enabled IoT
- IoT History and Paradigm Shifts — Lessons from technology adoption patterns
- MQTT Publish-Subscribe Basics — The lightweight IoT messaging pattern born from this history
- IPv6 and 6LoWPAN — Modern addressing and adaptation for constrained networks
Try It Yourself: Internet History Timeline
Time: ~10 minutes | Difficulty: Beginner | No hardware needed
Challenge: Create a personal “Internet history” timeline showing how networking technology has affected YOUR life.
Steps:
- List 5 Internet-enabled services you use daily (social media, streaming, smart home, etc.)
- For each one, trace it back to the historical innovation that made it possible (e.g., Netflix → Web → HTTP → TCP/IP → ARPANET)
- Calculate: How many of the 1969-1999 innovations from this chapter does each service depend on?
- Identify which service would STOP WORKING first if you removed innovations in reverse chronological order
Hint
Start with the most recent innovation (e.g., Matter/Thread for smart home) and trace backwards. You’ll find that ALL modern services ultimately depend on TCP/IP (1974) and packet switching (1962).
Solution
Every Internet-connected service depends on at least these 5 foundational innovations: 1. Packet switching (1962) — without it, no shared network 2. TCP/IP (1974/1978) — without it, no universal protocol 3. DNS (1983) — without it, you’d need to memorize IP addresses 4. HTTP/HTML (1991) — without it, no web interfaces 5. WiFi/cellular (various) — without it, no mobile access
Smart home devices additionally depend on MQTT (1999), BLE (2010), and IPv6 (1998).
3.16 Common Pitfalls
Pitfall 1: Treating the Web and the Internet as the Same Thing
The Web is an application that runs on the Internet. IoT systems often use Internet connectivity without using web pages at all; they may send MQTT, CoAP, DNS, NTP, or device-management traffic over the same packet network.
Pitfall 2: Assuming TCP/IP Was a Single Finished Invention
TCP/IP evolved through research, papers, implementation pressure, and operational cutover. The split between IP and TCP, the later use of UDP, and the growth of DNS all show why Internet architecture is best read as a set of design decisions, not a single launch event.
Pitfall 3: Copying Old Dates Without the Architecture Lesson
The important point is not only that ARPANET began in 1969 or that Flag Day happened in 1983. The engineering lesson is that open protocols, layered boundaries, packet forwarding, and interoperable implementations let independent networks become one Internet.
3.17 Check Your Understanding
3.18 Deep Dive: Packet Switching, Layers, and the IP Narrow Waist
The Internet that IoT rides on rests on two ARPANET-era ideas. The first is packet switching: instead of reserving a dedicated circuit, data is chopped into independently addressed packets that the network routes hop by hop, sharing links efficiently and rerouting around failures. The second is layering: the protocol stack is split into layers, each with one job, so they can evolve independently.
The TCP/IP model has four layers: link, internet, transport, and application. A sensor sending a reading and a browser loading a page use the same four layers; only the application protocol differs. Understanding that stack is the key to understanding every IoT protocol above it.
3.18.1 The Four Layers and Encapsulation
Each TCP/IP layer wraps the layer above it in its own header, a process called encapsulation:
| Layer | Job | Examples |
|---|---|---|
| Application | The actual message semantics | HTTP, MQTT, CoAP |
| Transport | End-to-end delivery and ports | TCP, UDP |
| Internet | Addressing and routing across networks | IP (IPv4/IPv6) |
| Link | Delivery over one physical hop | Ethernet, Wi-Fi, IEEE 802.15.4 |
A sensor sending {"temp":21.4} illustrates the process. The application layer defines that message; the transport layer, perhaps UDP, adds source and destination ports; the internet layer adds IP addresses so routers can forward it; the link layer adds a frame header for the next physical hop. At the receiver, the headers are peeled off in reverse.
Each layer reads only its own header. A router looks at the IP header and ignores the payload, which is why the network can carry protocols it has never heard of.
3.18.2 Why the Core Stays Simple
The Internet’s most consequential design choice is the end-to-end principle: keep the network core simple so it just forwards packets, and put intelligence such as reliability, ordering, encryption, and application meaning in the endpoints. A router does not track your whole conversation; TCP in your device handles retransmission. This is why anyone can invent a new application protocol without asking the network for permission.
The stack also has a famous narrow waist. Many link technologies sit below and many applications sit above, but everything meets at IP in the middle. Ethernet, Wi-Fi, cellular, and IEEE 802.15.4 can all carry IP, and HTTP, MQTT, CoAP, DNS, and many other protocols can all ride above it.
That narrow waist is what let IoT grow on the existing Internet. A constrained radio and a data-center server interoperate because both meet at IP, with technologies such as 6LoWPAN carrying IPv6 even over tiny 802.15.4 frames.
A CoAP-based sensor can talk to a cloud service written years earlier. Neither the routers between them nor the link technologies they use were designed for CoAP, yet it works because CoAP rides UDP, UDP rides IP, and the simple IP-forwarding core carries it unchanged. The end-to-end principle and the IP narrow waist are the reason IoT could be built on the existing Internet rather than on a separate network.
3.19 Summary
The Internet’s journey from 4 ARPANET nodes in 1969 to 27+ billion IoT devices today was shaped by key individuals, pivotal decisions, and a culture of open collaboration:
- Paul Baran, Donald Davies, and Leonard Kleinrock independently invented packet switching — the foundation of all Internet communication
- Vint Cerf and Bob Kahn designed TCP/IP — the universal protocol that connects everything
- Tim Berners-Lee created the World Wide Web and gave it away for free
- Kevin Ashton envisioned the Internet of Things — extending the Internet to physical objects
- The Internet’s open standards culture (RFCs, free protocols, shared specifications) is why IoT protocols like MQTT, CoAP, and LoRaWAN are freely available today
The most remarkable aspect of this history is that the fundamental architecture designed in the 1970s — packet switching, layered protocols, end-to-end design — still works perfectly for IoT devices that are millions of times more numerous and diverse than anything the original designers imagined.
3.20 What’s Next
Now that you can trace the Internet’s evolution from ARPANET to IoT, explore how these protocols work in modern systems:
| Topic | Chapter | Description |
|---|---|---|
| Protocol Architecture | OSI and TCP/IP Models | Examine the formal layered architecture that grew from Cerf and Kahn’s TCP/IP design |
| IoT Messaging | MQTT Publish-Subscribe Basics | Explore how publish-subscribe messaging evolved from IBM’s 1999 protocol for IoT |
| Systems Evolution | Systems Evolution to IoT | Trace how computing economics and miniaturization enabled the IoT revolution |
| IoT History | IoT History and Paradigm Shifts | Identify lessons from technology adoption patterns across Internet eras |
| IPv6 and 6LoWPAN | IPv6 and 6LoWPAN | Describe how modern addressing and adaptation support constrained devices |
3.21 Key Takeaway
The history of the Internet shows why layered design, open protocols, interoperability, and fault tolerance matter. IoT systems inherit those lessons when many vendors and networks must work together.