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

still a working view ended · each leads to its entry below

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

  1. Communication protocol (introduction, History), Wikipedia
  2. Ethernet (History), Wikipedia
  3. Internet Standard (History and the purpose of Internet Standards), Wikipedia
  4. ARPANET, Wikipedia
  5. End-to-end principle, Wikipedia
  6. Internet Protocol, Wikipedia
  7. IPv4 address exhaustion, Wikipedia
  8. IPv6, Wikipedia
  9. HTTP (introduction, History), Wikipedia
  10. Transport Layer Security, Wikipedia
  11. 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.

  1. 1965-Present

    Packet switching

    How can data share links without a dedicated circuit?

    Fly to its tower in Nousfarer

  2. 1970-Present

    Multiple access protocols

    Who may transmit when many share one channel?

    Fly to its tower in Nousfarer

  3. 1978-1995

    Formal committee standardization

    How do independent parties agree on a standard?

    Fly to its tower in Nousfarer

  4. 1978-Present

    Layered reference models

    How should communication be divided into layers?

    Fly to its tower in Nousfarer

  5. 1981-Present

    End-to-end principle

    Where should network complexity be placed?

    Fly to its tower in Nousfarer

  6. 1983-Present
  7. 1986-Present

    Request for Comments

    How are open technical standards written and agreed?

    Fly to its tower in Nousfarer

  8. 1991-Present

    Request/response application protocols

    How should a client ask a server for something?

    Fly to its tower in Nousfarer

  9. 1995-Present

    Transport Layer Security

    How can two parties talk privately over an open network?

    Fly to its tower in Nousfarer

  10. 1999-Present
  11. 2008-Present

    Software-defined networking

    Who decides where packets are forwarded?

    Fly to its tower in Nousfarer

  12. 2013-Present

    Low-latency transport

    How can transport be made fast and low-delay?

    Fly to its tower in Nousfarer

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.

Packet switchingMultiple access protocolsFormal committee standardizationLayered reference modelsEnd-to-end principleDistributed naming and addressingRequest for CommentsRequest/response application protocolsTransport Layer SecurityConstrained-device and IoT protocolsSoftware-defined networkingLow-latency transport

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.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

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 Protocols

Related fields

Fields its ideas are linked to

More in Networks

See where Network Protocols sits on the Map of Human Knowledge