The State of React

This ad is not shown to multipass and full ticket holders
JSNation US
JSNation US 2025
November 17 - 20, 2025
New York, US & Online
See JS stars in the US biggest planetarium
Learn More
In partnership with Focus Reactive
Upcoming event
JSNation US 2025
JSNation US 2025
November 17 - 20, 2025. New York, US & Online
Learn more
Bookmark
Rate this content

FAQ

The State of React survey is an unofficial community survey that gathers insights and opinions from React developers worldwide. It is not affiliated with the React team, Meta, or Vercel.

The latest State of React survey was conducted in October 2024, and the results were published in early 2025.

You can sign up for the next State of React survey by visiting stateofreact.com. The next survey will take place in September 2025.

The main surveys conducted by the presenter are the State of JS, State of CSS, State of HTML, State of React, State of Web Dev AI, and State of Devs.

The latest State of React survey had 7,870 respondents.

The useEffect feature is considered a 'footgun' by some respondents because it is easy to misuse.

The satisfaction level for most new React APIs is high, except for the Taint API and Server Actions, which have lower satisfaction due to being new and not well-documented.

Next.js was highlighted for its high satisfaction despite complexity and frequent complaints, showing a strong community support.

Styling and customization are common pain points among developers regarding component libraries, especially with built-in styles like Material-UI or Bootstrap.

Forward ref received notable negative sentiment in the survey and is deprecated in React 19 due to its cumbersome usage.

Sacha Greif
Sacha Greif
26 min
17 Jun, 2025

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Introduction to the State of React survey and the history of developer surveys. Detailed analysis of survey results, user demographics, and job titles. Examination of React API trends, user sentiment towards APIs, and new API challenges. Analysis of React library satisfaction, particularly with Next.js. Discussion on React state management and data loading, including pain points. Insights on React library usage patterns and application trends. Key takeaways include staying calm, appreciating foundational React elements, and relying on data for a balanced view.
Available in Español: El Estado de React

1. State of React Survey Overview

Short description:

Introduction to the State of React survey, the history behind developer surveys starting in 2016, focusing on React and Vue popularity and the need for deeper insights into developer preferences and trends.

Hi, everybody. Welcome to today's presentation about the latest results from the State of React survey. Now, the latest survey ran in October of 2024, and the results were published in early 2025. And by the way, one thing I want to mention is this is a community survey. It's unofficial, so it's not affiliated with the React team or Meta or Vercel or anybody. But hopefully, it's still interesting. And another thing is that to sign up for the next survey, you can go to stateofreact.com. The next survey will take place in September 2025. And if you want to follow along with the data I'm going to present today, you can go to 2024.stateofreact.com.

Now, before I talk about the State of React survey, I want to give you a little bit of context because one question that I get a lot when I talk about these surveys is how I got started, how I decided to start doing developer surveys. We have three main surveys, so stateofjs, CSS, HTML, which get between 5,000 up to 10,000 or sometimes even 20,000 respondents, depending on the year. And it all started back in 2016, which was the beginning of our current modern JavaScript era. At the time, React and Vue were still fairly new. And we had a lot of options.

But at the same time, there weren't really any clear leaders, there weren't any default options to choose from. So people were really struggling with JavaScript fatigue and choice paralysis. And of course, we had data about things like NPM downloads or GitHub stars. But that was kind of a bit rough. We didn't have very detailed insights into those trends because after all, even if React is downloaded a lot and Vue is downloaded a lot less, that doesn't necessarily mean that people are enjoying using React. And on the other hand, maybe the few people who are using Vue, I absolutely love it and things might change eventually. So of course, I'm just using React and Vue as two examples here. But that was really the key insight that pushed me to do the first survey, measuring not just raw data, how many people were using each item, but also what they thought about them, whether they would want to use it again, and even things like which frameworks or libraries people were most interested in learning in the future, with the idea being of capturing those upcoming trends as well. So like I said, it started in 2016, almost 10 years ago now with the state of JS, then came the state of CSS. 2023, I did the first edition of the state of React survey. And then this year, 2025, I added two new surveys, the state of web dev AI and the state of devs.

2. Insights from State of React Survey Results

Short description:

Detailed analysis of the State of React survey results regarding respondent demographics, years of experience, job titles, income disparities, and recommendations for job labeling. Explanation of the features chart categorizing user interactions with APIs based on sentiment and usage.

So let's now move on to the state of React results themselves. And 7,870 respondents to the survey, which is quite a decent sample size. As one might expect, a lot of the respondents came from the US, but also European countries and overall a nice spread of respondents throughout the world.

