React is so powerful that it can be used for more than frontend development. E.g. creating UI programmatically in the backend using a rule-based system or machine learning is another use case where React can serve as the best fit. Similarly, documentation earlier used to have only .md files but now it also includes .mdx file that contains React code. To fulfill such use cases, developers need to understand the internals of React and the tooling around it. Some great sources are popular codebases such as create-react-app, Next.js, etc. In this talk, I will share the lessons we learnt while creating a framework that achieves more than web development using React. Firstly, I will cover how create-react-app codebase is the best codebase to understand how webpack, babel, eslint, typescript etc. can be used alongside React. Secondly, I will share how Next.js teaches us to create a js framework where we can write backend and frontend in the same file and still be able to separate the two during calls. Thirdly, I will share how our framework supports plugins, i.e. the React code resides in multiple repositories but all of this code can share a single React runtime inside the browser. This is a very advanced use of React that cannot be achieved by code splitting using React.lazy. This talk will enable developers to use React for more than frontend development.
Lessons Learnt While Creating a New Framework on Top of React
AI Generated Video Summary
React is a versatile tool that goes beyond front-end development and can be used for synthesizing music. Creating a specialized framework with React requires understanding the tooling ecosystem and React's design philosophy. Examining good codebases like createreactapp can accelerate development. Handling side effects and module replacement can be achieved through techniques like dead code elimination and hot module replacement. Maintaining component state and implementing hot module replacement are important considerations for a React application.
1. Introduction to React and Its Applications
Hello everyone, I'm thankful to React Advanced London team for inviting me to share what I have learned while creating a new full stack framework. A bit about me, my name is Shyam Swaroop and I am the co-founder and CTO of Atrilabs. I have been using React for now more than a year, and it has become one of the go-to choices for generating HTML. React goes beyond just front-end development. We are mixing plain content in markdown files with react code for writing content. React Native was used to create native mobile apps for Androids and iOS. React Reconciler can be adapted for rendering UI on any device. I recently came across a very interesting use case that does not involve rendering UI, but rather synthesizing music by writing React code.
Hello everyone, I'm thankful to React Advanced London team for inviting me to share what I have learned while creating a new full stack framework that allows developers to write React code to build frontends.
A bit about me, my name is Shyam Swaroop and I am the co-founder and CTO of Atrilabs, a company that is building an exciting new full stack framework. I was pursuing Masters from Columbia University, then I dropped out and started working on my own startup.
I have been using React for now more than a year, I was more of an Angular person before that. We can find the use of JSX beyond just web development. It has become one of the go-to choices for generating HTML, a use case very similar to SSG, SSR, or you can say a replacement for template engines. Some projects have extended grammar of languages like Go and Python to include JSX.
React goes beyond just front-end development. We are mixing plain content in markdown files with react code for writing content. This has given rise to frameworks that specialize in specific tasks like documentation. A popular example would be DocuSource. React Native was used to create native mobile apps for Androids and iOS. There are few frameworks that can be used to create native Windows or MacOS apps using React. React Reconciler can be adapted for rendering UI on any device. I recently came across a very interesting use case that does not involve rendering UI, but rather synthesizing music by writing React code. I remember the power I felt when I learned React or Bison, where you just write a context-free grammar and it generates the parser. Since I knew how to create parsers easily, I was able to innovate fast in many scenarios.
2. Creating a Specialized Framework with React
This is how I feel now with web development, because now that I know the React and tools to handle a React code base, I can easily create a very specialized framework that can enhance the developer productivity of a web developer team.
This is made possible by tools like compilers, transpilers, bundlers, formatters, and linters. Rendering on the server side is a common requirement for most of the frameworks, if not all. Hence, our framework has to support React in both browsers and Node.js. In other words, it becomes crucial to realize the difference between different module types, especially ECMAScript and common.js. When we think about what bundler and build tools to use, we mostly think in terms of how fast they run. But as a framework creator, you might have to think more about your requirements. For example, if the developer's experience entails code mods, then you might prefer something like Babel over ESBuild because Babel exposes AST to load as plugins, while ESBuild doesn't. We're using Webpack and Babel together at a 3 framework.
3. Understanding the Create React App Codebase
Once we have some idea about tools and the ecosystem, going through a few good codebases or frameworks helped us a lot. It speeded up our development where we are able to focus more on our unique offerings than the mundane ones. The best starting point was going through the createreactapp repository, and that's what we are going to look at in detail next. Looking at NextGIS repository is also a good idea.
Before we look into the code of createreactapp, I would like to classify the packages in createreactapp into three categories. Packages that are used to build a CRE application. These are the most important packages to go through. There are a few packages to configure the tools such as transpilers, for example, Babel and the linter such as ESLint. Finally, the packages to generate the initial scaffolding when we run something like NPX Create React App.
4. Handling Side Effects and Module Replacement
Cid apps handle SVGs using a third-party library called SVGR. Dead code elimination or pre-shaking eliminates unused functions from across the world by starting at the entry point and only including functions that may be executed. To prevent Webpack from traversing further in the dependencies, let it know that no module in this package has any side effects by setting side effects field in package.json as false. Hot module replacement or HMR allows replacing the module containing the dialog box component during runtime and React's Fast Refresh plugin handles reapplying the state of the app once the module has reloaded.
Cid apps handle SVGs using a third-party library called SVGR. This is different than handling other assets which are directly handled by webpack like this. Here we can see side effects. What does this mean? How does it affect the final bundle? This brings us to the next topic dead code elimination or pre-shaking. The bundle optimization techniques such as dead code elimination and mangling are activated by default in production mode. If we are not in production mode but we still want to have any of these optimization benefits, then we will have to import optimization plugins on our own.
Pre-shaking eliminates unused functions from across the world by starting at the entry point and only including functions that may be executed. React's higher order components make it harder for Tercer to pre-shake dead code. For pre-shaking to work, we have to use ES 2015 or ES6 module syntax that is import and export. We have to ensure that no compilers or loaders or plugins transform our ES6 and above syntax code into CommonJS module. Just as a precaution, if you are using Babel and you use Babel's Preset env, you might have to configure it so that it does not convert the ES6 modules to CommonJS which is its default behavior.
Coming back to where we left in the code, the Tercive will detect CSS imports as unused, hence it will try to remove them. To prevent it we need to set side effects field in Webpack as true. Let's look at how Tree Seeking works in Webpack with an example. In this example, the index file imports wrap-button, but does not use it. Webpack's Tercer plugin, tries to figure out if it can drop some code from this file. But it might not be able to figure it out if button-wrapper function call has some side effects or not. A side effect might be something like changing a value on window object or any other global variable. The highlighted code will be eliminated once we have added a comment like this, which says Pure. But there are still questions with the imports which need to be included or evaluated because they could contain side effects. In other words Webpack will traverse the dependencies in this module and figure out if imported modules have any side effects. This will hurt bundle time and bundle size. One way to prevent this is by letting Webpack know that no module in this package has any side effects by setting side effects field in package.json as false.
Imagine we are developing a dialog box that opens up after we click through a few buttons. We have to change the app's state to finally open that dialog box. It becomes time-consuming and annoying for frontend developers to open the dialog box after every change they make to that dialog box component. The solution is to somehow replace the module containing the dialog box component during runtime and this is commonly referred to as hot module replacement or HMR. In React's context, a question arises. How do we maintain the state of the component after the module containing this component has been replaced? React's Fast Refresh plugin handles reapplying the state of the app once the module has reloaded.
5. Maintaining Component State and Implementing HMR
How do we maintain the state of the component after the module containing this component has been replaced? React's Fast Refresh plugin handles reapplying the state of the app once the module has reloaded. It needs to inject some code into each module to accomplish this. We use the React Refresh Babel plugin to actually handle this for us.
How do we decide whether the changes made in the module should trigger a full-page reload or a hot module replacement? To decide whether to hot replace the module or full-page reload, we can implement some checks on the module such as all the imports from the module must be a React component for the module to be eligible for HMR. Thankfully implementing HR for React is quite easy with bundlers like Webpack. Module bundlers like Webpack and Ruler have exposed HMR API that can be implemented on a module. Let's look into the code.