5 ms·
Intent to unship: HTTP/2 Push
- SSLy 2y ago… in Firefox.
- darrin5698 2y ago[dead]
- KaiserPro 2y agoWhy wasn't push adopted more widely? It was one of the big reasons HTTP2 was meant to be a game changer (despite the massive flaws) Was it a lack of browser support? or that it didn't really work with CDNs?
- swiftcoder 2y agoYou might like the more detailed breakdown published when Chrome decided not to support push: https://developer.chrome.com/blog/removing-push/ https://developer.chrome.com/blog/removing-push/
- Aachen 2y agoAll that says (that is relevant to the posed question) is: > it was problematic as Jake Archibald wrote about previously, and the performance benefits were often difficult to realize Edit: Clicking through to the linked post by Jake, <https://jakearchibald.com/2017/h2-push-tougher-than-i-thought/ https://jakearchibald.com/2017/h2-push-tougher-than-i-though...>, problems mentioned are - browsers had buggy implementations which wouldn't (always) use the pushed data. In that case, you've (as a web server) kept the connection busy and sent bytes for nothing - browsers ignore max-age when using push cache. Given that the time between pushing and using is usually <1 second, that seems fine to me? Don't get this one. Further down is another caching header caveat. Just don't push data to the cache that you don't want it to cache? - pushed data is dropped when the connection closes. Seems like a simple fix to me: keep data around until you navigate away from the page or the tab gets unloaded for any other reason. Or keep the connection open while the page renders because there might be more requests anyway, like for an image or commenter's avatar - different pages using the same connection can use each other's cache, so if you "open in a new tab" two links and one of them already pushed the /css/main.css then the other doesn't need to anymore. This sounds like a very useful feature, not a reason to remove push at all. Further down in the article, under a separate point, it says "Once the browser uses something in the push cache, it's removed", which sounds like this mechanism can't work at all and they'll steal each other's resources instead?! Surely that's not the case, since it makes the sharing entirely useless? - if you use authentication, make sure to send it along when requesting e.g. a font via JavaScript because otherwise it can't use the cache because you're not the same user. Okay, sounds reasonable and like a simple thing to do - not all browsers implemented cross-origin pushing Finally, there's a concluding paragraph starting with > There are some pretty gnarly bugs around HTTP/2 push right now, but once those are fixed I think it becomes ideal for the kinds of assets we currently inline, especially render-critical CSS. This doesn't sound like a reason to remove push altogether. Quite the opposite?
- bawolff 2y agoWell there is a link with more info about what Jake wrote. The tl;dr: its hard to predict ahead of time what resources browsers really need, so often you send the wrong thing or the non ideal thing. End result is the practical performance benefit was much smaller than the theoretical one.
- Aachen 2y agoI was indeed reading that while taking notes. The comment is now updated with those. I didn't read in the post what you said its tldr is supposed to be; maybe I read over it
- kijin 2y agoThe practical benefit is virtually nil because HTTP already has a proven mechanism for caching and preloading. By the time you visit the second page on a multi-page site, you are likely to have almost all stylesheets, scripts, and common images already cached. This means you will reject almost all of the resource the server tries to push to you. Even on the first page, modern browsers are very quick to identify resources they need to load, both from headers and the early parts of the document. They load those resources concurrently while they are still parsing the document, so they are rarely blocked for a noticeable time. Meanwhile, single-page sites have evolved to a point where the entire application is contained in one or two heavily optimized, minified scripts. You just load that one script and you're done. Most small images these days are SVG embedded right in the source code, so again, there's little need to push other resources. The only time a modern website makes you to load a lot of unanticipated resources is when those resources are used for tracking and advertising. They can't be pushed because they live on different origins.
- acdha 2y ago> Meanwhile, single-page sites have evolved to a point where the entire application is contained in one or two heavily optimized, minified scripts. You just load that one script and you're done. Most small images these days are SVG embedded right in the source code, so again, there's little need to push other resources. This isn’t true of most websites - look at the developer tools traces - because it’s terrible for performance to optimize for the IE6-era browser design. With those kind of bundles, you have to push a ton of content which didn’t change any time one byte of any resource changes. Since HTTP/2 substantially reduced the cost of multiple requests any site which has repeat visitors will benefit enormously from letting the bulk of the content which hadn’t changed be cached and only refetching the few responses which actually need to be updated.
- mhitza 2y ago> Why wasn't push adopted more widely? It wasn't given enough time, would be my guess. First Apache release that included HTTP2 support was in late 2015, same year HTTP2 RFC finished going through the process. In 2017 there still was browser inconsistency on how server push was handled (one of the reference articles in the sibling comment link). nginx implemented support for push somewhere around 2018 (based on wikipedia information). All those changes need to trickle down. Versions available in stable distros, config defaults etc. First time I've enabled http2 on my Apache servers, was in 2020 (and there are likely application servers out there that still don't support it directly in 2024).
- znpy 2y ago> It was one of the big reasons HTTP2 was meant to be a game changer Probably because it's a game changer only if you're at google/amazon/meta (or slightly smaller) scale. For everybody else its largely a huge complexity addition, and it's essentially ignored.
- bawolff 2y agoI suspect the issue is it wasn't really a game changer at google scale either.
- znpy 2y agoYeah i kinda don’t trust google anymore on going good engineering work. Nowadays they look like the cushy job providers, like banks in the 80s (i guess)
- KaiserPro 2y agoWe enabled HTTP2 in 2015 on the $big_financial_news_site. We had some influential JS people that were very keen to roll it out (they mostly ended up fastly after). I did warn that it would degrade all but the high bandwidth experience. It took a long time for them to "understand" the data, and that HTTP2 was not very useful, especially when compared the impact of changing CDN, or optimising for CDN caching.
- JackSlateur 2y agoServer push was never massively deployed because they may be harmful : the server pushes assets that may be needed by the client, but also may be already cached by the client. In the later case, this is a harmful burden, especially on mobile etc. The server is never able to truly know if the asset is actually required by the client Early hint is better, probably: the server quickly tells the client it will need those assets. The client can then decide if they must be fetched, or if they are already available.
- alex_duf 2y agoI looked into using this, but changed my mind. Say you get a hit on Index.html. you probably want to push script.js and style.css. So now you've pushed a few hundred kbits. Now, the user comes back and asks for index.html again: do you send everything again? Surely the resources are still in the user's cache. If you don't, how do you know what to send? Only the user's browser knows what's in can't and what's not. So you face the choice: speed up first visits but waste bandwidth for subsequent visits, out slow down first visits but speed up subsequent visits.
- liveoneggs 2y agoCan you explain the problem is solved better than Link headers, websockets, or SSE?
- SahAssar 2y agoWebsockets and SSE are completely unrelated. Link headers can be used for preload, but until 103 Early Hints it could not be sent before the body content was processed on the server (unless your body content did not affect your headers, which is quite rare).
- WhyNotHugo 2y agoIt’s really hard to architect around http push. Say I have a website in Python/Django, where I know that a page uses certain images. In order to use http push, my app would need to stream those images itself, rather than let a CDN or even Nginx do it. I suppose that some solution could have been implemented so that my Python app can tell nginx to stream certain static resources over a given connection… but the tools for that never surfaced. Most HTTP frameworks don’t support push.
- rrr_oh_man 2y ago> This means that if webservers and websites use push and don't test in Firefox, this feature can potentially cause websites to stop working only in Firefox That is one reading of the situation. The other would be: All other browsers reject HTTP/2 Push & gracefully ignore it, but Firefox majorly trips up in edge cases. (quote: «It seems that Firefox is resetting the connection because it encounters an uppercase character in the header names»).
- jorams 2y agoYour reading doesn't really make sense. Other browsers don't implement the specification. Firefox does. The specification is very explicit about how this violation should be treated. Those webservers and websites have a broken implementation. Had they tested with any spec compliant client they would have noticed it being broken.
- deleted 2y ago[deleted]
- chrismorgan 2y agoIt could just as easily have gone the other way: a new spec implemented only in one browser (typically Chrome, as it most frequently ships things first, often incomplete) and, badly implemented by a server, causing such a problem.
- swiftcoder 2y agoI mean, that's pretty much how we got HTTP/2 Push as a standard in the first place, so it's somewhat fitting we lose it the same way.
- rdsubhas 2y agoThey make it clear in their post: > Firefox has continued supporting HTTP/2 push as this wasn't too large of an effort until recently. > However in the past few months we've encountered some webcompat bugs only affecting Firefox through HTTP/2 push They are clearly saying that recently there has been bug report, and this blog post is to do exactly what you mentioned as other browsers do: reject H2 push and gracefully ignore it. There does not appear to be any hiding here.
- v3ss0n 2y agoHTTP/2 Push was really useful when we wanted to avoid Websocket , Ajax Polling , Long Polling. The problem with not adopting is due to Websocket getting more popular and Devs stop caring about HTTP2 altogether. But there are many cases Websocket is overkill , even text chat application dosen't need websocket. Similar functionality can already be achieved by using SSE/Eventsource although HTTP/2 Push was more powerful.
- creesch 2y agoIn what practical sense are websockets overkill? As far as I know, the resource usage isn't really all that different. It also isn't as if websockets are that difficult to use these days. I am also skeptical of the "doesn't need websocket" statement. It is technically true that you can use other technologies. But, WebSockets provide bidirectional communication, while Ajax Polling and Long Polling are used for periodic updates. HTTP/2 Push is more suited for pushing resources or data from the server to the client. As far as my understanding goes the use case there is specifically aimed at pushing resources the server "knows" the client will need as well without the client requesting them. I am sure that with some creative code you can also use this to implement a chat of sorts but that is a bit besides the point.
- jongjong 2y agoWell I'm not surprised. This is usually what happens when you take an existing protocol meant for a specific purpose and try to tack on additional functionality on top which has little to do with the original design goals of the protocol; you're almost always better off starting out with a low level protocol and going straight for your use case. In that respect, I think WebSockets already solved the problem of bidirectional communication elegantly. In terms of reducing latency when loading deep file/script hierarchies, the <link> tag with rel="preload" or rel="modulepreload" is an excellent, simple construct.
- bawolff 2y agoHttp/2 was a new low level protocol and http push was never really about bidirectional communication.
- _heimdall 2y agoHTTP/2 Push would have fit the exact same use case as preload links with reduced latency. The whole point was for the server to send the content that should be preloaded as a header so it could be preloaded before the link tag was ever sent or parsed. This is less useful, in my opinion, for pages that support streaming but for any request that hangs until the entire HTML page has been rendered server-side could have noticeable gains.
- klabb3 2y ago> HTTP/2 Push would have fit the exact same use case as preload links with reduced latency. I’m no expert, but it sounds like this still breaks a lot of assumptions about the 1:1 request-response based protocol that http is. If there’s no request, headers are… inferred? And the determination of what needs to be sent requires the server to model relationships between resources, as well as infer user-agent behaviors. Anyway, I never looked into it deeply. But I always felt this was a massive complexity burden spanning browsers and servers, for essentially bootstrapping cache performance only. Given that websites often don’t even cache properly, don’t bundle their bloated JS, etc, there’s so much low hanging fruit that needs addressing first anyway. So I’m happy it’s dying. Bank for the buck is crucial, and complexity creep is suffocation.
- lol768 2y agoI'm a bit sad to finally see the death of HTTP/2 Push. It was a neat idea, with poor framework uptake that never really got the attention I think it could've benefitted from. The .NET folks never bothered shipping it; there was a basic implementation in nginx. It was always hamstrung by lack of cache digests too. Chrome ultimately got rid of it with a justification partially along the lines of "nobody would notice anyway" and because re-architecting everything to use UDP (because that works great with NAT, doesn't it?) was apparently more important.
- kstrauser 2y agoI never had problems with UDP and NAT, but if that’s the thing that gets people annoyed enough to migrate to IPv6, I’ll shut my mouth and smile.
- LegionMammal978 2y agoI'd imagine that an IPv6 host behind a stateful firewall would have very similar issues with UDP connection tracking.
- 01HNNWZ0MV43FF 2y agoIt might require a firmware update but I see a clear text connection if here in the quic example https://quic.xargs.org/ https://quic.xargs.org/ Assuming that the IP port 4-tuple is not enough I never have trouble on my networks with QUIC or other popular udp protocols like WebRTC or DNS
- LegionMammal978 2y agoI also haven't had any issues with UDP behind an IPv4 NAT, nor behind an IPv6 firewall. I'm just suggesting that at whatever rate people do have issues with UDP behind an IPv4 NAT, people would similarly have issues behind an IPv6 firewall.
- kstrauser 2y ago
- _heimdall 2y agoI never found the explanations given for why HTTP/2 Push failed compelling. Google usually just refers to a blog post from Jake Archibald [1], but that post seems to call out all the ways browsers poorly implemented it rather than reasons the protocol itself wouldn't work. Browsers already support preload links, which should function effectively the same as a Push header. Why couldn't that same code have been used for Push, including all the existing handling for things like caching and authorization headers that Jake called out as challenges with the 2017 implementations? [1] https://jakearchibald.com/2017/h2-push-tougher-than-i-thought/ https://jakearchibald.com/2017/h2-push-tougher-than-i-though...
- youngtaff 2y agoFor security reasons pushed resources have to be treated as a special case until they're claimed by the page, amongst other things this means they need a separate cache until they're claimed
- paulddraper 2y agoExplain why security demands a separate cache?
- bawolff 2y agoCache poisioning attacks.
- paulddraper 2y agoOh I see. Push was not limited to the same host. Which would have been an easy fix.
- bawolff 2y agoConnections arent limited to the same (virtual) host. Additionally, to prevent cross page tracking, browsers use a separate cache for subresources loaded from different top level domains. Anyways, it is trickier than it sounds at first glance.
- pornel 2y agoYou can get some of this speed back with HTTP/3 0-RTT start, and use 103 Early Hints to make browsers preload assets early. This combo has an advantage of being semantically backwards-compatible with HTTP/1 (reverse proxies, load balancers).
- youngtaff 2y agoRemember talking to Mike Belshe (SPDY, and H2 spec co-author) before H2 was standardised and even then they were trying to get it dropped from H2 as the benefits were hard to realise, there were plenty of issues and foot guns too One of the largest issues was 'over-pushing' through either sending something that was already in the browser cache, or just trying to push way too much non-critical content (I've seen some truly bad cases of push actually making the page slower to load) There were some proposals to allow the browser to communicate to the server what was already in the local cache but these ran into some issue HTTP Early Hints and Resource Hints have largely removed the need for H2 Push in a way that's much easier to implement, avoids unnecessary fetches and it's easier to reason about too
- deleted 2y ago[deleted]
- saurik 2y agoIt is extremely annoying that all of this sudden discovery that http2 push didn't work hasn't come with some kind of apology to everyone out here who had tried to explain before why this wouldn't work and why it would be a dangerous waste of time just to be shouted down for years by the people insisting it was going to be epic as the much-smarter people at Google knew what they were doing and really needed this so we should just let them ram it into the spec. We should be extremely conservative about what we put in the spec and stop just throwing in speculative stretch goals because some people at Google thought it's a good idea.
- gary_0 2y agoTrying to improve HTTP and Web performance strikes me as pretty pointless when I have enough bandwidth to stream 1080p video, low enough latency to play real-time games, and a CPU 1000x more powerful than the one I first went online with. The only thing slowing browsers down is the mind-boggling amount of ads, trackers, and junk weighing down most sites. And the tech I use to fix that issue is uBlock Origin, not anything that Google invents. Everything Google forces into Web standards these days isn't for ordinary developers like us. It's so they can cram more ads in our faces or save 0.1% on their datacenter budget.
- endofreach 2y agoAs currently there are more new browsers coming along, maybe it's time for a new spec, exclude big corps & start from scratch with all the good stuff. I mean the sad reality is, the best thing that could happen is for mozilla to die. Then google would get into monopoly issues & we'd end up somewhere similar. Just now, the people who really care, have the chance to lead it & mozilla mustn't die.. FORK THE SYSTEM!
- TheNewsIsHere 2y agoSlightly tangential rant — I use an application firewall to actively allow/deny network connection attempts. It takes a bunch of tuning for the first month or so, but it’s then far less intrusive. It’s worth a week of click-ops’ing all of your network usage. Paired with DNS adblocking and enabling JavaScript on a per-domain basis, I am continually astonished at how garbage ridden the Internet has become anytime I’m outside of my network moat. I don’t think there’s any one answer, but I think a lot of it is laziness, greed, and a lack of care. Seriously, why is Stripe on (figuratively) _every_ page? Maybe that’s just lazy development. But why does Azure’s US marketing/pricing site load Google Brazil includes? Why does the 1Password web vault need to connect to marketing clouds? I was visiting a site yesterday where the mobile experience was basically top to bottom ads, and then when you start scrolling one of those annoying “Login or sign up with your Google Account” popups took up the whole bottom half. The site was basically unusable.
- dang 2y agoRelated (I think). Others? Removing HTTP/2 Server Push from Chrome - https://news.ycombinator.com/item?id=32522926 https://news.ycombinator.com/item?id=32522926 - Aug 2022 (201 comments) A Study of HTTP/2’s Server Push Performance Potential - https://news.ycombinator.com/item?id=32097013 https://news.ycombinator.com/item?id=32097013 - July 2022 (2 comments) HTTP/2 Push is dead - https://news.ycombinator.com/item?id=25283971 https://news.ycombinator.com/item?id=25283971 - Dec 2020 (168 comments) Blink: Intent to Remove: HTTP/2 and gQUIC server push - https://news.ycombinator.com/item?id=25064855 https://news.ycombinator.com/item?id=25064855 - Nov 2020 (133 comments) We're considering removing HTTP/2 Server Push support - https://news.ycombinator.com/item?id=24591815 https://news.ycombinator.com/item?id=24591815 - Sept 2020 (2 comments) Performance Testing HTTP/1.1 vs. HTTP/2 vs. HTTP/2 and Server Push for REST APIs - https://news.ycombinator.com/item?id=21937799 https://news.ycombinator.com/item?id=21937799 - Jan 2020 (71 comments) How HTTP/2 Pushes the Web - https://news.ycombinator.com/item?id=18216495 https://news.ycombinator.com/item?id=18216495 - Oct 2018 (16 comments) Nginx HTTP/2 server push support - https://news.ycombinator.com/item?id=16365413 https://news.ycombinator.com/item?id=16365413 - Feb 2018 (63 comments) HTTP/2 Server Push on Netlify - https://news.ycombinator.com/item?id=14798271 https://news.ycombinator.com/item?id=14798271 - July 2017 (23 comments) The browser bugs and edge cases of HTTP/2 push - https://news.ycombinator.com/item?id=14445728 https://news.ycombinator.com/item?id=14445728 - May 2017 (20 comments) A Guide to HTTP/2 Server Push - https://news.ycombinator.com/item?id=14077955 https://news.ycombinator.com/item?id=14077955 - April 2017 (59 comments) HTTP/2 Server Push - https://news.ycombinator.com/item?id=13990074 https://news.ycombinator.com/item?id=13990074 - March 2017 (2 comments) HTTP/2 Server Push and ASP.NET MVC – Cache Digest - https://news.ycombinator.com/item?id=13659962 https://news.ycombinator.com/item?id=13659962 - Feb 2017 (9 comments) Accelerating Node.js Applications with HTTP/2 Server Push - https://news.ycombinator.com/item?id=12296922 https://news.ycombinator.com/item?id=12296922 - Aug 2016 (6 comments) Rules of Thumb for HTTP/2 Push - https://news.ycombinator.com/item?id=12224258 https://news.ycombinator.com/item?id=12224258 - Aug 2016 (25 comments) Google's Rules of Thumb for HTTP/2 Push - https://news.ycombinator.com/item?id=12223352 https://news.ycombinator.com/item?id=12223352 - Aug 2016 (2 comments) HTTP/2 Protocol for iOS Push Notifications - https://news.ycombinator.com/item?id=11175980 https://news.ycombinator.com/item?id=11175980 - Feb 2016 (13 comments)
- deleted 2y ago[deleted]
- deleted 2y ago[deleted]
- notpushkin 2y agoI was just thinking about it yesterday! It would be a nice way to implement REST APIs for related resources. For example, if we have a /books collection with related authors for each book, client could request books with authors. Server would then fetch the books and authors in a single DB request, return just the books, and push each author as an additional response. Of course, this can be implemented with other mechanisms (JSON:API [0] comes to mind), but this seemed like a nice idea to explore. Guess we’ll never know! [0]: https://jsonapi.org/ https://jsonapi.org/
- Darulquran-123 2y ago[flagged]