- Atlas
- Computer Science
- Network Protocols
Network Protocols
A network protocol is an agreed set of rules for how two or more machines exchange information: what a message looks like, who may send when, what a receiver must do with what arrives, and what happens when something goes wrong.
12 frameworks, from 1965 to today · Networks · Computer Science
- Packet switching 1965-Present
- Multiple access protocols 1970-Present
- Formal committee standardization 1978-1995
- Layered reference models 1978-Present
- End-to-end principle 1981-Present
- Distributed naming and addressing 1983-Present
- Request for Comments 1986-Present
- Request/response application protocols 1991-Present
- Transport Layer Security 1995-Present
- Constrained-device and IoT protocols 1999-Present
- Software-defined networking 2008-Present
- Low-latency transport 2013-Present
Overview
A network protocol is an agreed set of rules for how two or more machines exchange information: what a message looks like, who may send when, what a receiver must do with what arrives, and what happens when something goes wrong1. Protocols are the connective tissue of every network. They are also unusually social artifacts. A protocol only works if everyone adopts it, so its history is a history of committees, competing designs, and the slow, contested business of getting independent parties to agree. What is at stake is coordination without central control: how machines built by different people, owned by different organizations, and running on different hardware can nonetheless behave as one system.
Early packet switching and the problem of shared links
The foundational move was packet switching, developed in the 1960s. Instead of reserving a dedicated circuit for a conversation, packet switching chops data into small packets that share links and are forwarded independently. This raised an immediate protocol question: when many senders share one medium, who talks when? Early shared-medium designs answered with multiple access rules. ALOHA, built at the University of Hawaii in the late 1960s and early 1970s to link islands by radio, let stations transmit whenever they had data and retransmit after collisions—simple, and surprisingly workable at low load. Ethernet, developed at Xerox PARC in the early 1970s by Robert Metcalfe and colleagues, used carrier sense: listen before sending, and back off randomly when a collision occurs2. These shared-medium protocols established a durable pattern—distributed rules that let independent stations coordinate on a common channel without a central scheduler.
Layered reference models and the committee era
As networks multiplied, the problem became how to describe and connect them. The response was layering: dividing communication into levels, each offering services to the one above and relying on the one below. The International Organization for Standardization's Open Systems Interconnection (OSI) reference model, published in the late 1970s and early 1980s, formalized seven layers from physical transmission up to applications. OSI was the product of formal committee standardization, with national standards bodies and telecommunications administrations negotiating detailed specifications. Its layered vocabulary—"layer 2," "transport layer," "application layer"—became universal even where OSI's own protocols did not.
A rival effort, the TCP/IP work funded by the U.S. Advanced Research Projects Agency (ARPA), took a looser path. Vint Cerf and Bob Kahn's 1974 paper described a protocol for connecting dissimilar networks; the resulting TCP/IP suite was refined through the 1970s and adopted as the ARPANET's standard in 1983134. Where OSI specified from the top down, TCP/IP grew from working code and rough consensus, documented in freely circulated "Request for Comments" (RFC) notes. The contrast—formal committee standards versus open, implementation-led standards—shaped the field's culture for decades.
End-to-end internetworking
The idea that carried TCP/IP to dominance was end-to-end internetworking: keep the network simple and push complexity to the endpoints. The end-to-end argument, articulated by Jerome Saltzer, David Reed, and David Clark in 1981, held that functions like reliability and error checking are best implemented at the communicating hosts, not buried in the network5. The Internet Protocol (IP) embodied this: it forwarded packets between networks without guaranteeing delivery, and TCP at the endpoints reassembled streams and retransmitted losses6. This made the network tolerant of heterogeneous links—any technology that could carry packets could join. The design choice was contested; telephone engineers found best-effort delivery alarming. But it let the Internet absorb new link technologies without redesigning the core, and it is the reason a single protocol family could span the globe.
Naming, addressing, and the growth of the directory
Connecting networks required a way to name and find machines. Early systems used a single hosts file listing every computer; as the network grew, that became unmanageable. The Domain Name System (DNS), designed by Paul Mockapetris in 1983, replaced it with a distributed, hierarchical naming scheme: names are resolved by querying a tree of servers, each authoritative for part of the namespace. DNS was an early and influential example of distributed naming and address management—delegating authority so no single machine holds the whole directory. Address allocation itself became a protocol concern as IPv4 addresses ran short, motivating subnetting, classless addressing, and eventually IPv6, whose specification emerged in the 1990s and whose deployment has been gradual and still incomplete78.
Open standards and rough consensus
The Internet's governance model became as influential as its protocols. The Internet Engineering Task Force (IETF), formed in the mid-1980s, codified "rough consensus and running code": standards emerge from working implementations and open discussion rather than formal votes. The phrase, associated with David Clark's 1992 remarks to the IETF, captured a philosophy in which interoperability demonstrations and deployed code carried more weight than committee authority. This open-standards culture spread—the World Wide Web Consortium, founded by Tim Berners-Lee in 1994, took a similar approach for web protocols. The model's strength was speed and pragmatism; its weakness, visible in later decades, was that consensus among implementers could be slow and could favor incumbents.
The web and application-layer request/response
The application layer produced the protocols most people actually touch. The Hypertext Transfer Protocol (HTTP), created by Berners-Lee around 1989–1991, is a request/response protocol: a client sends a request, a server returns a response9. Its simplicity—a method, a resource identifier, headers, a body—made it extensible, and it became the substrate for the web. Email protocols (SMTP for sending, POP and later IMAP for retrieval) followed similar patterns. These protocols showed that application-layer design could be minimal and still scale enormously, and their request/response shape remains the default mental model for networked software.
Security moved into the transport substrate
As traffic moved onto shared and public networks, confidentiality and authentication became protocol problems. Early efforts like Netscape's Secure Sockets Layer (SSL), released in the mid-1990s, and its successor Transport Layer Security (TLS) inserted an encrypted, authenticated channel between transport and application10. The design choice was consequential: rather than securing each application separately, security became a reusable substrate that any application could sit atop. TLS's evolution—through protocol versions and the eventual shift to TLS 1.3, standardized in 2018—tracked a running battle with attacks and a drive toward simpler, faster handshakes. Security as a transport layer rather than an application feature is now the norm.
Constrained devices and the Internet of Things
A different pressure came from very small devices: sensors, actuators, and embedded systems with little memory, power, or bandwidth. Adapting Internet protocols to them required new designs. The Constrained Application Protocol (CoAP), standardized in the early 2010s, reworked the request/response model for tiny devices over UDP, and the MQTT publish/subscribe protocol, originating in the late 1990s for telemetry, became widely used for device messaging. These constrained-device and IoT protocols showed that the Internet's core ideas could be scaled down, and that new application patterns—publish/subscribe rather than pure request/response—could coexist with the older model.
Software-defined control and the separation of planes
For decades, each router and switch decided forwarding locally, running distributed routing protocols. Software-defined networking (SDN), emerging around 2008–2011, challenged this by separating the control plane (where forwarding decisions are made) from the data plane (where packets are actually moved), centralizing control in software. The OpenFlow protocol, introduced around 2008, gave a controller a standard way to program switches11. SDN promised programmability and global optimization that distributed protocols struggled to achieve; skeptics worried about central points of failure and scale. The debate reshaped how networks are built, and the separation of control from forwarding is now a standard architectural option, especially in data centers.
Low-latency transport and the present
The most recent strand concerns transport performance. TCP's congestion control, refined since the late 1980s, was tuned for fairness and stability rather than minimum delay. Newer transport protocols—Google's QUIC, developed in the 2010s and standardized by the IETF in 2021—built reliability and encryption into a UDP-based transport to cut connection setup latency and improve performance on lossy links. Meanwhile, data-center operators developed specialized congestion-control schemes to keep latency low at high speeds. These efforts continue a long argument about how much the transport layer should assume about the network beneath it.
Today the field works across all these layers at once: formal standards bodies and open-consensus processes coexist; end-to-end internetworking remains the backbone while SDN and programmable data planes add centralized control where it helps; security is baked into transport; and IoT and low-latency designs push the old protocols into new territory. The open questions are familiar in shape—how to secure a sprawling, heterogeneous Internet; how to migrate the world to IPv6; how to keep latency low as traffic grows—and they are argued, as they always have been, through the slow work of getting independent parties to agree on rules.
References
- Communication protocol (introduction, History), Wikipedia
- Ethernet (History), Wikipedia
- Internet Standard (History and the purpose of Internet Standards), Wikipedia
- ARPANET, Wikipedia
- End-to-end principle, Wikipedia
- Internet Protocol, Wikipedia
- IPv4 address exhaustion, Wikipedia
- IPv6, Wikipedia
- HTTP (introduction, History), Wikipedia
- Transport Layer Security, Wikipedia
- Software-defined networking (introduction, History), Wikipedia
The frameworks of Network Protocols
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1965-Present
- 1970-Present
- 1978-1995
Formal committee standardization
How do independent parties agree on a standard?
- 1978-Present
Layered reference models
How should communication be divided into layers?
- 1981-Present
- 1983-Present
Distributed naming and addressing
How do machines find each other by name?
- 1986-Present
Request for Comments
How are open technical standards written and agreed?
- 1991-Present
Request/response application protocols
How should a client ask a server for something?
- 1995-Present
Transport Layer Security
How can two parties talk privately over an open network?
- 1999-Present
Constrained-device and IoT protocols
How can tiny devices join the Internet?
- 2008-Present
- 2013-Present
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Multiple access protocols grew out of Packet switching
Packet switching made shared links carry independently forwarded packets, which raised the question of who may transmit when. ALOHA and then Ethernet's carrier sense with random backoff were designed as multiple access rules for exactly that packet-switched shared medium.
Carried by Norman Abramson; Robert Metcalfe.
End-to-end principle influenced by Packet switching
Packet switching's best-effort forwarding, with no guarantees in the network, set up the question the end-to-end argument answered: where should reliability and error checking live. Saltzer, Reed and Clark argued it belongs at the endpoints, matching how IP and TCP were built.
Carried by Jerome Saltzer; David Reed; David Clark.
Layered reference models influenced by Packet switching
The problem of connecting dissimilar packet networks drove the layering work: Cerf and Kahn's 1974 internetworking paper and the ARPANET experience fed into both OSI's seven-layer model and TCP/IP's layering.
Carried by Vint Cerf; Bob Kahn.
Distributed naming and addressing influenced by Packet switching
As packet-switched internetworks grew, the single hosts file listing every machine became unmanageable. Mockapetris's DNS replaced it with a distributed hierarchical directory suited to a network of independently administered packet networks.
Carried by Paul Mockapetris.
Request for Comments reacted against Formal committee standardization
The IETF's RFC culture of rough consensus and running code defined itself against the top-down formal committee standardization of OSI, favoring open discussion and deployed implementations over negotiated specifications.
Carried by Internet Engineering Task Force; David Clark.
End-to-end principle influenced by Layered reference models
The end-to-end argument was framed in the vocabulary of layering, arguing about which layer should implement reliability and error checking; Saltzer, Reed and Clark reasoned explicitly about functions placed in lower versus upper layers.
Carried by Jerome Saltzer; David Reed; David Clark.
Software-defined networking influenced by Layered reference models
SDN's separation of control plane from data plane re-drew the boundary between layers, treating forwarding as a programmable data plane beneath a software control layer.
Carried by OpenFlow.
Software-defined networking reacted against End-to-end principle
SDN's centralization of control in software challenged the end-to-end and distributed-routing assumption that forwarding decisions are made locally by each router; the debate was framed as a rejection of purely distributed control.
Carried by OpenFlow.
Request/response application protocols influenced by Distributed naming and addressing
HTTP requests identify resources by URLs whose host part is resolved through DNS, so the web's request/response protocol depends on distributed naming to find servers.
Carried by Tim Berners-Lee.
Request/response application protocols influenced by Request for Comments
HTTP was specified and refined through RFCs, the open documentation channel that the IETF had established for Internet protocols.
Carried by Tim Berners-Lee; Internet Engineering Task Force.
Transport Layer Security influenced by Request for Comments
TLS and its successor versions were standardized as RFCs through the IETF process, carrying the open-standards documentation model into security protocols.
Carried by Internet Engineering Task Force.
Constrained-device and IoT protocols influenced by Request for Comments
CoAP was standardized as an IETF RFC, following the rough-consensus, running-code process that the RFC series embodied.
Carried by Internet Engineering Task Force.
Transport Layer Security influenced by Request/response application protocols
SSL/TLS was created to secure web traffic, wrapping HTTP's request/response exchanges in an encrypted, authenticated channel.
Carried by Netscape.
Constrained-device and IoT protocols grew out of Request/response application protocols
CoAP reworked HTTP's request/response model for constrained devices over UDP, keeping the method-and-resource shape while shrinking it for tiny nodes.
Low-latency transport influenced by Transport Layer Security
QUIC built TLS 1.3 into its handshake, making the transport security substrate integral to the low-latency transport rather than a separate layer above it.
Transport Layer Security influenced by Distributed naming and addressing
TLS certificates bind cryptographic keys to DNS names, so the transport security substrate relies on the distributed naming system to authenticate servers.
Low-latency transport influenced by Request for Comments
QUIC and newer transport work were specified and debated through IETF RFCs and working groups, continuing the open documentation model.
Carried by Internet Engineering Task Force.
Constrained-device and IoT protocols influenced by Transport Layer Security
Constrained-device protocols adopted TLS-derived security, with DTLS adapting TLS for datagram transport over UDP for IoT devices.
Beyond the field
Where Network Protocols's ideas came from in other fields, and what they led to there: the strongest 12 of 61 links.
Packet switching led to Internet Protocol in Routing And Internetworking
IP grew directly out of packet-switching protocol work; Cerf and Kahn's 1974 paper framed the new protocol explicitly as an internetworking layer over packet networks.
Carried by Vint Cerf; Robert Kahn.
Packet switching influenced Internetworking and the End-to-End Argument in Networks
Packet switching in network protocols is the transmission model within which the end-to-end argument was framed, since the argument concerns protocol functions in a packet network. The 1981 paper reasons about packet-switched protocol design.
Carried by Jerome Saltzer; David Reed; David Clark.
Multiple access protocols influenced by Packet Radio and Random Access in Wireless Networks
Packet radio's random access scheme, ALOHA, is a multiple-access protocol for a shared channel and became a founding case in that literature. Later multiple-access protocol work analysed and refined ALOHA's collision model.
Carried by Norman Abramson.
Multiple access protocols influenced Ad Hoc, Sensor and Mesh Networking in Wireless Networks
Ad hoc and sensor networks rely on multiple-access protocols to share the wireless medium among many nodes. Contention and scheduling schemes developed in the multiple-access literature were carried into ad hoc and sensor MAC design.
Request/response application protocols influenced by Remote Procedure Call and Client–Server in Distributed Systems
Request/response application protocols generalise the client-server and remote procedure call model developed in distributed systems from the mid-1970s. HTTP's request/response exchange is a direct descendant of the RPC call-and-reply pattern.
Carried by RFC 1945 (1996).
Request/response application protocols influenced by Layered Reference Models in Network Architecture
Request/response application protocols such as HTTP were designed against the layered reference model of the OSI and TCP/IP stacks, with HTTP explicitly sitting above a reliable transport. The layered model supplied the architectural frame in which request/response protocols were placed.
Carried by Tim Berners-Lee; RFC 1945 (1996).
Transport Layer Security grew out of Cryptographic protocol in Applied Cryptography
TLS grew directly out of the cryptographic protocol tradition, specifically Netscape's SSL, which was designed by borrowing from earlier key-exchange and authentication protocol work. TLS 1.0 (RFC 2246, 1999) was a refinement of SSL 3.0.
Carried by Netscape; SSL 3.0 (1996); RFC 2246 (1999).
Constrained-device and IoT protocols influenced by Internet Protocol in Routing And Internetworking
Constrained-device and IoT protocols such as 6LoWPAN and CoAP were built directly on the Internet Protocol, adapting IP to low-power links. The IoT protocol stack is defined by its use of IP addressing and the IP architecture.
Carried by RFC 4944 (2007); RFC 7252 (2014).
Software-defined networking influenced by Control-Data Plane Separation in Software Defined Networking
Control-data plane separation is the defining architectural principle that SDN took up and generalised into a programmable, centrally controlled network. SDN's central controller is the direct extension of the separated control plane.
Low-latency transport influenced by Delay-based congestion control in Congestion Control
Low-latency transport drew on delay-based congestion control, notably the Vegas and FAST approaches that use queuing delay as a signal. Modern low-latency protocols refined delay-based congestion signalling for data-center and wide-area use.
Low-latency transport influenced by Low-latency data-center congestion control in Congestion Control
Low-latency transport protocols such as those in modern data centers built on data-center congestion-control work, including DCTCP and its successors. The low-latency designs refined the congestion-control algorithms developed for data-center fabrics.
Packet switching led to Link-state routing protocol in Routing And Internetworking
Link-state routing is a protocol technique developed on top of packet switching, flooding link information as packets through the network.

Network Protocols is a planet in Nousfarer
Its city has a tower for each of these 12 frameworks. Land, walk in, and climb one concept at a time.
Land on Network ProtocolsRelated fields
Fields its ideas are linked to
- Routing And Internetworking 17 links
- Network Architecture 7 links
- Networks 5 links
- Network Security 5 links
- Congestion Control 4 links
- Wireless Networks 4 links
- Software Defined Networking 3 links
- Computer Systems 3 links
- Distributed Algorithms 2 links
- Applied Cryptography 2 links
- Systems Integration 2 links
- Construction Materials 1 link
More in Networks
- Congestion Control
- Network Architecture
- Networks
- Peer To Peer And Content Delivery
- Routing And Internetworking
- Software Defined Networking
- Wireless Networks
See where Network Protocols sits on the Map of Human Knowledge