Guy Podjarny

Head of line blocking is when something ahead in the line blocks things behind it. If browsers choose to use connection limits, then that means that things ahead in the line and get to use the connections are blocking things behind in line which have to stay queued up waiting for the connections to free up. So yes, that's head of line blocking. As for pipelining working great in those browsers, you should note that no major desktop browser uses pipelining. Firefox does not enable it by default. See the Firefox bug thread where it's explained why it's not on by default, and also identifying its head of line blocking issues: https://bugzilla.mozilla.org/show_bug.cgi?id=264354#c30. Microsoft did test pipelining. In their theoretical lab network, with ideal situations, they can match SPDY performance. But the sad reality is that real websites and networks don't match that. Please see http://www.guypo.com/technical/http-pipelining-not-so-fast-nor-slow/. And you have to ask yourself, if Microsoft really believed that result, why don't they enable pipelining in IE? It's fascinating to me that you still seem to hold onto your claims that HTTP pipelining is feasible in real networks, even though IE, Firefox, and Chrome developers have all clearly tried and given up on it.

Apparently "connection: keep-alive" is needed to enable pipelining in the browsers: http://www.guypo.com/http-pipelining-big-in-mobile/

I can point you to a benchmark that disagrees. http://www.guypo.com/not-as-spdy-as-you-thought/ . I promise you that I've considered the spec and its implications. Where are we now?

SPDY is a good idea in general, but the average web site shouldn't be expected to see the same gains that a Google property (which is tuned like a mofo and which is usually hosted entirely through Google-controlled domains) will: http://www.guypo.com/technical/not-as-spdy-as-you-thought/ HTTP's high-frequency back-and-forth shuffle is a good thing to eliminate, but most of the time, there are more serious bottlenecks somewhere else. You can play with it easily enough in FF: set network.http.spdy.enabled to FALSE and see if Google News really seems any different to you as a human being.

It means javascript execution is slower in 3rd-party browsers. They can make up for that by e.g. using better networking libraries: http://www.guypo.com/mobile/ios-browsers-speed-bakeoff/

For Google, a .0001% reduction in user overhead may translate to millions of dollars of resource savings. Google is willing to do crazy things like run their own modified Linux kernel that most companies wouldn't bother with. What is the end-user benefit in performance using HTTP 2.0? The only analysis of SPDY I saw indicated low single digit percentage benefit vs HTTPS. Whoop-dee-do. http://www.guypo.com/technical/not-as-spdy-as-you-thought/

Tried to find where you pulled this number. This study seems in-line with your hypothesis (it states a gain over HTTPS, and a loss over HTTP): http://www.guypo.com/technical/not-as-spdy-as-you-thought/

So? "The results show SPDY, on average, is only about 4.5% faster than plain HTTPS, and is in fact about 3.4% slower than unencrypted HTTP" -- http://www.guypo.com/technical/not-as-spdy-as-you-thought/

I think they're talking about this: Not as SPDY as you thought: http://www.guypo.com/technical/not-as-spdy-as-you-thought/ The guy seems to know what he's talking about, and has actually run some tests but the test setup seems kind of weird. Effectively he's saying "if you only change HTTP to SPDY and make no other changes, then it's 3% slower (though more secure)" or "if you only change HTTPS to SPDY and make no other changes, then it's only 4% faster" assuming your site looks like some kind of average of the top 500 sites. And his conclusion is much more positive than most of the 3rd party coverage of it: "I believe SPDY is still awesome, and is a step in the right direction. This study and its conclusions do not mean we should stop working on SPDY, but rather that we should work on it more, and make it even faster."

http://www.guypo.com/technical/not-as-spdy-as-you-thought/ The results show SPDY, on average, is only about 4.5% faster than plain HTTPS, and is in fact about 3.4% slower than unencrypted HTTP. This means SPDY doesn’t make a material difference for page load times, and more specifically does not offset the price of switching to SSL.

Proof: http://www.guypo.com/technical/not-as-spdy-as-you-thought/

I'm a bit confused that multiplexing over one TCP connection is somehow seen as a strength of this new protocol. OK. I see how muxing streams over a TCP session theoretically allows the TCP session to "fill" the available bandwidth for a longer period of time. But it also means that every stream in the session will suffer from a few packet drops (and the resultant "sputtering" slow starts over lossy physical media, ie. the mobile use-case). As for why flow control is being pushed into the app layer, the answer again comes down to multiplexing of multiple streams over one TCP connection (since without stream-level flow control, one slow end-point for a stream can potentially block the progress of every other stream in that session... see discussion here: https://groups.google.com/forum/#!topic/spdy-dev/g4PiZBTW-34) I guess in the end, only real measurements with a mature implementation will answer the question. As it turned out with SPDY (1), the results of all this work might still not be enough to overcome the basic problems with TCP. (1) http://www.guypo.com/technical/not-as-spdy-as-you-thought/

My sibling has already pointed out one of the better critiques I've seen. There is also http://www.guypo.com/technical/not-as-spdy-as-you-thought/ , which I believe has been discussed on HN before, but I'm on a pomodoro break, so I'm trying to keep this short. One critique that I don't remember if is contained in either of these two is header compression. Header compression seems to make sense, as compression is good. The problem is that intermediaries make routing decisions based on the headers, and so it's quite possible that the CPU time needed to decompress, possibly modify, and recompress the headers outweighs any gains that the compression brought in the first place. I've also seen some vague commentary about 'mixing application concerns into the transport layer' which I find compelling, but I don't have enough experience with the low-level networking to properly judge on my own. Break over! Gotta run.