Enabling HTTP/2 for Dropbox web services: experiences and observations
blogs.dropbox.com
blogs.dropbox.com
One of the main excuses given for not enabling HTTP 1.1 pipelining was a small amount of software that didn't handle it correctly. According to Google, we needed a new protocol so we could start out fresh where there wouldn't be software not implementing the protocol correctly.
But according to this report, the browser with the largest market share and by the creators of HTTP/2 had a bad implementation of it for which a workaround had to be found for.
For history's sake we should recognize now that this buggy software argument for not enabling pipelining was never valid. Not enabling pipelining was used as a political tool to prevent HTTP 1.1 from being on par performance-wise with the new protocol people wanted for other reasons, and that's also why Google never even once tested SPDY against pipelining.
I'm curious, what are the politics behind this? What are the 'other reasons'?
Google does all sort of weird stuff. I had to disable their QUIC protocol on Chrome because Google apps stopped loading correctly or needed 15 refresh. It was driving me crazy. If some Googlers are listening, your QUIC protocol doesn't work.
Google is very good at seeing their own needs and deciding that what is good for them, at their Gigascale, must be good for everyone else on the internet too.
And then they push it in their own products and in their own browser, without any proper concern about internet standards and the processes for being then established in a proper and cooperative way.
Like they did with SPDY, which is now the overly complex and buggy HTTP/2.0.
If they didn't have their own browser, they would not be in a position to do things like this. I sometimes wish for an antitrust case against Google: that they cannot operate the major websites and have their own browser at the same time, much like the ruling against Microsoft over bundling Internet Explorer.
https://http2.github.io/faq/#whats-the-relationship-with-spd...
Google essentially donated the spec and started phasing out SPDY for HTTP/2, giving up control of it.
How you get "anti-trust case" from this is beyond me. But all of your comments here seem to have an anti-Google slant.
Even within Google the Chrome team is known to make moves that piss off others at the company. The Chrome/Flash debacle last summer was a good example. The AdX teams, like the rest of the ad industry, were not thrilled with the change being forced on the industry.
[0] http://arstechnica.com/information-technology/2016/05/html5-...
Nobody else was forced to implement SPDY, and there are plenty of others in the committees that gave us HTTP/2. In the end, it's what we have been saddled with. I would have preferred to see a more streamlined HTTP/2+SSL that didn't have as much round-trip cost. In any case, buggy software happens.
I find it especially remarkable that dropbox co-sponsored the nginx HTTP/2 module. This really brings benefits to all of us instead of treating such improvements as company internal secrets. Thanks!
Either way, nice move Dropbox!
[1] https://ma.ttias.be/day-google-chrome-disabled-http2-nearly-...
As we are moving to HTTP/2 and JavaScript heavy applications are everywhere we should stop bundling all of JavaScript files into a single big bundle file. It will help with caching a lot because right now we update the bundle if a single line in the code base changes. A lot of front-end build systems are optimized for HTTP/1.1.
There's also the fact that some browsers (IE on < Win10) will languish for a few years, so you may still need to support them, to what extent, who knows. And until there is proper support for native module loading in the majority of browsers, we aren't likely to see separate files widely adopted again.
Beyond all of this, as stated above, caching really hasn't worked out so well in practice, and shouldn't be your main optimization unless you are building an internal application that your users regularly utilize... Of course, those are the environments most likely to let best practices slip in terms of meeting deadlines.
So, the big resulting file is not a "bundle" and can't easily be split into parts.
I suspect we'll see more HTTP/2 servers now that Ubuntu 16.04 has been released.
The TL;DR is that nginx wants to do some weird stuff with flow control to avoid the need to do internal buffering. nginx is definitely outside the RFC here: what the client is doing is entirely acceptable.
[0]: https://lists.w3.org/Archives/Public/ietf-http-wg/2016AprJun... [1]: https://trac.nginx.org/nginx/ticket/959
Would be interesting to know what nginx does when it receives no content-length header, which is also valid.
From reading and implementing the HTTP/2 spec the setttings negotiation is the biggest weak spot in opinion, because it represents a big race condition where the expectations of client and servers probably won't match. I would have preferred it if they would either have put in a mandatory wait for SETTINGS ACK until streams can be acknowledged or if the default settings (window size, HPACK table size) would be very low and could only be increased during negotation. With the given HTTP/2 spec I would most likely try to be conservative as a library or application author and just announce/use the default settings or bigger ones in order to avoid compatibility problems. For most server this should be possible. However for constrained devices lower default settings would have been preferrable.
But yes, nginx's HTTP/2 implementation is really quite strange to me.
I'm not prepared to custom compile something like openssl, especially when it requires frequent updates.
How about we just ditch HTTP/2.0 (aka the Google forced it upon us protocol) and get back to something which is proven, IETF/W3C-based, is not binary, is simple and most importantly: actually works?
That'd be real nice.
Also let's not let Google create more internet protocols please. That'd also be nice.
Can you quote the section of the article where it says that? Because the only reference to HTTP/1.1 I found says:
> HTTP/2 [...] provides several performance optimizations compared to HTTP/1.1. These optimizations include more efficient header compression, server push, stream multiplexing over the same connection, etc.
I’m curious how HTTP/2.0 and HTTP/1.1 compare in a few years from now.
Why is this a downside (apart from 'I can't telnet now')?
Binary ruins that fine tradition for the promise of 0.1% better performance. And I think that's a terrible trade.
I would say even say most networking protocols are binary. Some very high level protocols are not, but in my opinion working with binary ones in applications and libraries is much easier (no need to read an arbitrary amount of bytes and loop through all of them just to find a termination sequence, etc.)
(Edit: I realise you can likely also access/debug HTTP/2.0 streams with a CLI tool - I am currently ambivalent about text vs binary streams.)
It's even the backbone for the new Google RPC framework: gRPC allowing for microsecond latencies. It's time to move on to better tech.
Reading your other comments, it seems you have some anti-Google political stance rather than a technical basis for this.