HTTP Protocol Evolution: A Technical Analysis from 0.9 to 1.1

Network

2025 Apr 151220 words|Estimated reading time: 7 minutes

HTTP (Hypertext Transfer Protocol), as the foundational communication protocol of the World Wide Web, has undergone progressive evolution from simplicity to complexity since its proposal by Tim Berners-Lee in 1991.

This article systematically analyzes the core features, design philosophies, and evolutionary logic of three milestone versions—HTTP 0.9, HTTP 1.0, and HTTP 1.1—from a technical architecture perspective. It focuses on the interaction mechanisms between each version and the TCP protocol, as well as their impact on web performance.

Prerequisite Knowledge

Before delving into HTTP protocol evolution, readers should have a basic understanding of TCP protocol concepts, including but not limited to:

TCP three-way handshake / four-way handshake mechanism
Connection establishment and release processes
Basic principles of flow control and congestion control

To supplement TCP knowledge, refer to this article:

HTTP/0.9: The Initial Form of Web Protocol (1991)

As the foundational protocol of the Web, HTTP/0.9 was designed and implemented by Tim Berners-Lee in 1991. Its minimalist architecture reflected the core requirement of early "hypertext transfer." Though limited in functionality, this initial version established the basic client-server interaction model.

Architectural Features

Minimalist Request Model
- Only supported the GET method, with the format: GET <path>\r\n
- No protocol version identifier in the request line (since no other versions existed)
- No concept of request/response headers
Limited Response Handling
- Responses were raw HTML document byte streams
- No status codes, Content-Type, or other metadata
- Document transmission completion indicated success; disconnection indicated failure
Stateless Communication
- Servers did not retain any request context
- Each request was a completely independent interaction

TCP Layer Interaction Mechanism

Client                          Server  
  |-------- SYN ----------->|         |  
  |<------- SYN+ACK --------|         | TCP three-way handshake  
  |-------- ACK ----------->|         |  
  |---- GET /index.html --->|         | Request starts  
  |<----- <HTML>...</HTML> -|         | Response data  
  |-------- FIN ----------->|         |  
  |<------- FIN+ACK --------|         | TCP four-way handshake

Connection Characteristics:

Serial short-lived connections (new TCP connection per request)
No Keep-Alive mechanism by default (each connection handled only one request)
Significant RTT (Round-Trip Time) latency:
- Each request required at least one TCP handshake (1.5 RTT)
- Highly inefficient for small file transfers (handshake overhead dominated)

Example Workflow

/* Request */  
GET /sample.html  

/* Response */  
<HTML>  
<head><title>Sample Page</title></head>  
<body>...</body>  
</HTML>

Protocol Limitations

Missing Features
- No multimedia support (only HTML text)
- No error handling (e.g., 404 status code)
- No content negotiation (e.g., language/encoding selection)
Performance Bottlenecks
- Serial connections caused "head-of-line blocking"
- Average latency = TCP handshake time + transfer time
- Poor bandwidth utilization (especially in high-latency networks)
Scalability Issues
- No support for new methods (e.g., future POST/HEAD)
- Lack of metadata hindered feature evolution

Historical Note: This simple design was acceptable in the era of 56K modems, but as web applications grew more complex, its limitations quickly became apparent, directly leading to the standardization of HTTP/1.0.

HTTP/1.0: The Industrial Standard (1996, RFC 1945)

As the first formally standardized HTTP version, HTTP/1.0 (defined in RFC 1945) marked the transition of web protocols from labs to commercial applications. This version addressed core flaws of 0.9 through structured design, laying the foundation for modern web architecture.

Revolutionary Improvements

Metadata Framework
- Introduced request/response headers
- Defined standard status codes (1xx-5xx)
- Added Content-Type for multiple MIME types
Protocol Extensibility
- Method expansion: retained GET, added POST/HEAD
- Supported content negotiation (Accept header)
- Basic cache control (Pragma/Expires)
Security System
- Introduced basic authentication (Authorization header)
- Implemented simple access control

Protocol Interaction Model

Client                          Server  
  |-------- SYN ----------->|         |  
  |<------- SYN+ACK --------|         | TCP three-way handshake  
  |-------- ACK ----------->|         |  
  |-- GET /index.html HTTP/1.0 -->|   |  
  |<-- HTTP/1.0 200 OK ----------|   |  
  |<-- Content-Type: text/html ---|   |  
  |<-- Content-Length: 1024 -----|   |  
  |<-- <HTML>...</HTML> ---------|   |  
  |-------- FIN ----------->|         |  
  |<------- FIN+ACK --------|         |

