React is Cancer: How We Let the Web Burn with a Smile

A Brief History of Chaos

JavaScript was born as a toy. A hacked-together scripting language for Netscape in the 90s, rushed into existence in 10 days. Since then, the frontend world has been on a wild ride:

1999–2004: DHTML nightmares. jQuery saves the day.
2010–2012: MVC/MVVM boom: Backbone, Knockout, AngularJS. Too many ideas. Nothing sticks.
2013: React drops. Everyone’s confused.
2016–2020: React wins the war, mostly by being less awful than Angular 2.
2023–2025: React is the de facto standard. That should feel good, right?

It doesn’t.

React’s rise didn’t fix frontend chaos. It amplified it. It enshrined complexity, pushed architectural ambiguity, and created a culture of hype-driven cargo culting. Now we’re stuck. And worse — we’re telling juniors this is normal.

Separation of Concerns? Never Heard of It

React’s most fundamental sin is philosophical: it throws away Separation of Concerns. Logic, markup, styling, state, side effects — all mashed together in JSX soup. The line between what should be and what can be is obliterated.

return (
	<div onClick={() => {
		if (user.isAdmin) {
			setToast('Nope');
		} else {
			doSideEffect();
			setData(items.filter(i => i.ready).map(i => ({
				...i,
				timestamp: Date.now()
			})));
		}
	}}>
	{list.filter(i => i.active).map((item, idx) =>
		<span key={idx}>{item.name.toUpperCase()}</span>
	)}
	</div>
);

This isn’t an edge case. This is the React way. The chaos is unavoidable by design.

Meanwhile, Vue and Svelte encourage templates, scoped logic, and readable separation between concerns. You can still shoot yourself in the foot — but you have to try. React hands you a shotgun and says, "Have fun."

Hooks: Functional, But Only On Paper

Hooks promised to clean up class-based components. In reality, they replaced one mental model with something worse: a minefield of lifecycle guessing, dependency arrays, and fragile logic chains.

useEffect(() => {
	const unsub = subscribe(user.id, (msg) => setData(msg));
	return () => unsub();
}, [user.id]);

If you forget a dependency, things break silently. If you include the wrong one, it loops forever. You’re not doing it wrong — the system is hostile.

Compare with Svelte or Solid:

createEffect(() => {
	const unsub = subscribe(userId(), updateData);
	onCleanup(unsub);
});

Clean. Predictable. Built to guide, not punish.

The Infinite Ecosystem of Everything (and Nothing)

React has the biggest frontend ecosystem. But size doesn’t equal stability. You’re expected to:

Pick a router (React Router? Wouter? TanStack?)
Pick a state manager (Redux? Zustand? Recoil? Context misuse?)
Pick a form lib (Formik? React Hook Form? Custom?)

And none of it fits together out of the box. React has no opinions. No baseline. Everything is DIY. That’s not freedom — it’s fragmented responsibility.

Vue and Svelte offer tighter ecosystems. They may be smaller, but they have consistent philosophies. They offer you guardrails. React gives you an unassembled IKEA kit, throws away the manual, and sets the room on fire.

YDD: YouTube-Driven Development

React’s community has grown so large, it’s lost any architectural soul. Tutorials, course bro content, hot takes, and trend-chasing dominate. Developers hop from one library to another like TikTok dances:

"Bro, ditch Redux, Zustand is better. No wait, Jotai. No wait, signals are the future."

YDD (YouTube-Driven Development) rules everything. Substance loses to hype. Stability loses to novelty.

Vue, Svelte, Elm? Smaller communities. But more thoughtful. More principled. Focused on building good software, not chasing stars.

Okay, But React Isn’t All Bad

Let’s be fair:

✅ Componentization is powerful.
✅ Re-rendering is predictable (mostly).
✅ It taught a generation functional composition (kinda).
✅ The ecosystem is mature (in quantity, at least).

React is not a total disaster. It succeeded because it was just better enough than Angular at the time. But in doing so, it became the center of a frontend universe that normalizes dysfunction.

TL;DR: React Didn’t Fix Frontend. It Weaponized It.

Area	React	Vue/Svelte/Solid
Markup Style	JSX chaos	Templates, clean logic
State/Effort Model	Hooks + Effect hell	Signals / Stores
Ecosystem	Big, scattered	Small, cohesive
Architecture	DIY mess	Opinionated sanity
Community Culture	YDD, churn, hype	Thoughtful, stable

React is a tool. But the way it’s designed and taught encourages mess. And now it’s everywhere. It’s the default. The baseline. The disease we all caught by accident.

There are better ways to build frontends. But first, we have to admit:

React is cancer.

And we need to stop pretending it’s the cure.