Why I Do NOT Like React

React is one of the most popular JavaScript libraries, but despite its widespread adoption, I’ve never been a fan. Here’s why I find it confusing, outdated at its core, and unnecessarily complicated—and why I’ve decided to create my own solution, Dodo Framework.

1. Confusing and Hard to Understand

React's learning curve is steep, especially for beginners. While it promises simplicity, the reality is different. You have to understand JSX (a mix of JavaScript and HTML), components, state management, and the virtual DOM just to get started.

Moreover, React often requires developers to juggle between different concepts, such as lifecycle methods and complex state management libraries like Redux or Context API. For newcomers, it’s overwhelming; for experienced developers, it’s tedious.

2. Outdated Roots

React was created in 2013, before many modern JavaScript features like ES6 classes, async/await, and Promises became standard. Although React has adapted to some of these changes, its core still reflects an older JavaScript ecosystem.

For example, React initially relied on class components, which have since been largely replaced by hooks. This shift has caused confusion and inconsistency in codebases as developers have to decide between the "old way" (class components) and the "new way" (hooks).

3. Hooks: A Mixed Blessing

Hooks were introduced as a way to simplify React development, but they’ve often made things worse. While hooks eliminate the need for class components, they introduce new problems:

• Complex State Logic: Managing state with hooks like useState and useReducer can quickly become a tangled mess.
• Dependency Arrays: Forgetting or mismanaging the dependency array in useEffect can lead to bugs that are hard to debug.
• Rules of Hooks: The strict rules of hooks (e.g., "don’t call hooks inside loops or conditionals") are unintuitive and add to the learning curve.

4. Bloated Ecosystem

React’s simplicity often comes at the cost of requiring numerous additional libraries for tasks like routing (React Router), state management (Redux, MobX, Context API), and form handling. This bloated ecosystem means developers spend more time learning libraries and keeping them updated than focusing on building applications.

5. Overhyped Performance Claims

React’s virtual DOM is often touted as a performance boost, but in many cases, the performance gain is negligible or even counterproductive compared to optimized direct DOM manipulation. The complexity of reconciling the virtual DOM with the real DOM can sometimes introduce inefficiencies.

6. Verbose and Boilerplate-Heavy

React’s code is verbose. The requirement to wrap components in <div>, <Fragment>, or <Provider> components leads to deeply nested structures. Coupled with state and prop drilling, this verbosity makes React code harder to read and maintain.

---

Introducing the Dodo Framework

Frustrated with React’s shortcomings, I decided to create my own solution: the Dodo Framework. Dodo is designed to be:

1. Simple and Intuitive: Dodo eliminates unnecessary complexity, focusing on clean, minimal syntax.
2. Modern from the Ground Up: Built with modern JavaScript in mind, it leverages ES6+, async/await, and promises for a seamless developer experience.
3. Hooks-Free: Forget about tangled useState or useEffect—Dodo uses straightforward state management and lifecycle handling.
4. Lightweight and Fast: Dodo doesn’t rely on a virtual DOM, focusing instead on direct, optimized DOM interactions for faster rendering.

If React has left you frustrated, give Dodo Framework a try. It’s my answer to the problems that React introduced to the JavaScript world. Check it out here: http://dodo.mikosoft.info.

React may have been revolutionary in its time, but the time has come for a simpler, more modern alternative. That’s why I built Dodo Framework. Let’s make web development enjoyable again.