You have a lot of valid points, in fact I think a lot of us can agree that upgrading and maintaining these frameworks can be a challenge.

You can even go further like your last example and say that all dependencies are a negative.

However I think you’re looking at the issues in the wrong way, and instead of taking a rational solution you jumped directly to extreme.

The main things the ui frameworks give us is a standardized way to implement something that has been historically hard.

You might be able to have 500 developers align on a way to do ui binding but you might not, and hey if you did you also just wrote a framework! Also good luck doing a cross system update or using cross team controls, hope everyone implemented things the same!

So I think the question we should be asking is how do we minimize the effects of changing dependencies (as they will always change) but still leverage them?

I think the proper approach is to minimize the tight coupling on any one framework and instead keep it at an arms length, this is a bit harder with the templates but a lot of the problem is that we “marry” our own presentation or business logic to the frameworks as opposed to exposing things via abstractions that can absorb the impact of that weekly angular version bump.

This isn’t easy and it’s not perfect, but it’s better than writing your own framework (or not 😱) and having a massive enterprise depend on it.

Along with this implementations of micro front ends are becoming easier and by splitting your code out into vertical domains you can also absorb the impact of change and not need system wide refactors.

The JavaScript community has grown very fast the past decade and we’re going through a lot of the pains that things like entity framework, MVC, etc went through as well. The same concepts apply, always keep the framework at arms length.

Good luck, you have truly valid points but I think a more nuanced solution is the better option.