The React Knowledge That Changes Everything

You're about to master React in a way that few others do. By truly understanding it, under-the-hood. From JSX transpilation to React Fiber and more.

React is a required skill in the modern web development job market. But even devs experienced in React struggle with understanding it fully, and thus struggle with writing efficient code and debugging it quickly.

Maybe you've spent lots of time mimicing instructors, typing what they type like following a GPS. The problem is that doesn't lead to true understanding. If you don't understand the roads, you can't find your way when you face a roadblock.

In this course, you'll gain the most powerful tool a developer can have: an accurate mental model - which leads to unparalleled confidence and calm while coding.

I've read all of React's source code for you, and you're about to dive into it with me. Whether new or experienced, you're about to understand React.

But I Already Know React!

A lot of developers have experience using React, and have built things with it! But that's not the same thing as the cool confidence that comes from understanding how React works.

I've given talks on React and watched as a room full of devs currently using React drop their heads and start frantically writing notes as they see how React internals work. Why? Because there is great value in deeply understanding.

Understanding yields better coding choices and most strikingly faster, easier debugging. When you know how something works it's far easier to fix things when something goes wrong.

That's what you'll get in this course. I'm proud to say experienced React devs, after taking this course, have said that an accurate mental model has changed their dev life.

But I Don't Know React!

That's great! Then you don't have any incorrect mental models to undo.

This course will take you up from the very beginnings of the problems React was designed to solve, through JSX, how React works under-the-hood, and more.

It's also perfect for people who've never used React at all.

Don't Imitate, Understand

A lot of courses will use terms like "deep dive" and "under-the-hood", but not actually provide deep understanding.

I call the technique I use "don't imitate, understand". If you just parrot what the instructor is typing on the screen you might end up with a finished product. But as soon as you're dealing with challenges and problems in a real-world job, you'll realize the parroting didn't teach you all that much.

Instead of spending hours imitating me typing, we're going to dive deep together into React's source code to truly, deeply understand it.

We'll write plenty of code along the way, including project work. But we won't write a line of code we don't fully break down and understand.

JavaScript, Browsers, and Computer Science

As we dig into React's internals, we'll discuss the underlying algorithms and data structures you need to know to understand React.

We'll stop and spend time analyzing the vocabulary of React, making sure we don't use any terms that aren't clearly explained.

We'll approach React like a computer scientist. React is just other people's JavaScript code. So why did they write the code they wrote? Why does React work the way it does? What are the benefits? What are the pitfalls?

We'll also look at JavaScript and browser concepts that underpin React's choices and best practices. Things like immutability, object references, and the browser rendering engine. All of this to service using and debugging React well.

These topics will take rules that normally would be memorized (like the rules of Hooks, "pure" component functions, and things you can't do in JSX) and instead be able to derive those rules ourselves naturally by understanding how components and Hooks are structured and work inside React.

We'll write plenty of code along the way, including project work. But we won't write a line of code that we don't already fully understand.

The Fiber Tree: Deep React Internals

A foundation of our understanding of React will be the tree data structure.

Understanding React actually means understanding three trees. The DOM, the React Element Tree, and vitally, the Fiber Tree.

Understanding core React concepts like JSX, Hooks, reconciliation, and events properly all rely on understanding the Fiber Tree, as well as core data structures like Linked Lists and Queues. In this course we cover them all together.

100s of Animations

We won't just look at code. I've put together hundreds of animations so that you can visualize what the React is doing internally and fully understand it.

Then, we put that newfound mental model to use as we build your React knowledge piece-by-piece, and work through code examples together.

Watch The First 6 Hours For Free

I'm confident you will find this technique to be game-changing. I've seen it happen for students for a decade. It's how I've learned things during my 25 years of web dev.

I'm so confident it will help you, that I put the first 6 hours of the course for free on my YouTube channel. Feel free to watch here.

There's enough free training here, that even if you don't enroll in the full course you'll learn something about React that you didn't know before.

FAQs