15 ms·
HTTP/2 Push is dead
- thecompilr 6y agoWhat is dead may never die. Server Push never gained any traction sadly, despite having a great potential.
- Strom 6y agoGoogle never liked HTTP/2 push. I've been hosting some pages on Google App Engine and push never got implemented for the mandatory frontend proxy.
- detaro 6y agoGoogle also "invented" it as part of SPDY (it's surprisingly difficult to find a clear reference, but I'm reasonably sure it was in pre-standardization-process SPDY too). For this kind of thing, one one hand it doesn't make much sense to apply a global opinion about a relatively minor thing to a company of that size, where different teams and their goals aren't aligned or even at odds. On the other, I wouldn't take GAE not having a feature as a big signal: its best days clearly are over and it's lacking/buggy/... in all kinds of places sadly.
- kmonsen 6y agoYou are correct, I worked a bit on spdy back in the start. Also correct in that google doesn’t have one opinion. Even inside the chrome team there were many different opinions.
- mankyd 6y agoAs someone who helped contribute to Google's pre-HTTP2 apache/mod_spdy push, I am sad :(
- 0xbadcafebee 6y agoMan. Modern internet standards are some serious turd-polishing. First you have HTTP2, which goes from a plaintext protocol to a binary protocol. But it's backwards compatible with HTTP/1.1, because... nobody in the entire world will consider adding a new internet service port (81, 442, etc). In 100 years, we will still be using ports 80 and 443 - not because it's a good idea, but because literally every business in the world just refuses to update their software. Then you have HTTP3. Where we do the above, but with a transport protocol. Literally nobody in the world wants to update their protocol stack, hardware, middleware, software, etc to add a new internet protocol. So we clamber on top of another protocol (UDP)'s back, to create a new protocol (QUIC), and then clamp yet another protocol (HTTP3) on that. So we have IP->UDP->QUIC->HTTP3. Which is backwards compatible with HTTP/1.1, because, you guessed it.... nobody wants to add ports 82 and 440. The next step is going to be nobody wanting to update to IPv6. So they will probably implement IPv7, and stick it on top of whatever replaces UDP on top of IPv7. Then add on QUIC, and HTTP4. So it will be Ethernet->Arp->IPv4->UDPv4->IPv7->UDPv?->QUIC->HTTP4. All because nobody wants to update their software to use an existing, widely supported, network layer protocol. Or transport protocol. Or application protocol. Meanwhile, anything that wants to use the new features of the new protocols needs to implement 4 new protocols. It's going to keep going like this until we have some new Apple-ish company come along with brand new everything, and everyone will flock to it, and the only way anyone will be able to use it will be to implement the new snowflake protocols. To even connect to the devices you'll need to have a license agreement with them and establish a secure connection that only that company has the keys for (because "privacy", because the internet standards are so ancient they never adapt fast enough and hackers basically compromise all web security). And those new things will become a de-facto standard. So we'll never have, say, a new TCP, but we'll have an AppleTCP.
- 40four 6y agoThat was an amazing rant. I really respect the level of detail and dedication to the rant.
- perryizgr8 6y ago> The next step is going to be nobody wanting to update to IPv6. I hate that IPv6 has such low usage, and it is exactly the same problem you describe. We have a protocol meant to replace IPv4 and eliminate several kludges (NAT) in the process. But guess what? People would rather keep on hacking the previous protocol to the extremes than learn and implement a newer better system. IPv6 is better than IPv4 in literally every sense, but your sysadmin can't be bothered to deviate even slightly from her decade old knowledge. So now we have all sorts of v4 in v6 tunneling, someone even talked about NAT for IPv6 (WTF?!). The end result is that v6 is incredibly complex due to these backward stuff. We need Apple to deprecate IPv4 like they did 32 bit. Otherwise companies will keep us locked into old technology for eternity.
- donatj 6y ago> IPv6 is better than IPv4 in literally every sense The addresses are harder to type, harder to yell across an office while setting up equipment, and impossible to remember. I honestly think this is it’s major failing that has prevented wider adoption. Aesthetics make a big difference, like it or mot, and IPv6 is far less accessible than IPv4. Beyond that, IPv4 is arguably generally simpler for someone not well versed in networking to get a baseline understanding of.
- mbrumlow 6y agoIts a shame. Because it would do away with nasty packing strategies like webpack. I always built my go+react apps to avoid webpack,on service start it would scan all the includes from the each entry point and built out a map for each entry point. On request I would push all the dependencies. It was really nice. :(
- dhritzkiv 6y agoWhile I think webpack is a beast in its complexity, it and other bundlers can/do output based on the strategy you described. It emits entry point bundles, as well as smaller chunks, many of which remain unchanged between releases. All of that gets pushed out. I think it works pretty well.
- earthboundkid 6y agoPush doesn’t work with cache, so that strategy was less efficient than just concatenating everything.
- sanxiyn 6y agoPush can work with cache (the article mentions Cache-Digest proposal which directly does this) but it never got implemented for reasons unclear to me.
- VWWHFSfQ 6y agoI guess I never really understood the problem that wasn't just solved by old-school tcp keepalive and pipelining HTTP requests for more assets/files from the CDN
- davedunkin 6y agoI hope browsers implement 103 early hints. I’d like to tell the browser to preload assets while the server is still working on the response, which may take a significant amount of time to determine if the response is 200, 401, or 404. https://evertpot.com/http/103-early-hints https://evertpot.com/http/103-early-hints
- rhacker 6y agoI was seriously thinking the domain name was a play on an HTTP status code: "Ever Tea Pot", but went to the root and it is just the guys name "Evert Pot".
- swirepe 6y agoI was thinking the same thing
- JxLS-cpgbe0 6y agoYou're confusing him with his wife, Ima T.
- treve 6y agoEvert here =) first and last name are dutch. I moved to Canada and joked about naming my son Jack ;) I didn't like my name growing up, but as an adult I'm grateful I have a kinda weird but more memorable name.
- ksec 6y agoYes to me 103 is more exciting then even HTTP3. Do we know if Safari, Chrome and Firefox even plan to have it implemented?
- fiddlerwoaroof 6y agoIs HTTP/1.1 pipelining basically dead too?
- ArchOversight 6y agoYes. There are no current browsers that implement HTTP/1.1 pipelining, and even various proxies and others don't support HTTP/1.1 due to head of line blocking and proxy errors. Also, with HTTP/1.1 pipelining if a client sends multiple requests but one of the requests results in an error and the server closing the connection all of those other requests are lost.
- latch 6y agoUnrelated, but I just want to rant. I hate how the minimum possible websocket message is smaller than the largest possible websocket header. You can have an entire message that's 6 bytes, but you can also have a header that's 14 bytes. I'm curious why they added support for massive messages (2^32+1). And I'm curious how much bandwidth would be "wasted" if instead of supporting a 6 byte header (for messages 0 - 125 bytes) and 10 byte header (for messages 126-2^32) they just made it fixed for 0-2^32 with a 9 byte header.
- robocat 6y agoI think you are ignoring the TCP/IP overhead. Add: 22 bytes Ethernet Header 20 bytes IP Header 20-32 bytes TCP Header 16 bytes Ethernet Footer That's 78 to 90 bytes extra - trying to optimise the websocket packet size is really not going to help much. See https://www.researchgate.net/publication/269031593_Performance_evaluation_of_Websocket_protocol_for_implementation_of_full-duplex_web_streams https://www.researchgate.net/publication/269031593_Performan...
- latch 6y agoI'm trying to simplify parsing.writing by making it less variable. The spec is the one with the optimization to save 3 bytes for short messages. Why?
- robocat 6y agoAhhhhh, well, perfection is hard to achieve eh? Off-topic, but all those little cuts do sting. Of course, if they did it your way, surely someone else would be ranting about why they wasted bytes unnecessarily.
- xxs 6y agoWhat kind of optimization. From performance point of view 64bytes would be a cache line (on most architectures), so if the message fits there, it's good enough.
- Tepix 6y ago
- rektide 6y agoDevelopers asked for some support for PUSH frames in Fetch for 5 years[1]. There were a couple api ideas that came up. But no browser ever implemented anything to make Push actually useful & interesting to developers, beyond the very basic & boring. It is extremely unfortunate (cruel?) that we will no longer have any chance to see what these very interesting capabilities are good for. This is a seriously difficult change, but I don't think it should be ended. I hope a browser with more courage can help it along, and that the world has a chance to use this amazing enhancement to HTTP. [1] https://github.com/whatwg/fetch/issues/65 https://github.com/whatwg/fetch/issues/65
- pvg 6y agoRecently: https://news.ycombinator.com/item?id=25064855 https://news.ycombinator.com/item?id=25064855
- oscargrouch 6y agoThe writing is on the wall about Google being the most powerful actor mandating what should die or live in the web specs. The monopoly would be bad alone, but to make things worse, they have a clear conflict of interests giving they are a powerful cloud computing operator that is very interested in centralizing, controlling and monopolizing data (which is the 21th century gold). We can expect a "war" against anything really distributed from the big tech once some tech that would menace their centralized control over our data. Have them dictating what can or cannot be in browsers will prevent new blue seas on tech, and i expect that if nothing changes the picture, even the startup scene will be pretty slow, giving it will have not much left to do, and the ones who find out a way, will probably be bought and left in a dump of vaporware. Lets get a blue sea as an example, AI.. they have access to massive data no one have, and there's no way any AI product can compete with that in the long term. So your browser being a "dumb" client that fetch and save everything in the cloud is the only thing they need, and the thing they will optimize for. And this is not in the users or devs best interests, much less the civil society as a whole.
- tootie 6y agoApple has deliberately ceded this ground by focusing on native apps and Microsoft are still in purgatory for their crimes of the IE era. Google won this war by attrition.
- donatj 6y agoIs there a mechanism for communicating to the server that the http2 implementation doesn't support push beyond parsing user agent? Or are we just going to end up with servers pushing to chrome and it just ignoring it? That sounds even worse.
- sanxiyn 6y agoYes there is. HTTP/2 has SETTINGS frame to communicate implementation capabilities, and SETTINGS_ENABLE_PUSH is standardized to communicate push support. Chrome will send SETTINGS_ENABLE_PUSH set to zero, so no user agent parsing is necessary and all compliant implementations should handle this transition transparently.
- rhacker 6y agoTwo of my co-workers migrated completely to Firefox in the last month. I don't expect Firefox to regain it's market share, probably ever, but I can't stand Chrome, it's ads, it's backer. DDG extension installed.
- zelly 6y agoThrift and gRPC can "push" until the cows come home (streaming). Use the correct tool for the job. HTTP is for hypertext documents, not APIs or RPC.
- psanford 6y agoWell, gRPC uses HTTP/2 as its default transport so I'm not sure "HTTP is for hypertext documents" is valid. Note that gRPC never used HTTP/2 PUSH_PROMISE frames so it isn't affected by their removal. gRPC's bi-directional streams have to be initiated by the client.
- abofh 6y agoAnd telephones are for phone conversations, not squealy modems! Use an ISDN line like god intended!
- zelly 6y agothis but unironically
- rswail 6y agoHTTP is for REST, REST is an API style for client/server interactions. RPC is another API style, but it's more tightly coupled. RPC has been tried and tried and tried and the same problems happen all the time. Tightly coupled, brittle, hard to upgrade. If by "gRPC" you meant protobuf as a message format, then sure. But TLV based binary streaming has been around for yonks (eg ASN.1). Pushing is an optimization to avoid API round trips, not just the capability of sending a binary stream. Link headers have the same effect as HTTP/2 push, but a client can cache previous requests (and the new 103 Early Hints status). It's a hint from the server that it's highly likely that the Link URLs will have useful information in terms of the current request. It can be seen by caching layers between the client and the server, so they can pre-cache the links or deliver them without server interaction if previously cached. All of that is part of HTTP, which has nothing to do with "hypertext documents". It just happened to be that hypertext documents were the first use of the protocol.
- 6y ago
- sriku 6y ago"link" headers giving asset references with `rel="preload"` work pretty fine for this purpose, although it can kick start only after the first response comes in. Browsers seem to do the right thing on encountering this and all the "preload" resources get fetched "in parallel" .. meaning the server doesn't wait for resource1 to finish before starting to stream resource2 and on the network panel they all seem to be coming in simultaneously .. each taking roughly the same time as when fetched from the server sequentially. Header pattern - link: </somewhere/something.png>; rel="preload"; as="image", </somewhere/something.js>; rel="preload"; as="script", ... This saves considerable page load time if you maintain granular resources and simplifies build and deploy by permitting that granularity in the first place .. and the resources can be parsed+compiled on multiple cores (not sure which browser engines do that, but would be possible). This mechanism seems effective enough in cases where HTTP/2 push could be beneficial. Thoughts by push advocates/critics? edit: .. and this works well with the cache.
- treve 6y agoYeah this works well for specifically this case. There's other cases that I feel we haven't had a good chance to explore, specifically as it pertains to APIs. I wanted to kill many compound HTTP request within a single one. Many API formats pack many logical entities in a single response, and that doesn't work well with caches. Wouldn't it be nice if the next paradigm shift in API development goes towards every entity being addressable, cacheable by a browser but not suffering from the penalty of having to do many requests? That's mostly where my work on Prefer-Push came from. I wrote a much longer article about this use-case earlier this year: https://evertpot.com/h2-parallelism/ https://evertpot.com/h2-parallelism/
- liminal 6y agoA subscription mechanism seems like it would be broadly useful. Maybe "push" is the wrong framing for this? I've seen some efforts in that direction [1], but don't have a real sense of what's coming when. 1. https://braid.news/ https://braid.news/
- bmn__ 6y ago> A subscription mechanism Already specced out and implemented for years. https://enwp.org/AtomPub https://enwp.org/AtomPub https://enwp.org/WebSub https://enwp.org/WebSub https://enwp.org/Webhook https://enwp.org/Webhook
- CyberRabbi 6y agoWeird that all these man hours were spent revising the entire web stack for the sake of squeezing out the last bit of unnecessary latency via quic / http3 just for them to leave out server push. It’s like going from 80% to 99% just to leave off the last 1%. Without going all the way with server push, the logic behind the transition from http1.1/tls/tcp to http3 seems a bit dubious to me. If they aren’t going to go all the way, things already worked well enough IMO. Seems like google is just arbitrarily deciding what they want the web stack to look like.
- AgentME 6y agoHTTP/2 and HTTP/3 are both very useful even without server push. HTTP/2 fixed the issues of HTTP pipelining and made it so multiple requests could share one connection without issues like head-of-line blocking, and HTTP/3 improves things further so that a missed packet in one request doesn't slow down simultaneous requests. Server push was never a critical feature of them. The measured improvements from 2 and 3 were almost always without server push.
- CyberRabbi 6y agoYou can open multiple tcp connections in parallel to virtually eliminate the head of line blocking problem for the vast majority of experiences. The problem has been exaggerated for the sake of justifying http2/3 but in practical terms it barely affects the average user experience. 80% optimal was good enough. On the other hand it reduces cost by a few percentage points for the vanishingly few web hosts large enough such that that would have a meaningful financial impact.
- vhiremath4 6y agoThere is a cost to opening a new connection and having to re-incur multiple roundtrips in order to complete a new TCP and TLS handshake. This is a meaningful overhead savings for folks with a network setup that has high last-mile latency.
- 6y ago
- matsemann 6y ago> Yesterday, the Chrome team announced to remove the feature from their HTTP/2 and HTTP/3 protocol implementations. It's sad and scary that Chrome has such market dominance that they can basically decide how the standards should be.
- TwoBit 6y agoThe only silver lining in this is that at least most of what they are doing is reasonable is some level of good, whereas Microsoft's version of this control back in IE6 days was mostly horrific.
- kmonsen 6y agoI think in this case it’s the opposite. At least back in the day when I worked on this the chrome team (or parts of the team) tried to introduce this feature but it never caught on so now they kill it. Overall I think this is good. Experiment and try new stuff, but if it doesn’t work out kill it off at some point.
- chrismorgan 6y agoPeople often seem to think that HTTP/2 Push was a good thing that could let you improve performance. It really wasn’t. As a performance optimisation tool, it absolutely depended upon cache digests to make any sense, but cache digests were never finished, and so push became a wild guess that would routinely be a pessimisation instead of an optimisation: “why did you clog my pipe up, sending me that megabyte of JavaScript? I already had it!” “But this helped webpack and other such bundlers”—this was never actually true. Even if cache digests had materialised, almost every situation that PUSH frames could have helped with in JavaScript bundling would be better or at least similarly handled in a different way: if you need the resource immediately, you were probably splitting your bundle up too small and should merge the files (though this is certainly not always the case; there are definitely cases where cache digests + push could have done a better job); and if you don’t need the resource immediately, <link rel=preload> is much of a muchness with the push frames, but allows the client to retain control of what it fetches when, which is normally a mildly desirable property; or a service worker could also directly interact with the cache, too. I think it was the other purposes of PUSH frames that were more interesting in their technical possibilities, things like letting APIs kinda return multiple responses to a request. But those possibilities never really eventuated, because once you’re doing things like that, streaming response bodies and WebSockets are mostly easier and definitely more reliably available—though you may end up reimplementing a few pieces of HTTP/2 Push along the way, depending on your use case. So all up, I say of it all that yeah, it was a nice idea, but it ended up just not being useful in practice, because its use cases all either depend on something else that doesn’t exist, or are at least as well handled by something else. I haven’t followed any discussions around this, but as a developer that’s not at all fond of Google my feeling and expectation is that it’s not really “Chrome dictates the direction of the web and they’ve unilaterally killed it” here so much as a general consensus of “we thought this thing would be great, but it didn’t really pan out, and it makes things quite a bit more complex and no one should be actually depending on it, so we’re removing it”—and Google is just the first one to actually do so. I think the average developer here is just thinking that HTTP/2 Push is better and more useful than it actually is.
- treve 6y agoGreat summary. We indeed switch to Websockets for a few things that we would like to have (eventually) used HTTP/2 Push for. To give an example of an issue with this, is that we would like to receive updated resource states when they happen. Receiving these via websocket unfortunately means that they can't really interact with the browser cache, which led us to implementing our own Javascript caching layer. There's many small examples of this where the ideal approach doesn't exist yet, and we're left to imperfect workarounds.
- porker 6y agoDoes this have any effect on Server Sent Events (SSE)? I understand that uses HTTP/2 in some way. https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events https://developer.mozilla.org/en-US/docs/Web/API/Server-sent...
- radiospiel 6y agono
- nikanj 6y agoThe main benefit of HTTP/2 for SSE is having just one server connection regardless of how many naively implemented widgets you have on a single page. SSE works just fine over HTTP, but it does keep a socket open to the server per each connection, so a badly architected client can exhaust server resources quite fast
- dmix 6y agoCan someone give a useful example of HTTP/2 Push being used? I believe I understand how it works but I'm curios what IRL techniques could be achieves.
- tylerhou 6y agoThe blog post links to another one of their blog posts with a real world example for push: https://evertpot.com/h2-push-for-apis/ https://evertpot.com/h2-push-for-apis/
- nikisweeting 6y agoIt's great for pushing a small bundle of static assets (e.g. <250kb) in advance of the HTML to make pageloads first-time visitors nearly instant. (e.g. for landing pages, public sites, blog posts, etc.) It's bad for pushing large bundles of JS and images to every visitor that already has them cached (which is unfortunately how it was misused in practice).
- nikisweeting 6y agoI'm quite sad about this, there was one thing that push was great for, and thats optimizing pageload speeds for first-time visitors. We used it to push about ~140kb of static assets before our django views finished computing, and it noticeably sped up initial pageload speed for first-time visitors, which is the segment we cared most about. It's a powerful footgun, obviously it will only make things worse if you're pushing multiple megabytes of JS to users who already have it cached, but when used sparingly in the right situations it was quite helpful. I even built a django middleware that handled figuring out which assets to push automatically: https://github.com/pirate/django-http2-middleware https://github.com/pirate/django-http2-middleware
- deleted 6y ago[deleted]
- stingraycharles 6y agoOne place where I can still see this working well is landing pages for marketing campaigns; it’s a fair assumption that most visitors there will be first time visitors. Other than that, I’d say that there should be a mechanism where the browser informs the server of what assets they have cached, although I can only assume that may open a privacy can of worms.
- nikisweeting 6y agoThat was cache digests but it's dead unfortunately.
- jlokier 6y agoYou can still do initial page speed optimization using dirty tricks. Some of these were possible even before HTTP/2 Push existed. If you already have fancy middleware to predict the best assets to push for different users, perhaps you can extend the middleware to inject the dirty tricks as well. - data: URLs inlined into the initial page HTML - compression to remove the entropy of base64 encoding - ordinary inlining, e.g. for JavaScript, CSS and (less likely) HTML fragments - Cache and ServiceWorker to allow future pages to use the inlined assets without fetching them a second time Combine the above with heuristics like you were using for HTTP/2 Push to decide what to inline for each user. So a user with an If-None-Match Etag or a cookie has probably seen the page before, and a user with neither probably has not. As others have pointed out, <link> preloads are also available. Although those don't kick in until the first data from the initial page has been received, if there is enough page data, one extra RTT needn't matter for some resources, especially JavaScript that is only needed once the user starts interacting with the page, items far below the fold, and other page resources if it's a single-page application.
- Aeolun 6y agoI don’t understand. How can Google just arbitrarily decide to not support part of a standard because it’s easier for them?
- jabiko 6y agoIt is optional for a client to support server push. It I understand the RFC correctly a client can announce server push support via the SETTINGS_ENABLE_PUSH setting. So if a client chooses not to announce push support it is still standard compliant.
- martin_a 6y agoTwo words: Market domination.
- nolok 6y agoPlease, they're the one that added this in SPDY to begin with. They would do that even if they were a minority player because the reason they actually remove it is that it provides no gain for the work required.
- martin_a 6y agoWell, either it's a standard or not. And if the most powerful browser vendor decides to drop support for standardized features that is a strong "political" signal against the standard and it absolutely has a different meaning...
- nolok 6y agoI don't understand. What makes you think Google or any other company out there HAS to support the entirety of a (non certification dependant) standard if they estimate that they could drop a part of it at no loss / at a gain ? Is your company properly supporting HEAD on its website ? Probably not (treat it as GET), because it's easier and no real loss is incurred. Same here.
- kaetemi 6y agoAlmost as if there's no standard, and everything's really just running on a proprietary Google protocol...
- chmod775 6y ago> The Chrome team has considered removing Push support since at least 2018. The main reason being that they hadn’t really seen the performance benefit for pushing static assets. Because they probably benchmarked Google properties that are already using something akin to HTTP/2 Push, because they are inlining a lot of their assets and data.
- tracker1 6y agoI always thought that push was interesting, but frameworks/tooling integration never made it very approachable to use on smaller scale projects in small/medium businesses. If your userbase is below tens of millions, there's usually other places to spend your development efforts for far bigger impact.
- devit 6y agoLooks like you can achieve an equivalent effect with service workers, like this: 1. If no cookie is set, the server inlines all resources in the initial HTML, along with the original URL in a data attribute if not content-hashed, and sets a cookie. Ideally, the inlining is performed so that base64 data is all together for better compression (this can be achieved by putting all scripts in the header and images in the header as CSS background-image values) 2. If JavaScript is enabled, a service worker is installed, and all the inlined resources are extracted, put in local storage (or in the browser cache if possible) and will be returned by the service worker 3. If JavaScript is enabled, the service worker keeps track of what is cached in the browser and modifies each request to send a bloom filter indicating these resources 4. The server later only inlines resources that are not cached by the client, using either the bloom filter if available, or using server-side tracking As far as I can tell this has equivalent latency and bandwidth requirements to having server push plus cache digests, with the disadvantage of requiring JavaScript and slightly higher overhead, but the advantage of being more customizable.
- untog 6y agoThat's a lot more overhead. For one it requires you to spin up an entire JavaScript engine! I don't know if it was ever implemented but the beauty of doing this at the HTTP level is that (for example) it could be built into the networking layer of iOS or Android.
- nojvek 6y agoThe part I don’t get is why http push wasn’t cache friendly. The idea of fetching a graph of objects is so common. All I want to do as a web dev is a browser client requests a tip REST object or an entrypoint js script. When the client receives that, the client can send the object/script back and all the connnected objects back together to avoid multiple round trips. It makes me sad that this still isn’t a thing (server can reply with more than one cacheable url) To work around this we invent all sorts of tools like graphql, webpack with layers of complexity. Sure there is the problem of what if the client already has the resource. Then the answer is the response can optionally send content or just the url. You then have a 2nd roundtrip to fetch the content the browser doesn’t have. At the end of the day, I just want the browser to essentially rsync-ish a bunch of url/resources from the server.
- treve 6y agoAgreed. We're building HATEOAS-powered SPA's for customers, and we've ultimately built an architecture that reimplements features we wished browsers did better. Our end-goal is ultimately exposing a graph, make everything addressable, have great cache control and means for different parts in the stack to decide when caches should expire. All of these are features of the 'web'. But clients and servers are a bit behind what we would like to see.
- z3t4 6y agoFor a long time browsers, both Firefox and Chrome had a bug that if you HTTP2-pushed resources, it re-fetched them anyway. But since that got fixed in both browsers I've used HTTP2 push extensively when optimizing web applications. For example instead of first requesting the main html-file, parsing it, requesting the css file and parsing it, requesting a background image, etc, both the css and the background image is pushed when the index.htm is requested. This can shave off seconds and drastically improve user experience. I've also implemented commonJS module system where all dependencies are HTTP2 pushed on the first module request. The main advantage with HTTP2 push is that is simplifies development as you do not get penalized for not using resource bundling (which complicates caching).