One thing that's interesting, I think, is looking at years of experience. If you group those first two buckets, you actually see that 59% of respondents have less than 10 years of experience. In other words, they never knew a world where React didn't exist, in terms of them being web developers.

And so maybe for a lot of people taking the survey or even watching this, while React might seem like a very default way of doing things, very obvious. But if you have been around for longer than that, then you remember that when React was first introduced, it was actually quite innovative. Things like JSX, the virtual DOM, and even later on hooks, every time React did things a bit differently from everybody else.

We can also look at job titles. We have a good split between software engineer, developer, front-end developer. But it becomes really interesting when you switch to job titles versus income. Because here, you can see that engineer job titles, senior engineer, front-end engineer, are all at the top, whereas developers, front-end, full stack are at the bottom, with a pretty sizable gap in income between them.

And so, I don't know if this is correlation or causation, but just to be safe, if you're able to, I would recommend updating your resume if you are currently labeling yourself as a developer of some kind, and just replace that with engineer. Who knows, you might get a nice raise for your next position. Moving on to features.

So, let me explain how to read this chart, because I know it can be a lot to take in at first. For example, if we look at create portal here, you'll see that each row is split into three colored bars. The first one, dark blue, corresponds to users who have actually used a feature. Light blue is for users who have heard of a feature but not used it. And finally, gray is for users who haven't even heard of the feature. And then within those bars, you further have a subdivision according to positive sentiment in green and negative sentiment in red.

And then, in the middle, it's just people who didn't submit a sentiment, so who remained neutral. Now, what's cool about this system is you can change the grouping from experience to sentiment, and then you can also sort by, for example, positive sentiment. At the top here, we have things like fragment, create context, use states. In other words, APIs that are fairly straightforward to use, that are well understood, and those are the ones with very little negative sentiment.

But of course, you're probably curious to sort by negative sentiment and see which APIs are the most hated. And no surprise here, but forward ref is first by far.

3. React API Trends and User Sentiment

Short description:

Discussion on highly disliked APIs like forward ref and use effect, emphasizing the positive sentiment towards most React APIs despite some negativity. Analysis of user appreciation for features and the evolution of opinions over time. Examination of the usage and satisfaction levels of new APIs, highlighting challenges and successes within the React community.

But of course, you're probably curious to sort by negative sentiment and see which APIs are the most hated. And no surprise here, but forward ref is first by far. And forward ref is actually deprecated going forward in React 19. And so it's nice to see that the React team has already addressed this issue and the fact that forward ref has always been a bit cumbersome to use. Number two is use effect. We actually let respondents submit comments on every feature, and one word that comes back a lot is footgun, as in it's very easy to shoot yourself in the foot with use effect. And so that explains why it's the number two feature with the most negative sentiment. But I do want to point out that even though it has 15% negative sentiment, it has more than double that amount in positive sentiment. And that holds true for all the other features here. So in other words, looked at it collectively, the set of React APIs are actually very well loved by React developers, even though we like to complain. But at the end of the day, if you look at the raw data, I think it points to a very healthy relationship between the developers and React team that are able to listen to our concerns and create APIs that address them.

We can also look at how things have evolved over time. One metric that is kind of interesting is appreciation. What appreciation is is the gap between how many positive sentiment there is among respondents who have only heard of a feature and those who have actually used it. And the reason the chart looks a bit broken here is because we actually have negative values for all the way at the bottom, forward ref. So in other words, people who have never used forward ref may have a bad opinion of it, but people who have actually used it think even less of it and have an even higher proportion of negative sentiment. The other ones that have low appreciation are act, memo, profiler, and it doesn't mean that necessarily there are more negative opinions than positive. All it means is that maybe people initially were interested enough to try the feature, but once they actually tried it, they ran into some edge cases or confusing parts and their overall positivity went down a bit. And I think that can easily happen, especially with new features that aren't maybe that well documented or where it's harder to find examples in the wild. And what's going to be really interesting is seeing how this ratio evolves next year and the year after that. And that's the whole value of doing a recurring survey like that is seeing how the React team is able to address community feedback and evolve the library, which I have to say it's done a pretty good job, I think, up to now.

