DEV Community

Cover image for The history of HTTP in under 5 minutes
Andreas Bergström
Andreas Bergström

Posted on

The history of HTTP in under 5 minutes

The Hypertext Transfer Protocol (HTTP) is the foundation of data communication on the World Wide Web. Since its inception, HTTP has undergone several iterations to improve its performance, security, and efficiency. In this blog post, we will take a deep dive into the history and key features of each HTTP version, from HTTP/0.9 to the latest HTTP/3, with a focus on new headers and technologies introduced in each version.

HTTP/0.9: The Beginning

HTTP/0.9, also known as the "One-Line Protocol," was the first version of HTTP introduced by Tim Berners-Lee in 1991. It was a simple text-based protocol that allowed clients to request documents from servers using a single line command.

The client would send a request in the format "GET ", and the server would respond with the requested document. There were no headers or metadata, and the connection would close immediately after the transfer. While HTTP/0.9 was extremely limited, it laid the groundwork for future versions of the protocol.

HTTP/1.0: Expanding Functionality

HTTP/1.0, officially released as RFC 1945 in 1996, expanded upon HTTP/0.9 by introducing a more robust request and response format. HTTP/1.0 added support for request and response headers, which allowed clients and servers to exchange metadata about the request and the resource being transferred. Some of the key headers introduced in HTTP/1.0 include:

Content-Type: Specifies the media type of the resource being transferred.
Content-Length: Indicates the size of the resource in bytes.
Last-Modified: Represents the date and time the resource was last modified.
Expires: Provides a date and time after which the resource is considered stale.

These headers enabled new features such as caching, content negotiation, and conditional requests. However, HTTP/1.0 still had some significant limitations, such as opening a new TCP connection for each request, which negatively impacted performance.

HTTP/1.1: Performance and Efficiency Improvements

HTTP/1.1, first released as RFC 2068 in 1997 and later updated in RFC 2616 (1999) and RFC 7230-7235 (2014), aimed to address the performance issues present in HTTP/1.0. The most notable improvement was the introduction of persistent connections, which allowed multiple requests and responses to be sent over a single TCP connection, reducing the overhead of establishing and closing connections. HTTP/1.1 also introduced features such as pipelining, chunked transfer encoding, and additional caching mechanisms.

Some important headers introduced in HTTP/1.1 include:

Host: Specifies the domain name and port number of the server hosting the requested resource.
Cache-Control: Allows clients and servers to specify caching policies, such as max-age or no-cache.
ETag: Provides a unique identifier for a specific version of a resource, allowing for conditional requests and more efficient caching.
Connection: Indicates whether the connection should remain open for further requests or be closed after the current request.

HTTP/1.1 also paved the way for real-time communication with the introduction of WebSockets and Server-Sent Events (SSE), enabling efficient bidirectional communication between clients and servers.

HTTP/2: A Major Leap Forward

HTTP/2, standardized as RFC 7540 in 2015, brought a fundamental shift in the way HTTP communicated over the network. Instead of using plain text, HTTP/2 utilized a binary framing layer, making it more efficient and less error-prone.

One of the most significant advancements was the introduction of multiplexing, which allowed multiple requests and responses to be sent concurrently over a single connection. This eliminated the head-of-line blocking problem present in HTTP/1.1, where a single slow request could block subsequent requests.

HTTP/2 also introduced server push, a feature that enabled servers to proactively send resources to the client's cache, anticipating future requests. Additionally, HTTP/2 offered header compression using HPACK, which reduced the overhead of sending redundant header data.

Some enhancements in HTTP/2 include:

Stream Prioritization: Enables clients to specify the priority of multiple requests, allowing servers to optimize resource delivery.
ALPN (Application-Layer Protocol Negotiation): Allows clients and servers to negotiate the specific version of HTTP during the TLS handshake, improving connection establishment time.

HTTP/3: Embracing QUIC

HTTP/3, which began as an experimental protocol called QUIC (Quick UDP Internet Connections) at Google, was officially standardized by the IETF in 2021. The most significant change in HTTP/3 is the shift from using TCP as the transport layer protocol to QUIC, which uses the User Datagram Protocol (UDP) instead. This transition improves latency and connection establishment times by reducing the number of round trips required during the handshake process.

QUIC also introduces built-in encryption, making it more secure by default. Another notable feature is the improved handling of packet loss, which is particularly beneficial for users on unreliable networks or experiencing high latency. By employing a more efficient loss recovery mechanism and allowing for independent streams, QUIC ensures that packet loss on one stream does not impact the performance of other streams.

HTTP/3 also retains the performance features of HTTP/2, such as multiplexing, header compression, and server push. However, due to the fundamental differences between TCP and UDP, some adjustments were required. For example, HPACK compression was replaced with QPACK, a new compression scheme specifically designed for QUIC's unique characteristics.

Top comments (0)