So as many of you know I have been thrust into working with Angular the last six months or so. I feel that at this point I have a intuition for what I like and don’t like. This is my attempt at verbalizing why I tend to like React and more recently Solid over frameworks like Angular.
Now I understand that bad code and good code can be written in any framework but I feel frameworks can push you in good default directions. This is where I think Solid outshines something like Angular.
The following four points highlight the main concepts that I think differentiates them:
Starting with maybe the most controversial. I personally find JSX good for my mental model. I much prefer it over things like
v-for directives. I read the following in an article recently and it resonated with me.
This leads into the next point which is I feel JSX allows better TypeScript integration. Instead of having magic strings like:
*ngIf="showCollapse; else nonCollapse you do things like ternaries or use a
<Show> component like Solid. I feel like component props are strongly typed and provide autocomplete, where in Angular they aren’t. There are some settings and an Angular extension that can do some of the job but it just isn’t the same.
Another thing the drives me crazy is the fact you have to add components to an
NgModule. Now I think in newer Angular versions they have this concept of a standalone component which allow us to just import components and use them without fuss.
Lastly I like having my logic and template together in the same file. This is another controversial opinion but I just want less file switching, and just less files in general. I also think this way of slicing components promotes having smaller components. I have quickly seen
*ngIf and templates get complicated very quickly.
Lately I’ve come to appreciate Read/Write Segregation with state primitives. This is an idea I am still trying to understand deeper but this is my take. Solid’s
createSignal and React’s
useState are perfect examples of this. They both return a tuple of a getter and a setter. It allows you to be more explicit about what things can set the value. This promotes the related concept of unidirectional data flow.
Also preferably you control how setters are called instead of providing direct access. An example is passing an
increment function instead of the
A good quote I found around this is as follows:
Read/write segregation creates the opportunity to only use mindful, “local” mutability. The Accessor is designed to be «shared»; the Setter is designed to be «owned».
Along with this is a related concept of keeping your state scoped as low as possible to avoid global state. I’ve come to the realization that these state primitives should be defined within a component where possible. This way the setter can only affect the current component and down the tree.
Having setters that can be called from multiple different random places in the codebase is a mess. This helps keep the “locality of thinking” as Ryan Carniato says.
Functions Over Classes
Another key concept I’ve come to appreciate is functions over classes, or similarly composition over inheritance.
My brain just aligns a bit better with a functional programming paradigm. This paradigm tries to keep things pure as much as possible in that the same inputs get the same output.
The composability of using props and children (React/Solid) is is much greater than dependency injection in frameworks like Angular.
Functions also have less ceremony and boilerplate around them which make them easier to use, especially together with modules.
This is another obvious distinction for me between React/Angular. Angular relies heavily on classes, and almost every other framework relies on functions.
Now obviously I come more from a web background, so maybe my opinion would be different if I was coming from
One of the important things I wanted to do with Solid’s design was to keep the locality of thinking - Ryan Carniato
So I won’t get too much into what signals are but instead talk about the benefits of using them. You can read this article if you want a bit more in depth reading.
The most talked about reason for them is the performance. They allow frameworks to make targeted updates to the DOM instead of relying on a vdom and re-rendering everything. This is why Solid has been at the top of JS benchmarks for years.
The other benefit is the auto-tracking of dependencies in effects. This means no dependency array footguns that something like
useEffect in React give you.
When comparing with Observables in Angular I find that most of the time I want simple synchronous reactivity. I just want to be able to get a value, and set a value in an predictable way. Most of the time I don’t care about the “values over time” aspect of observables.
These are just a couple of the biggest difference between React and Solid and why Signals are influencing every framework these days including Svelte, and Angular.
React’s true strengths are: composition, unidirectional data flow, freedom from DSLs, explicit mutation, and static mental model - Dan Abramov
So just as a quick comparison you can see below the list of frameworks and which principles they follow. This also happens to be my preference of frontend frameworks from left to right.