We can also look at usage for new APIs. So React server components are gaining ground on suspense as well. And if we look at satisfaction, which is positive sentiment among respondents having used a feature, it's actually pretty high for almost every new API. So the only one that's a bit low is the Taint API, maybe because of the name, I don't know. And then server actions, maybe because they are still very new and not that well documented, necessarily. But overall, I would say that all the new APIs recently introduced have been hits with the community, even though, of course, they have their own challenges, which we can see in the pain points. So again, a lot of pain points around forward draft, like we said, memo and act as well, which makes sense. These are new and you need time to assimilate how to use them. And then new APIs against React server components, which I think shows that when you introduce a new API, especially a new paradigm like React server components, of course, it's going to create pain.

4. React Library Analysis and User Satisfaction

Short description:

Discussion on the importance of pain in feature evolution, analysis of libraries' positive sentiment, especially Next.js, and the user satisfaction quadrant chart for React libraries.

But just because you have pain doesn't mean that the community is going to reject the feature. It's just part of evolving alongside with the framework. Moving on to libraries. Now, one thing you'll notice here is that the first two items are not actually libraries, useState and fetch. The reason they're included here is just as a point of comparison, for example, with useState state management libraries and for fetch data loading libraries. But we can go ahead and look at positive sentiment. Number one is useState. Number two, in other words, the first actual library is 10-stack query. That didn't really surprise me because 10-stack products in general seem to be pretty beloved by the community and 10-stack query is actually establishing itself, I think, as one of the main ways of handling data loading in your app. Zeus 10, which is great for state management, and then Next.js. Now, Next.js still has a very high positivity to negativity ratio, even though people love to complain about it. So what's going on here? I think it's natural when you have something as complex as Next.js and also as widely used that on social media, on forums, on Reddit, on YouTube, wherever, people will vent. They will air their complaints. They will share feedback, which can give this appearance of negativity around any project. But I think it's interesting and useful to look at data like this to remind ourselves that there's a big community of just developers quietly using Next.js and sure, we run into issues now and then, but it doesn't mean we don't like the framework and so this is what's shown here, I think. We can also see this confirmed in this quadrant chart. On the bottom axis here, we have user count, and on the left we have retention or satisfaction. Again, the only React library with both high usage and satisfaction is Next.js. The other ones here are not really libraries or something that's not React specific, again, included as a point of comparison. A 10-stack query, though, is very close to crossing over into that over 50% usage quadrant, but for now, at least, it's in the top left quadrant, along with things like Astro, GISTAN, 10-stack start, which is all those things that have very high satisfaction. People love them, but they're not widely used yet. So if you are a more prudent developer, you can wait for things to cross over and become really mainstream before using them. If you're more of an early adopter, you can also experiment with those items here.

Moving on, we can look more specifically at component libraries. Let's go straight to positivity, or let's do satisfaction. Now, I'll switch to the rank view to have a bit clearer picture. Number one is Redux, then we had ShedCNUI, React-Aria, Headless-UI, and Mantine. What's interesting is, with maybe the exception of Mantine, all the other ones are not really traditional component libraries. ShedCNUI lets you copy-paste code snippets. There's no npm package.

5. React State Management and Data Loading Analysis

Short description:

Discussion on Headless-UI libraries, state management satisfaction with useState and Zeus10, and the popularity of 10-Stack Query in data loading and pain points.

And then the other ones are Headless-UI libraries, which means that they give you components that are unstyled. You only have the behavior part of the component. And I think there's a couple of factors for the popularity of these Headless-UI libraries. One, Tailwind actually does a good job of handling styling for you, and making styling more accessible for developers who might struggle with CSS. And the other thing is, if you have built-in styles with something like Material-UI or Bootstrap, overriding those styles and customizing them can be quite tough. It's almost more work to customize those styles compared to simply just writing your own sometimes. So it makes sense that these would be popular, I'm using Redix myself. I think these toggles are Redix, probably.

Now, what else can we look at? Maybe pain points. And again, styling and customization is a big issue, which goes back to the idea of it's good when you are able to customize things to your own needs without struggling too much. Which, again, Headless-UI libraries are great at. Moving on to state management. Now, useState is number one and Zeus10 is number two. If we look at the values, they're very close but useState is at 97% satisfaction and Zeus10, 95%. I think that's very cool that the default option, useState, is actually number one. Like, it's not only competitive with dedicated libraries, but beating them in terms of satisfaction. And it's not always the case with other ecosystems. A lot of the time, the default weight is too limited or frustrating to use, so you have to resort to third-party libraries. But for React, at least, useState, although limited, does provide a good developer experience for most people.

