Note: The conversations presented herein are imagined for illustrative purposes, though grounded in the historical development of HTTP.
Here is a tale of the conception of the very early version of HTTP, known as "HTTP/0.9" — the simplest form of communication betwixt client and server that ever graced the nascent World Wide Web.
Picture CERN in the late 1980s — a vast institution where thousands of researchers labored, each producing documents, papers, and notes. Yet these treasures of knowledge resided trapped within individual computers, accessible only to those who knew precisely where to look.
"How might we share our findings?" a researcher might lament. "My colleague across the building has written a paper I must read, yet to obtain it I must either walk to his office with a floppy disk in hand, or wait for him to send me a copy through the post. And what of researchers in other countries? Must knowledge travel at the speed of a floppy disk carried by courier?"
Information existed in silos. Knowledge, though abundant, remained isolated and difficult to discover. Something had to change.
'Twas in this environment that Sir Tim Berners-Lee pondered a solution: "How might computers request documents from one another across this network? How might we liberate knowledge from its prisons?"
There was naught before — no protocol to reference, no standard to follow. One might imagine his reasoning thus:
"What shall we fashion? A client need only express what it desires. Let it simply say: GET the document."
And so HTTP/0.9 was born — a protocol of but a single method:
GET. No headers, no status codes, no versions. Merely a
request and a response.
Imagine a conversation betwixt client and server, stripped to its barest essence:
Client: "GET /index.html"
Server: [sends the entire HTML document]
Server: [closes connection]
That is all! No HTTP/1.0 suffix, no
Host: header, no complexities whatsoever. The complete
exchange:
GET /index.html
And the server would respond:
<html> <body> This is the document you requested. </body> </html>
If the file could not be found, the conversation became even briefer:
Client: "GET /missing.html"
Server: [silence, closes connection]
Client: [confused] "I suppose... that means no?"
The client was left to deduce the nature of the failure from this eloquent silence.
As the web grew, researchers found themselves in want of more information. Picture a researcher in 1995, perplexed:
"The server sent me something, but what is it? Is it HTML? An image? Plain text? How large is it? And when the document is not found, must I truly guess at the problem from mere silence?"
Thus was HTTP/1.0 born, bringing forth a proper dialogue betwixt client and server:
GET /index.html HTTP/1.0
200 OK, 404 Not Found, and other such
indications
POST and
HEAD joined GET in the protocol
Now the conversation gained civility and clarity. The client introduces itself properly:
Client: "Good day! I am Mozilla 1.0, and I would like to GET /index.html, if it please you. I speak HTTP/1.0."
GET /index.html HTTP/1.0 Host: example.com User-Agent: Mozilla/1.0
And the server responds with equal courtesy and precision:
Server: "Ah, greetings! I am pleased to inform you that all is well (200 OK). I shall send you an HTML document of 137 bytes in length:"
HTTP/1.0 200 OK Content-Type: text/html Content-Length: 137 <html> <body> This is the document you requested. </body> </html>
What a remarkable improvement! No more guessing, no more silence.
Scarcely a year hence, researchers noticed a curious waste of effort:
Researcher: "Why must we make introductions anew for each request? If I need to fetch an HTML page, then its stylesheet, then three images, must I truly establish a new connection for each? 'Tis like knocking on a door, exchanging pleasantries, receiving one item, saying farewell, and then knocking again immediately thereafter!"
HTTP/1.1 addressed this grievous inefficiency, allowing connections to persist:
Client: "GET /index.html HTTP/1.1" [receives document]
Client: "Oh, and whilst we are speaking, might I also have /style.css?"
Server: "But of course! Here you are."
Client: "Splendid! And /image.jpg, if you would be so kind?"
Server: "Gladly provided. Anything else whilst the connection remains open?"
Key improvements included:
PUT,
DELETE, OPTIONS, and more joined the protocol
This version became the foundation of the web for nearly two decades, serving faithfully until HTTP/2 arrived in 2015.
What strikes one most profoundly is the elegance of that first protocol. HTTP/0.9 was so simple as to be implementable in but a few hours, yet it sufficed to birth the World Wide Web.
From such humble beginnings did arise the vast network through which you now read these very words. Each complexity we have added since — cookies, compression, encryption, multiplexing — serves some needful purpose, yet one cannot help but admire the purity of that original vision.
Consider this: in the span of merely six years (1991-1997), HTTP evolved from a protocol of a single line to one capable of supporting the modern web. Each enhancement addressed a real need, yet none strayed from the fundamental model of request and response.
Perchance there is a lesson here about the nature of protocols, and indeed of all things: that which begins simple may grow complex, but the essential purpose remains unchanged — to connect, to communicate, to share.
The next time you load a web page, spare a thought for those early pioneers who fashioned these elegant solutions to connect the world. Their work, though decades old, still underlies every request you make.