Should in-between browser compatibility issue be handled?

Question

When we talk about browser compatibility, most of the time we define it as a list of minimum version of browsers the application will support. e.g.:

IE9+, Firefox 25+, Chrome 32+, etc.

When testing compatibility, we typically test the baseline and the latest version. If we want to make it more extensive, we can use tools such as SauceLabs to test all versions in between.

My question is not about if we can test for the compatibility, but rather should we or how should we consider which version of browsers should be supported.

For example, I encountered an issue with aurelia-polyfills.

The library fails to load in Firefox 35 at the line (function(o, s) { ... }(Object, Symbol)) with Symbol is not defined.

This code works fine in Firefox 29 and in latest (54). I don't know how many versions before and after 35 would experience this issue.

This issue, IMO, has more to do with Firefox and less with the library, as it should dereference Symbol as undefined and let the code check and handle it properly. It is similar to the issue that IE doesn't handle keywords such asenum properly.

Now, the question is, should this consider as a bug for the library or the library should declare this in-between version of Firefox is not supported?

On one hand, it makes sense to exclude this version as it is the "wrong doing" of the browser. Library author can't take the beating on any and all issues made by the browser. Especially nowadays new releases of browsers are much more frequent compared to the past. Some bugs are bounded to happen.

On the other hand, this is precisely what "browser compatibility" is about and should be handled. The library author can't ignore them because they are used by the customer. But in this particular case, it just won't work because whenever accessing Symbol will crash the system.

Another point is that when the browser compatibility table is updated, it will "shift" to those versions that have the problem.

That means either updating the compatibility table from "IE9+, Firefox 25+, ..." to "IE10+, Firefox 35+,..." and "WTF", or forced to have a much narrower table, e.g. "IE10+, Firefox 52+,...".

I think that we have to either bite the bullet and continue to support "all-recent versions" or leave some holes in the compatibility table and only support the "golden" versions.

What would you recommend?

btw, I have nothing against Firefox and only using it as an example.

Answer 1

I will add a voice to the alternate viewpoint of supporting a range of browser versions.

Even with browsers that "autoupdate" the fact is that there is an adoption time. Sure, you can say that most browsers will switch to a new version within N days, but there's a tail after that. And from a professional context, that tail is LONG. It is a non-trivial amount of time before all users are off a particular browser.

There's a funnel when it comes to users using a service. What % of folks end up on your website -> what % of those folks can use your website (due to old browsers) -> what % of those users click the sign up button -> .... -> what % of those users buy your product (or whatever).

Removing 5% of that funnel at any point has a cost. It's a cost that should be considered not only when doing testing, but also when deciding which browser technologies to support.

TL;DR: Come at this from the point of view of supporting as many customers as you can. Only make your funnel smaller when the gains you make elsewhere exceeds the cost of making your funnel smaller.

For example, we decided that it was worth it to cut of < IE10 so that we could move our site to flexbox. That was worth the n% of customers that were using the site, because our dev team could make a more sustainable product that materially benefitted all of our other users.

Answer 2

For auto updating browsers (Chrome, FX, Safari, Edge) support the latest version only. Corps can freeze on older versions, but supporting that older version is something you can both charge for and recommend against. If a client wants FX35 support then that would be a very singular request - it's not cost effective for you to spend time testing for it when you don't know they're going to want it. Spend that money on the versions the vast majority of customers are going to need first.

Also note that old versions are extremely high risk - FX35 is missing 2½ year's worth of security patches, I wouldn't even let a machine with it installed access our network.

For IE it's much messier. Currently 'live' out there are IE8, IE9, IE10 and IE11 - all with their own quirks and incompatibilities, all no longer actively developed and all pretty much dead in the non-corporate space (non-tech users with a new PC have to go out of their way to get IE11 rather than Edge, so won't). IE11 is a zombie - MS have stopped developing it and only patch security issues (until 2025), but it still shambles on consuming the brains of web developers everywhere.

For some time I think the best strategy in IE has been to support IE11 fully, and offer cut-down/missing functionality for IE8, 9 and 10 with very limited testing. If you find a bug in IE8 turn that feature off and recommend upgrading - IE8 users don't expect smooth animations and rich UI anyway.

This really comes down to a business case: supporting lots of old versions will cost you money, what money will it make? Define the budget that you have for supporting those old versions and then decide on the testing and support strategy that fits.

Answer 3

I would go for the latest versions of all browsers, with some exception:

• I have a customer, which has frozen a google chrome version for all their PC's.
• In another case their are firefox-versions which are fixed in a stable release of a linux distribution. Those cases are handeled individually.
• I would provide an issue log for browser compatibility issues open for all users of the web site, so that an issue can be discussed in the ocmmunity and within your testing and development department, if this is important enough to handle a specific version of a specific browser.
• Which such a platform you can also communicate, which versions you have tested which your latest release. And defend your "latest version strategy".