Key Header Fields:

Type	Example Field	Description
Request	`Accept: text/html`	Content negotiation
	`User-Agent: Mozilla/4.0`	Client identification
Response	`Content-Type: image/gif`	Content type declaration
	`Content-Encoding: gzip`	Transfer encoding

TCP Layer Optimization Attempts

Experimental Persistent Connections
- Non-standard Connection: keep-alive
- Inconsistent server implementations (NCSA/Apache differences)
- Short-lived connections remained default
Performance Trade-offs
- Short connections: High latency due to repeated TCP handshakes
- Long connections: Increased server memory usage (socket retention)

Example Workflow

/* Request */  
GET /profile.html HTTP/1.0  
Accept: text/html, image/gif  
User-Agent: Mozilla/5.0  

/* Response */  
HTTP/1.0 200 
<html>...</html>

Remaining Issues

Connection Management Flaws
- Inconsistent Keep-Alive timeout policies
- No pipelining support
- Unresolved head-of-line blocking
Performance Bottlenecks
- Redundant headers (no compression)
- Limited concurrent connections per domain (2-4)
- Unoptimized DNS lookup overhead
Inadequate Caching
- Relied on Expires absolute timestamps
- No cache validation (ETag not yet introduced)
- Lack of hierarchical cache control

Engineering Impact: These limitations led developers to adopt workarounds like CSS Sprites and domain sharding—practices that influenced web optimization even into the HTTP/2 era.

HTTP/1.1: The Cornerstone of Modern Web (1997-1999)

As a milestone in HTTP evolution, HTTP/1.1 (defined in RFC 2068 (1997) and RFC 2616 (1999)) established the communication framework supporting the modern internet. Its design philosophy shifted from "document transfer" to "application platform."

Architectural Breakthroughs

Connection Efficiency Revolution
- Persistent connections by default (eliminated 90% of TCP handshake overhead)
- Experimental pipelining (later abandoned due to implementation issues)
- Smart connection management (Keep-Alive timeout)
Enhanced Caching
- Strong caching via Cache-Control and Expires (no server validation needed)
- Conditional requests via Last-Modified/If-Modified-Since and ETag/If-None-Match
Content Transfer Optimizations
- Chunked transfer encoding (Transfer-Encoding: chunked)
- Byte-range requests (Range/Content-Range)
- Compression (Content-Encoding)

Protocol Operation

Client                          Server  
  |-------- SYN ----------->|         |  
  |<------- SYN+ACK --------|         | TCP three-way handshake  
  |-------- ACK ----------->|         |  
  |-- GET /a HTTP/1.1 ---->|         |  
  |-- GET /b HTTP/1.1 ---->|         | Pipelining attempt  
  |<-- 200 OK /a ----------|         |  
  |<-- 200 OK /b ----------|         |  
  |-- POST /c HTTP/1.1 --->|         |  
  |<-- 201 Created --------|         |  
  |-------- FIN ----------->|         | Idle timeout  
  |<------- FIN+ACK --------|         |

Key Header Advancements:

Mandatory Host header (enabled virtual hosting)
Granular cache control (Cache-Control directives)
Conditional requests (If-Match/If-None-Match)

TCP Layer Optimizations

Connection Reuse Strategies
- Browser connection pooling (6-8 TCP connections per domain for true concurrency)
- Dynamic adjustment based on RTT and bandwidth
Slow Start Adaptation
- Better TCP congestion window coordination
- Avoided burst data transmission

TIME_WAIT Challenges

# Typical TIME_WAIT accumulation issue  
for i in range(10000):  
    conn = create_connection()  
    send_request(

Example Interaction

/* Request */  
GET /app.js HTTP/1.1  
Host: cdn.example.com  
Accept-Encoding: gzip, deflate  
If-None-Match: "abc123"  

/* Response */

Engineering Innovations

Performance Optimization Techniques
- Domain sharding
- Resource concatenation
- CSS Sprites
- Inlining critical resources (e.g., Critical CSS)
CDN Acceleration Strategies
- Edge caching
- ETag-based cache validation
- Intelligent content distribution

Fundamental Limitations

**Protocol Bottlenecks...