Learning from React - part 2
Tags: programming, essay, react, net
Published: 2021-05-31 20:36:01

---
title: Learning from React - part 2
published: true
date: 2021-05-29 10:40:32 UTC
tags: programming,essay,react,net
canonical_url: https://siderite.dev/blog/learning-from-react---part-2/
---

Original post at: https://siderite.dev/blog/learning-from-react---part-2/

Learning from React series:

- [Part 1](/blog/learning-from-react---part-1/ "Learning from React - part 1") - why examining React is useful even if you won't end up using it
- [Part 2](/blog/learning-from-react---part-2/ "Learning from React - part 2") - what Facebook wanted to do with React and how to get a grasp on it

In order to understand React we must consider what were the advantages that Facebook found in the concept when they created the library. There a numerous [presentations](https://www.youtube.com/watch?v=GW0rj4sNH2w "Original JSConf presentation from 2013") and articles that they pushed to explain it, but it kind of distills to this:

- mutation of values complicates flows in complex applications
- traditional Model-View patterns promote mutation through two directional data binding
- solution for mutation:
  - use unidirectional data binding and re-render views as the data changes
  - send inputs as events that a higher level entity will interpret
- solution for slow browser render overhead:
  - code is organized in smaller and smaller components that depend on a few values in the overall data
  - there is an intermediate layer of rendering between React and the actual browser DOM called a [Virtual DOM](https://reactjs.org/docs/faq-internals.html "Virtual DOM and Internals"), which only sends to the browser the changes that renders affected

But wait, you will say! How do the values change if they are immutable? The point here is that your components have an immutable internal state. The values that are passed to the components can still change, but on a higher level. They declare a label that have a text and for the label the text never changes. When the text changes in the logic of the application, a new label instance with a new text is rendered. The advantage of this is that the declaration of the render for a component defines the way the component will always render. It's declarative of your intent of how that component should look. They wanted to replace mutation with what they called reconciliation between the previous state and the current state. They almost treated web development like game development or remote access software.

So when you look at a [JSX syntax](https://reactjs.org/docs/introducing-jsx.html "Introducing JSX") and you see Javascript mixed with HTML and switching back and forth, that is different from the ASPX spaghetti code where server logic was mixed up with UI declarations. JSX is less an XML flavor and more a Javascript flavor. In fact, it is transpiled to Javascript code when executed and the changes to the UI are imperative commands that tell it how to change based on how the render code affected the component. But for the developer it's just a story of how the component should look given some data.

React was released in May 2013 and it went through some transformations on the way. Internally it probably started as an object oriented approach which was cumbersome and fought with the overall design of Javascript. They fixed that by the time of the release by using the JSX syntax, but still with code looking like

`var component = React.createClass({ render: function() { return <something/>; } });`

And further down the line they came up with [React hooks](https://reactjs.org/docs/hooks-intro.html "Hooks are a new addition in React 16.8."), which move further from the class oriented approach and more towards a functional one with stuff like

`const component = (props) => (<something />);`

which of course is lighter still. Note that Javascript changed during that time, allowing for more stuff to happen. And now they added Typescript support, so you get something like

`const Component = (props:{text:string})=>(<something />);`

This evolution of the library is also one of the biggest obstacles against learning how to use it as in your Goggle search you might find solutions and problems from any time in the history of the library. You will find the perfect tool for what you wanted, but all the examples are in Javascript and in Typescript it works differently or the answers refer to previous versions of absolutely everything and you don't know which of them is the one that should apply to your task. Or even worse, some package that you use and it made your life so easy conflicts with the one you just want to use because they were never meant to work together.

As opposed to Angular, which was designed as a framework, to constrain and control what you do, React is a library. And it evolves not only through the efforts of Facebook, but also of a very active community. People would add React to their existing project rather than rewriting it from scratch. This means they will have used any of the various versions of React as well as any of the various versions of all the packages that they use in conjunction with it. And these packages are wild! Imagine a developer coming from the world of WPF or vanilla web design with HTML and CSS as the primary focus and Javascript an after thought or from Angular. They will work with React, but use it in a way they are more familiar with. That means that even if the library has a backing philosophy, there is little it can do to force you to use it in that way.

Let's take just one example: [MobX](https://mobx.js.org/README.html "Simple, scalable state management."), a package that takes existing data objects and wraps them in proxies that notify of changes. With React you use it as you would a [ViewModel in WPF](https://docs.microsoft.com/en-us/archive/msdn-magazine/2009/february/patterns-wpf-apps-with-the-model-view-viewmodel-design-pattern "Patterns - WPF Apps With The Model-View-ViewModel Design Pattern"). Instead of sending an event called CLICK from a click event and handling it in some state machine looking code you can just modify the "immutable" property of the data you were sent and behind the scene a setter is executed which lets everybody know that it has changed and so it triggers a re-render which will take the value of the actual property from the behind-the-scene getter. You get your way, React kind of gets its way.

To recap:

- components live in a tree, rather than a graph, and they all render based on the properties they are passed
- components declare how they should look like
- any input from the components is sent up as an event to which the system "reacts"
- slow browser rendering is replaced with a virtual representation of the UI and updated with specific commands to reflect only the changes from one state to the other
- React is an evolving beast with many heads and finding your own way of doing things lies at the root of any successful development effort

While exploring development with this library, developers have found various tools and concepts useful to integrate. As we usually do, they started to generalize these attempts and come up with some new principles or get to the root of the underlying flow. I want to spend the next part of the series discussing some of these more general or architectural ideas and try to see what they are worth.