And then, of course, if you do need more power, you can move on to things like Zeus10 or Jotai. But it's nice to see that the defaults do work. We can also look at pain points. Excessive complexity is a big one, which I think is not a surprise for state management. Next up is data loading. Now, like I said, 10-Stack Query is scoring very high. And after that, fetch is the next one. So this is a case, unlike with useState, where although the native browser API also scores high, it doesn't score as high as 10-Stack Query. But again, both are doing fine. Axios is also doing pretty well, and TRPC is also a good choice. If we look at pain points, state management, caching, error handling are the top three, which also all happen to be things that 10-Stack Query helps with, which goes to explain the popularity of that library, I think.

6. React Library and Application Patterns Insights

Short description:

Analysis on library satisfaction, pain points in type safety, and usage patterns in React applications.

Finally, for libraries, backend and infrastructure, and more specifically, meta frameworks, things like Astro, Next, and so on. Now, number one is Astro in terms of satisfaction. After that, we have, which one is it, 10-Stack Start, which is very new but has very high satisfaction, Remix, DocuZeros, Remix, DocuZeros, and then Next.js, still with high satisfaction. Now, in terms of usage, Create React app might be number one, but Next.js is clear number two. And after that, there's a big gap before Gatsby and Remix and the other ones. One note about Gatsby, it has very low satisfaction because, as far as I know, it's not being very actively developed anymore, and it has its share of issues. But ironically enough, the site that we're looking at right now is a Gatsby site. So, I am using Gatsby, and I think it's still pretty good, it's still pretty powerful. But of course, as the ecosystem evolves, there is a turnover, and now Gatsby seems to be on the way out, while Astro is doing great.

If we look at pain points, interesting to see that end-to-end type safety or the lack thereof is the number one pain point. The reason it's interesting is because this is something that's Next.js, that the leader in this category doesn't really address natively, out of the box, I would say. Whereas other frameworks like TempStack, Start, are built around that concept, or tRPC as well. If this is really such a big pain point, this might prove to be a way that these new entrants can disrupt Next.js. So, we'll see what happens with that next year.

Finally, let's look at how people are actually using React. For example, application patterns, as you can see, the biggest one by far is single-page applications, followed by server-side rendering and static-side generations. All three of those are fairly traditional patterns, I would say. They've been around for a long time. Whereas the other ones, the fancier, more esoteric application architectural patterns, have much lower usage. But, of course, if you go to a conference such as React Summit or if you look at React videos on YouTube, people will often talk about these fancier, more complex patterns, because there's not that much left to say about SPAs or static-sides. On the other hand, you can say a lot about incremental static generation, partial hydration, and so on. But then I think this creates a false impression that the community has already moved on and is now adopting all these new patterns. Whereas the truth is, most developers, including myself, are always lagging a couple of years behind. So, if that's your case, I think there's nothing wrong with that. And I just want to caution against feeling too much FOMO, fear of missing out, just because you are not implementing, whether it's React components or partial hydration or this or that. Actually, I do think even being a couple of years late to the party can be a more productive way to be a developer, because you let others figure out all the edge cases and handle all this complexity. That being said, it doesn't mean you can't still be excited about new features, such as React Compiler, React Server Components, Use Hook. Server Actions score fairly low, even though I think they will be a pretty game-changing feature, or server functions. So, I'm very curious to see how this in particular changes next year. So, there you go.

7. Reflections and Future Outlook on React

Short description:

Key messages: Stay calm if you feel behind; appreciate foundational React elements like JSX and virtual DOM. Social media bias towards negativity; rely on data for a balanced view. Join us for the next State of React in September 2025.

I think that's a pretty good overview of the state of React, at least in October of last year. Of course, things changed so fast, so we'll take this with a grain of salt. But I just want to leave you with, I guess, two messages. One, as I already mentioned, if you feel like you're behind, don't panic. I think the majority of the community always lags behind a little bit. That's normal. And then also, take a second to appreciate things like JSX, the virtual DOM, useState, all the things that we take for granted. They are actually quite well thought out, I think. And we do have a very good library on our hands.

And then, a third thing maybe, use social media to keep up. But if you see a lot of negativity around something, whether it's a library or a feature, remember that there's kind of a bias here where people will only tweet or go on BlueSky or whatever to only do that when they are actually angry, when they need to vent. So, that's always going to be biased towards negativity. But if you look at actual data, you'll see that things aren't that bad.

So, there you go. Thanks a lot for tuning in today. And I definitely hope you will join us for the next State of React in September 2025. Thank you.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

