But not for lack of trying!
Tutorials, books, courses, podcasts, blog posts… you've done 'em all, or you've tried to.
You've followed along, and sure, it made at least some kind of sense while you were assiduously reproducing each step, but just when you reach the end, everything you supposedly learned just…
from your mind into a vast, grey nothingness: The Fog of Uncertainty (or "FU", for short).
It's true that when you do those tutorials, you get a result! But you don't really know how. Or why. Or how you could use what you just learned — pardon me, "learned" — to create your app, from scratch. You sit down to try and it just…
You live in The Fog now.
React has turned you from a living, breathing human capable of learning and doing all kinds of things, into a throbbing question mark:
And the biggest question mark of all…
You don't think you're incapable. You're a developer. Of course you can learn to develop a new way! And of course, other people have managed to learn React. Clearly, it's not impossible.
Maybe if you tried harder…?
Reached back to one of those as-yet-unhelpful tutorials and tried your best to pound it into your brain — again?
But those tutorials really aren't helping.
Rather than making things easier — rather than giving you a calm, clear, simple framework you could use to build yourself out of the Fog of unknowingness — they pile more confusion on.
They've gotta mix it up with Webpack, Babel, Redux, React Router, Apollo, Next.js, Gatsby, SSR, Firebase, Docker… styled-components, emotion, or maybe Tailwind CSS... Plus, of course, ES6 itself, with its
let, and its weird little syntactic sugar like
Those other tutorials promise that all this overwhelm will be worth it, because you'll learn how to "build a full React app from end to end!"
But the problem with this approach is that you learn very little about a whole lot of things. When you go to apply your knowledge in the real world, you trip across massive holes in your knowledge and understanding. Conveniently hidden in The Fog, so you fall right in.
So maybe, you think, you can find a tutorial that covers your exact use case. Your exact feature set.
Has anyone built a React app that does x, y and z?
Of course, the very fact that you feel that this is your best hope for getting your project off the ground is… well… embarrassing to admit outloud.
It doesn't have to be this way.
And it's not your fault!
If you could wrap your hands and brain around the core of React, the technology, the mindset, itself…
Because you'd have a functional mental model to guide your hypotheses and trials. A strong framework of understanding to hang all the little bits on.
Time to start a new project? No problem! You could sit right down and start from scratch, with confidence and momentum. Free yourself from the hunt-and-pluck tutorial.
Overwhelming ecosystem? You got this. Armed with your mental model, you'd be able to unravel the complexity. You'd… just… get how all those extra libraries, tools, and techniques fit into the React world as a whole, and your needs in specific.
You could see React components when you look at designs for your project.
You could think in React.
You could feel like your savvy, capable self again.
Fog begone. Forever!
Burnt away by the sunlight of comprehension.
Plus, of course, you'd be able to reap all the expected benefits from mastering React — like power, flexibility, jobs… But you already know all about those.
When I started learning React, we didn't have Create React App. We had boilerplate projects, with mountains of files.
The sheer volume of stuff required just to say "Hello, World" was enough to make me want to run and hide.
There had to be an easier way, I thought — to pare it down to absolute essentials, and burn off the fog.
No messy boilerplate projects, no dependencies, just vanilla React.
So I set out to create a book, Pure React. I taught the basics of React the same way I had pieced it together… with small steps, and lots of practice exercises.
I knew I had to take a radically different approach than all the tutorials that had failed me (and you!) before.
Their missing ingredient? Focus.
The kind of laser-sharp focus that empowers you to build that mental framework, so you can see in React and think in React.
That's why, when you learn with Pure React…
The book-only version of Pure React has sold over 2,000 copies and helped so many developers like you (and me!).
Within the first hour of going through the book, I was accomplishing and understanding more than I did after a 35-hour Udemy course, thanks to having loads of opportunities to identify gaps in my knowledge.
But I knew I could create an even better, more powerful, experience that would make it even easier for you to claim the power of React.
I took the best parts of the Pure React book and turned them into a series of concise, self-paced video workshops that'll help you learn deeper, further, and faster.
Every lesson was battle-tested with a live audience — over 500 people in total! — and refined based on that feedback.
Every single video lesson has been professionally edited, reviewed, and play-tested to ensure the absolute highest quality learning materials for you to use to advance your skills as a web developer.
The lessons aren't the typical rambling, um-filled slog. They're short, easily digestible, and to-the-point.
And they're all built around small, achievable projects. We start small and work our way up.
You'll build a series of self-contained projects:
And through these bite-sized tutorials, you'll learn all the core skills you need to get started thinking and seeing in React. (Full list of modules below!)
Here's what you'll receive:
And you get all of this for the cost of one night in a moderately fancy hotel in a major city.
If you're ready to banish the Fog and claim the clarity and power of React for yourself, BUY NOW.
There's a lot of React material out there, and it spans the gamut from "a guy sat down and recorded himself live coding and uploaded it to Udemy for $10" to "professionally designed live events in major cities that cost $1,000 a day."
Pure React sits firmly in the second camp:
Compare to a live workshop…
With Pure React, you can learn how, where, and when you like without disrupting your life!
Plus you get all the material to keep forever, including the recordings themselves, full transcripts, the code, and the exercises.
At the current price, Pure React it a heckuva lot cheaper, too! If you have to travel for an in-person, all-day, butt- and brain-numbing workshop, $349 might just cover your hotel.
Hands-On React Basics:
And more Hooks!
setStatethe right way to avoid bugs
componentDidCatchand multiple error boundaries
The React Context API:
API calls and forms:
Tools, but minimal:
That's a lot of skills you'll pick up!
We'll cover arrow functions and how they differ from regular functions, statements vs. expressions (which will come in handy when you start working with React's JSX syntax), and the ...rest and ...spread operators (two names for three dots that look the same). Then we'll get into immutability and why it matters (super important to understand for avoiding weird bugs in your apps). You'll learn how to use the map, filter, and reduce functions — those three paragons of functional programing — with a special focus on making sure you truly (finally!) understand the
reduce function. And we'll close out by learning how to import and export modules.
Welcome to React! In this module you'll write your first React app, and learn how to build apps using React's JSX syntax. We're intentionally starting simple, with hard-coded data and no "state" to worry about. After working through these lessons you'll understand enough of React's fundamental concepts to be able to build static apps, just as you would with plain HTML.
Until this point, the components we've built have all been stateless and pretty much static. In this module, you'll learn how to write
class components in React to handle state, which will allow us to create interactive components.
Up until React 16.8, classes were the only way to add state to components. Today, we have Hooks that allow us to add state to function components without writing a class. So you might wonder, why learn classes at all?
The reality is that there is a mountain of React code that existed before Hooks, and plenty of companies aren't fond of rewriting code that already works. Having a full understanding of class components will give you an advantage when it comes to finding a React job, and it'll also help when looking for answers on StackOverflow and the like.
React version 16.8 added Hooks, a set of functions that allow you to add state and side effects to function components. In this module you'll learn how to use Hooks in your components! Starting with
useState, we'll cover how to add simple and complex state to your functions. From there we'll look at using
useReducer to handle more complex state. You'll learn how to write reusable custom hooks, too. And we'll talk about how hooks work behind the scenes to demystify the "magic". Finally we'll look at
useEffect and learn how to "think in effects" by converting a few class components to functions with hooks, and learn how to use the
useCallback hooks to optimize your components.
Not long after getting started with React, you'll want to pull in some data from an external source, whether that's your own API or someone else's. In this module we'll be building a Pet Store where we can view a list of pets in the adoption center, add new pets, edit their names and photos, and delete (er, adopt) them.
We'll start with a static app with hardcoded data and refactor it piece-by-piece until all the data is coming and going from an API server.
In many cases, teams reach for Redux as the de facto choice for state management. But sometimes, Redux is overkill. In those cases, the React Context API might suit your needs perfectly.
In this module, we’ll build a simple email client using the React Context API to pass data throughout the app. You’ll learn how to create a context, how to pass data deeply through an app without manually passing props all over the place, and how to group related data and logic using simple wrapper components. We’ll also cover practical applications like using Context to display and manage notifications and how to maximize performance with Context.
This book has been designed to get you from zero to React quickly, and with maximum understanding.
Pure React: The core concepts of React, in isolation, without Redux, Webpack, and the rest.
Learning everything at once is massively overwhelming. So in this book, we will take a different approach. A more sane approach. We will learn Pure React.
Purchasers of Pure React Pro will get access to video interviews with industry experts on topics that will help you go beyond Pure React.
I spent hours teaching all of this material to a live audience and honing it before ever recording a lesson. Those sessions were recorded, but the recordings haven't been available to the public until now. As a special bonus, included with the Pro package you'll get access to view those live events!