alt Hacker News> This is a danger to the open web in more ways than one. If there is only one functioning implementation of a standard, the implementation becomes the standard.
I still don't understand why this is a problem. As long as the engine implementing the spec - governed by committee formed by entities other than Google itself - is open source. The problem and the waste of resource is how we are behaving now.
The browser engine should become as the Linux Kernel: one engine and different distros.
Replies
I disagree. The more browser engines in use the less damage any one security exploit can do. This matters even with memory safe languages, because logic errors can be just as damaging, e.g. the Log4j exploit.
In theory yes. In practice, only when the interests of the sole maintainer are aligned with the interests of the users; since these can change, it’s best to avoid a monopoly.
Case in point, recent manifest v2 deprecation is generally disliked by the community and no long term blink based alternative exists (that I know of).
> The browser engine should become as the Linux Kernel: one engine and different distros.
Try spending a month with a BSD - personally, I recommend OpenBSD, or (yes) macOS. Alternatively, try ZFS where you've previously used mdadm+lvm+luks+etc.
The difference is like sitting in a chair that has all of its screws tightened. You only notice how bad was your previous chair once you feel there's no wobbling.
Google is killing Manifest V2, and AFAIK all downstream Chromium-based browsers (Brave, Edge, Vivaldi, Opera, etc) will eventually be affected. That should say enough about why having multiple browser engines is a good thing.
Standards already skew heavily to what Google or Google connected individuals want. If everything was Chromium based the situation would be even worse.
Maybe worse is what we need to realize that many of the W3C and WHATWG standards are past the point of saving, and those organisation are no longer a good avenue for further advancement of the web.
Even with the best intentions, the implementation is going to have bugs and quirks that weren't meant to be the standard.
When there's no second implementation to compare against, then everything "works". The implementation becomes the spec.
This may seem wonderful at first, but in the long run it makes pages accidentally depend on the bugs, and the bugs become a part of the spec.
This is why Microsoft has a dozen different button styles, and sediment layers of control panels all the way back to 1990. Eventually every bug became a feature, and they can't touch old code, only pile up new stuff around it.
When you have multiple independent implementations, it's very unlikely that all of them will have the same exact bug. The spec is the subset that most implementations agree on, and that's much easier to maintain long term, plus you have a proof that the spec can be reimplemented.
Bug-compatibility very often exposes unintended implementation details, and makes it hard even for the same browser to optimize its own code in the future (e.g. if pages rely on order of items you had in some hashmap, now you can't change the hashmap, can't change the hash function, can't store items in a different data structure without at least maintaining the old hashmap at the same time).