A Guide to React Rendering Behavior
React Advanced 2022React Advanced 2022
25 min
A Guide to React Rendering Behavior
Top Content
This transcription provides a brief guide to React rendering behavior. It explains the process of rendering, comparing new and old elements, and the importance of pure rendering without side effects. It also covers topics such as batching and double rendering, optimizing rendering and using context and Redux in React. Overall, it offers valuable insights for developers looking to understand and optimize React rendering.
Building Better Websites with Remix
React Summit Remote Edition 2021React Summit Remote Edition 2021
33 min
Building Better Websites with Remix
Top Content
Remix is a web framework built on React Router that focuses on web fundamentals, accessibility, performance, and flexibility. It delivers real HTML and SEO benefits, and allows for automatic updating of meta tags and styles. It provides features like login functionality, session management, and error handling. Remix is a server-rendered framework that can enhance sites with JavaScript but doesn't require it for basic functionality. It aims to create quality HTML-driven documents and is flexible for use with different web technologies and stacks.
React Compiler - Understanding Idiomatic React (React Forget)
React Advanced 2023React Advanced 2023
33 min
React Compiler - Understanding Idiomatic React (React Forget)
Top Content
Watch video: React Compiler - Understanding Idiomatic React (React Forget)
Joe Savona
Mofei Zhang
2 authors
The Talk discusses React Forget, a compiler built at Meta that aims to optimize client-side React development. It explores the use of memoization to improve performance and the vision of Forget to automatically determine dependencies at build time. Forget is named with an F-word pun and has the potential to optimize server builds and enable dead code elimination. The team plans to make Forget open-source and is focused on ensuring its quality before release.
Using useEffect Effectively
React Advanced 2022React Advanced 2022
30 min
Using useEffect Effectively
Top Content
Today's Talk explores the use of the useEffect hook in React development, covering topics such as fetching data, handling race conditions and cleanup, and optimizing performance. It also discusses the correct use of useEffect in React 18, the distinction between Activity Effects and Action Effects, and the potential misuse of useEffect. The Talk highlights the benefits of using useQuery or SWR for data fetching, the problems with using useEffect for initializing global singletons, and the use of state machines for handling effects. The speaker also recommends exploring the beta React docs and using tools like the stately.ai editor for visualizing state machines.
Routing in React 18 and Beyond
React Summit 2022React Summit 2022
20 min
Routing in React 18 and Beyond
Top Content
Routing in React 18 brings a native app-like user experience and allows applications to transition between different environments. React Router and Next.js have different approaches to routing, with React Router using component-based routing and Next.js using file system-based routing. React server components provide the primitives to address the disadvantages of multipage applications while maintaining the same user experience. Improving navigation and routing in React involves including loading UI, pre-rendering parts of the screen, and using server components for more performant experiences. Next.js and Remix are moving towards a converging solution by combining component-based routing with file system routing.
React Concurrency, Explained
React Summit 2023React Summit 2023
23 min
React Concurrency, Explained
Top Content
Watch video: React Concurrency, Explained
React 18's concurrent rendering, specifically the useTransition hook, optimizes app performance by allowing non-urgent updates to be processed without freezing the UI. However, there are drawbacks such as longer processing time for non-urgent updates and increased CPU usage. The useTransition hook works similarly to throttling or bouncing, making it useful for addressing performance issues caused by multiple small components. Libraries like React Query may require the use of alternative APIs to handle urgent and non-urgent updates effectively.

Workshops on related topic

