If you want to create a truly open standard, you _need_ to make it simple.
There are no exceptions to this rule. When a standard becomes harder to fully implement than what your average motivated programmer can do in two months (max!), it _shouldn't_ be considered "open" anymore.
Complicated Standards Lead to Implementation Monopolies
Since implementing a complex standard is hard, you will eventually end up with the implementation that started the earliest and maintained since, being the only implementation that is actually usable. And that implementation will most likely be the one created by the standard's creators.
In cases where the standard's creators don't maintain an implementation like "the web"⁰, the only choices are either the standard dying out because of it's complexity, or the actively maintained implementations requiring tons of effort, with (most likely) companies backing said implementations.
Implementation Monopolies Lead to Extensions
If a big implementation just decides one day that your standard is lacking, they can just extend the parts they want. The two outcomes of this being that:
- The other implementations copy their extensions
- That one implementation getting more users, and eventually, a near monopoly because of a bigger feature set
At that point, the "standard" implemented by said implementations is longer the actual defined standard, but because people will inevitably use the said extensions, any new implementation that wants to be considered usable will eventually need to support said proprietary extensions.
Too Many Extensions Spoil The Standard
Even if you have an "open" extension system, where implementations can all propose and agree on extensions to the standard, you need to be able to keep those implementations in check, so their extensions don't overcomplicate the standard.
Remember: Having a simple standard with a million extensions is no better than a complex standard with no extensions.
Please note that I will be skipping the elephant in the room: "the web", as it has been discussed _to death_.
Matrix is _technically_ an open standard. But because of the complexity it has accumulated over the years, Synapse is the only usable server implementation. Even Dendrite, the new implementation by *the same folk that created the standard*, is barely usable after _years_.
The same applies to Matrix clients, with Element being the only usable client implementation. That space definitely seems healthier than the server space, but the same issues are there.
Various Programming Languages
I will not be specifying any language, as I might get any specifics incorrect, but a general pattern I have seen is that most programming languages have only a few compiler/interpreter implementations, even though the language is standardized in some form.
This example actually has some interesting reasoning behind this issue on top of the complicated standards:
- Writing a compiler/interpreter can be hard.
- Especially if the current implementations do optimizations or other "clever" tricks.
These issues can devolve into arguments regarding seeing the complexity of these issues as a part of the standard, and other "technology is too complicated in general" arguments, which I will not dive into here.
X Display Server
The X Display Server standard got so complicated, the people developing it decided to abandon it entirely and create Wayland.
It probably didn't help that most of the standard was no longer being used, and a lot of extensions are required for its use today.
Wayland probably will also suffer the "too many extensions" problem at some point, so I am looking forward to that too...
0: Well, Google, Mozilla and Apple all had a hand in most of the "modern" parts of the standards...