Earlier this week, the big news in the tech space surrounded the completion of the HTTP/2 Spec.
Gibberish, gibberish, gibberish.
What does this mean for the internet? The short version is: it’s about to become way faster.
Faster is extremely important if you want to make money from traffic to your site. Or, you know, if you use the internet at all. No one wants to wait for a website that just sits there and spins while it’s trying to load. We all hate that. And importantly, Google hates that.
Several years ago, Google invented and implemented the SPDY protocol. Simply, SPDY allows for the compression and efficient transmission of requests between browser and server. I’ll get into the technical details later, but for the sake of summarizing why the Internet is about to get faster… Google’s SPDY technology is the cornerstone of HTTP/2.
Now that the spec is finalized, it goes to editorial for cleanup and publishing… but the nuts and bolts of the spec will not change going forward. That means browsers and servers can start rolling out these changes as soon as… today.
If you are not interested in the technical explanation for HTTP/2, please skip to the next section. I don’t want you falling asleep and drooling on your keyboard.
In the original days of the internet, there was the HTTP/1.0 spec. This spec defined how clients (browsers) and servers communicated over a network. We still use 1.0 quite a bit today, though 1.1 is the current preferred.
When it comes to HTTP, the concept is simple… a client requests a resource (image, html, mp3, whatever) from a server, the web server interprets the request, goes back into a storage closet, finds the resource, has the requestor sign for it and then sends the resource on it’s way back to the client. A simple understanding is….
BROWSER: “Hey, server… can I get that image named image.jpg? You should find it in this folder.”
SERVER: “Sure, let me go look. Oh, here it is. There you go”
BROWSER: “Thanks, dude”
If the server can’t find the image in the directory, it sends the client a 404 (Not Found), but that’s just a sidenote.
The problem with HTTP/1.0 however, was that it only allowed for a single request on a single connection to the server. To put it in another way, The web page has 10 images on it. In order to get those 10 images from the server, it would have to send 10 requests. That creates a lot of requests for the server and if the server wasn’t optimized for that kind of capacity, it could crash… or at least be in the weeds. It was bad all around for bandwidth as well. All of those requests add up to high bandwidth costs!
So God gave us HTTP/1.1.
Given this inherent problem with HTTP/1.0, HTTP/1.1 enhanced the original spec by adding the concept of pipelining. Imagine, if you will, a highway tunnel. Generally, there’s no passing in a tunnel. While HTTP/1.0 only allowed a single car through the tunnel at a time, HTTP/1.1 allowed multiple cars in the tunnel, but dictated no passing. And because the web server on the other end of the tunnel can only process requests as they come in, you end up with a stacked up queue of requests waiting to get processed and… you still have the same problem where the server gets in the weeds and slows down.
In both the case of 1.0 and 1.1, server technology evolved to allow concurrency of requests. This gave us multiple lanes in the tunnel, but 1.1 still dictated no passing. So requests in one lane, had to stay in that lane but there could be more than one lane which allowed us to bandaid the inherent weakness in the HTTP/1.x stack.
When Google started giving SEO benefits to sites based on speed, they also ate their own dog food and invented SPDY. SPDY allows for compression of resources in a much more efficient way if both server and client supported it. It also allowed for single requests to get many resources at a time. That page that had 10 images and had to make 10 requests for those 10 images could now make a single request to get all 10 images at once. Efficiency, I tell you.
As with any working group, the task force that put together HTTP/2 had representation from Google. Google, as a good citizen, shared it’s knowledge and spec for SPDY with the working group and it became the basis of HTTP/2. In fact, Google will now eliminate SPDY in favor of HTTP/2.
In fact, clients are supporting HTTP/2 now. Well, a lot of them are anyway… and that’s because of Google’s implementation of SPDY. Internet Explorer 11+, Firefox 36+, and Chrome all implement SPDY-HTTP/2 support, but none are currently enabled by default. Safari and Mobile Safari will likely soon get the support.
Most web servers also implement SPDY-HTTP/2 with the exception of lighttpd.
What does it mean to me?
The new HTTP spec is probably not anything you need to worry about at this point. System administrators will want to make sure their web servers are up to date and their TLS certificates are upgraded. Though the working group does not require HTTP/2 to use TLS, I’d expect most server manufacturer’s to require them in their own implementation… for security reasons.
On the client side, HTTP/1.1 still works. The working group was very careful to ensure backwards compatibility with prior versions of the spec. So if your browser makes a 1.1 request to a 2.0 server, the server will still answer in 1.1 with the same limitations I described above.
As developers, we will most likely want to use 2.0 when we can. The finalization of the spec is so new that it remains unclear what that means yet. For instance, what does this mean for the WordPress WP_Http class? Probably nothing in the short terms, but I’d expect enhancements to start rolling in as optional “toys” for developers.
Are you a developer or engineer? What are your thoughts on the new spec?