React Performance Debugging Masterclass
React Summit 2023React Summit 2023
170 min
React Performance Debugging Masterclass
Top Content
Featured Workshop
Ivan Akulov
Ivan Akulov
Ivan’s first attempts at performance debugging were chaotic. He would see a slow interaction, try a random optimization, see that it didn't help, and keep trying other optimizations until he found the right one (or gave up).
Back then, Ivan didn’t know how to use performance devtools well. He would do a recording in Chrome DevTools or React Profiler, poke around it, try clicking random things, and then close it in frustration a few minutes later. Now, Ivan knows exactly where and what to look for. And in this workshop, Ivan will teach you that too.
Here’s how this is going to work. We’ll take a slow app → debug it (using tools like Chrome DevTools, React Profiler, and why-did-you-render) → pinpoint the bottleneck → and then repeat, several times more. We won’t talk about the solutions (in 90% of the cases, it’s just the ol’ regular useMemo() or memo()). But we’ll talk about everything that comes before – and learn how to analyze any React performance problem, step by step.
(Note: This workshop is best suited for engineers who are already familiar with how useMemo() and memo() work – but want to get better at using the performance tools around React. Also, we’ll be covering interaction performance, not load speed, so you won’t hear a word about Lighthouse 🤐)
Next.js for React.js Developers
React Day Berlin 2023React Day Berlin 2023
157 min
Next.js for React.js Developers
Top Content
Featured WorkshopFree
Adrian Hajdin
Adrian Hajdin
In this advanced Next.js workshop, we will delve into key concepts and techniques that empower React.js developers to harness the full potential of Next.js. We will explore advanced topics and hands-on practices, equipping you with the skills needed to build high-performance web applications and make informed architectural decisions.
By the end of this workshop, you will be able to:1. Understand the benefits of React Server Components and their role in building interactive, server-rendered React applications.2. Differentiate between Edge and Node.js runtime in Next.js and know when to use each based on your project's requirements.3. Explore advanced Server-Side Rendering (SSR) techniques, including streaming, parallel vs. sequential fetching, and data synchronization.4. Implement caching strategies for enhanced performance and reduced server load in Next.js applications.5. Utilize React Actions to handle complex server mutation.6. Optimize your Next.js applications for SEO, social sharing, and overall performance to improve discoverability and user engagement.
Concurrent Rendering Adventures in React 18
React Advanced 2021React Advanced 2021
132 min
Concurrent Rendering Adventures in React 18
Top Content
Featured Workshop
Maurice de Beijer
Maurice de Beijer
With the release of React 18 we finally get the long awaited concurrent rendering. But how is that going to affect your application? What are the benefits of concurrent rendering in React? What do you need to do to switch to concurrent rendering when you upgrade to React 18? And what if you don’t want or can’t use concurrent rendering yet?

There are some behavior changes you need to be aware of! In this workshop we will cover all of those subjects and more.

Join me with your laptop in this interactive workshop. You will see how easy it is to switch to concurrent rendering in your React application. You will learn all about concurrent rendering, SuspenseList, the startTransition API and more.
React Hooks Tips Only the Pros Know
React Summit Remote Edition 2021React Summit Remote Edition 2021
177 min
React Hooks Tips Only the Pros Know
Top Content
Featured Workshop
Maurice de Beijer
Maurice de Beijer
The addition of the hooks API to React was quite a major change. Before hooks most components had to be class based. Now, with hooks, these are often much simpler functional components. Hooks can be really simple to use. Almost deceptively simple. Because there are still plenty of ways you can mess up with hooks. And it often turns out there are many ways where you can improve your components a better understanding of how each React hook can be used.You will learn all about the pros and cons of the various hooks. You will learn when to use useState() versus useReducer(). We will look at using useContext() efficiently. You will see when to use useLayoutEffect() and when useEffect() is better.
Introducing FlashList: Let's build a performant React Native list all together
React Advanced 2022React Advanced 2022
81 min
Introducing FlashList: Let's build a performant React Native list all together
Top Content
Featured Workshop
David Cortés Fulla
Marek Fořt
Talha Naqvi
3 authors
In this workshop you’ll learn why we created FlashList at Shopify and how you can use it in your code today. We will show you how to take a list that is not performant in FlatList and make it performant using FlashList with minimum effort. We will use tools like Flipper, our own benchmarking code, and teach you how the FlashList API can cover more complex use cases and still keep a top-notch performance.You will know:- Quick presentation about what FlashList, why we built, etc.- Migrating from FlatList to FlashList- Teaching how to write a performant list- Utilizing the tools provided by FlashList library (mainly the useBenchmark hook)- Using the Flipper plugins (flame graph, our lists profiler, UI & JS FPS profiler, etc.)- Optimizing performance of FlashList by using more advanced props like `getType`- 5-6 sample tasks where we’ll uncover and fix issues together- Q&A with Shopify team
React, TypeScript, and TDD
React Advanced 2021React Advanced 2021
174 min
React, TypeScript, and TDD
Top Content
Featured Workshop
Paul Everitt
Paul Everitt
ReactJS is wildly popular and thus wildly supported. TypeScript is increasingly popular, and thus increasingly supported.

The two together? Not as much. Given that they both change quickly, it's hard to find accurate learning materials.

React+TypeScript, with JetBrains IDEs? That three-part combination is the topic of this series. We'll show a little about a lot. Meaning, the key steps to getting productive, in the IDE, for React projects using TypeScript. Along the way we'll show test-driven development and emphasize tips-and-tricks in the IDE.