React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

Learn React

In this course, we will incorporate [react-intl](https://github.com/yahoo/react-intl) into a project created with [create-react-app](https://github.com/facebookincubator/create-react-app) and [react-router](https://github.com/ReactTraining/react-router). The react-intl library makes complex tasks such as internationalization and formatting dates & currency incredibly simple. Another huge benefit of react-intl is that it gives you the ability to centralize the content across your application into language specific files. This creates a consistent place to find content and encourages reuse. If you’ve ever used language specific `yml` files in Rails, you’re already familiar with this pattern.

Starting with the entry point of the application, we will hit the ground running by adding the necessary components and data structures required for `react-intl` to function. From there, we will use `react-intl` components to format various types of data including strings, dates, and numbers. We will also work through writing tests for components that include `react-intl` components using Jest and enzyme.

Add Internationalization (i18n) to a React app using React Intl

In this course we are going to take an empty React and Redux application and add Redux Saga side effects. We’ll begin by installing saga to the app and implement a basic saga generator function. We’ll explore the saga commands provided by Redux Saga and what the difference is between blocking and non-blocking actions. 

We will also understand how to concurrently run sagas with saga helpers and how we wire everything up with the Redux store. Finally, we’ll finish up by implementing tests for our sagas.

Async React with Redux Saga

In this course we will begin with nothing more than an empty directory & a text editor. Through small, focussed lessons we’ll learn how to setup our app with Webpack & Babel and how to configure these tools for use with Preact. Then we’ll move on to learning how to create components and how the Preact API mirrors that of React - highlighting the differences/additions along the way. Finally we’ll look at the interoperability with existing popular libraries in the React community such as Redux & React Router and with the popular development tools such as Redux Dev Tools & React Dev-Tools

Up and running with Preact

React 16 comes with some powerful new features, in this course we'll be exploring each of them. Each lesson is going to go over every individual new feature, one at a time.
From the new error boundaries that will save us many a headache to handling whether to update our state *within* our `setState` 

We won't just be learning the technical capabilities of the new features however, we'll *also* be going into best practices. 

Once you watch this course you'll be more than ready to leverage everything React 16 has to offer! 

Leverage New Features of React 16

In this course, you will learn to use many of the most powerful and convenient higher-order components within Recompose by coding several real-world examples. Using recompose looks very different from “vanilla” React; so you will also get comfortable with the look and feel of a “recomposed” component. The best part is no more need for class components! You’ll learn how to use Recompose to both modify components and also create your own higher-order components.

Higher Order Components with Functional Patterns Using Recompose

A large part of a software developer’s time is spent searching the internet for answers to a never-ending stream of questions. Often, the answers we find are on blogs written by people who’ve been there, and found a solution. Isn’t it time you paid it forward?

Gatsby.js is a static site generator for React with a plugin ecosystem that makes it super easy to publish.

In this course, you’ll build a Gatsby site that transforms Markdown documents from your local filesystem into HTML. From there, you’ll use GraphQL to query posts for displaying on an index page, link between posts, and group posts by tags. After your site has been compiled, you’ll see how to deploy it via Github Pages.

[Community Notes for this workshop can be found here.](https://github.com/eggheadio-projects/build-a-blog-with-react-and-markdown-using-gatsby-notes)

Build a Blog with React and Markdown using Gatsby

With the variety of choice we have in building modern web applications using JavaScript, it can make it difficult to understand where to even begin. We live in a wondrous era, where every problem we have seems to have a corresponding javascript module on npm that we can install with just a few keystrokes. It’s easy!


Often, “easy” can mean the opposite of simple. Easy is “quick to do”, where simple is “quick to understand”.


KISS.


In this course you will learn how to build production quality React applications. We will strive to keep things as simple as possible, with minimal dependencies. Instead of typing `npm install`, we will build our own simple solutions first, to get a solid understanding of the problems that we are solving through libraries. We will build our tools in a functional style, and write appropriate unit tests to verify that they work as expected.


If you are brand new to React, you’ll want to read the documentation and watch our [free React Fundamentals course](https://egghead.io/courses/react-fundamentals).

Build Your First Production Quality React App

React Router v4 takes an entirely new approach to routing and handling URLs in your React applications. It fully embraces the concept of declarative programming and a component based development process. In practice, this turns out to be very nice and gives you a routing solution that is less configuration heavy than many previous solutions.

In this course, you will learn about the basics of React Router v4 to help you get started. We will look at the core components that React Router supplies and how they interact together to create a robust routing solution for your React applications.

Add routing to React apps using React Router v4

In this course we will learn and demonstrate the basic concepts of the React Native Animated API. We'll use Animated calls like `timing` and `spring` to animate style properties, and learn how to combine animations to create more complex effects. We'll learn about more advanced interactions like animations with touch events, interpolation, and flip animations. The ultimate goal is to gain an understanding of how to animate React Native Views, how you can apply them to many different types of styles, and how to enhance the experience in your application.

Animate React Native UI Elements

React provides are a powerful paradigm for creating UI applications with JavaScript. TypeScript can greatly increase the maintainability of React applications by opening up syntax for self-documenting code.

In this course, we will cover how to set up a React application with TypeScript and use TypeScript for React applications


Use TypeScript to develop React Applications

In this course we’ll explore getting started with a basic React Native application on both iOS and Android. We’ll learn about using React Native components, how to build custom components, how to layout an application using Flexbox, and how to style components.


We’ll also focus on how to use state to control components, how to persist information across application reloads with AsyncStorage, and how to inline edit in a ListView.

The ultimate goal is to gain an understanding of how to get started building simple React Native applications.

Build a React Native Todo Application

React Suspense has been released in React 16.6.0 (React.lazy support only) and React Hooks is stable in 16.8.0! Let's see how we can use these and more features of React together to write simpler React components.

React Hooks and Suspense

This course will pick up where we left off with the [Redux Fundamentals course](https://egghead.io/series/getting-started-with-redux). If you haven't watched that yet, you are highly encouraged to do so!

You are about to learn practical production ready techniques for building your React and Redux applications. You will explore advanced state management, middleware, React Router integration, and other common problems you are likely to encounter while building applications for your clients and customers.

Even if you have already spent time studying Redux, this course will show you better practices straight from the library's creator Dan Abramov.

**[Click here to see the Community Notes on this course](https://github.com/tayiorbeii/egghead.io_idiomatic_redux_course_notes)**


Building React Applications with Idiomatic Redux

MobX is designed to enable building web applications with a complex data model in an intuitive and very performant manner. Using React and MobX is currently the simplest way to build component based web applications.

"Half the code, twice the fun" is how people describe MobX, or "So simple, I cannot believe it just works". 



Manage Complex State in React Apps with MobX

React Router is the defacto router for any React application and it allows us to extract the state of our application from the browser's address bar.

In this course we'll explore the core features of React Router in common examples.  From routing with individual components to more complex routing consisting of multiple components, query-strings, route parameters,  and redirects.  

Getting Started with React Router v3

This playlist will guide you trough short circuit operators in JavaScript. In the first video you will get an introduction to what short circuits are proceeded with some of the most popular practical applications of it.

Learn Practical Application of Short Circuits in JavaScript

As a React application grows, so does the needs for organization and patterns. How do components communicate? How do we manage state across the application? How is data shared between components? 

These are the questions that Flux was built to answer.

In this series, we will explore React Flux, using ES6 (ES2015), babel, and webpack to manage our developer workflow.

React: Flux Architecture (ES6)

The definition of "legacy code" can be described simply as "code that doesn't have tests." Code you just wrote, 5 minutes ago? Legacy code. Code that can't be **refactored**, but only changed.

How do we prevent the mountain of legacy code that most projects become?

A solid testing strategy.

React apps are no different, and can be tested simply if you know some core principles.

In this course we will take a look at testing React applications. From getting setup and running tests, all the way through testing Redux enabled React applications.

React Testing Cookbook

In this comprehensive tutorial, Dan Abramov - the creator of Redux - will teach you how to manage state in your [React](/q/react) application with [Redux](/q/redux). 

[State management](https://egghead.io/playlists/react-state-management-in-2021-6732) is absolutely critical in providing users with a well-crafted experience with minimal bugs. 

It's also one of the hardest aspects of a modern front-end application to get right.

Redux provides a solid, stable, and mature solution to managing state in your React application. Through a handful of small, useful patterns, Redux can transform your application from a total mess of confusing and scattered state, into a delightfully organized, easy to understand modern [JavaScript](/q/javascript) powerhouse.

The principles of Redux aren't new, but they are packaged and presented for you in an easy to use a library that not only elevates your applications but also improves your general understanding of building JavaScript UIs.

In this course, Dan Abramov will show you the fundamentals of Redux, so that you can start using it to simplify your applications. 

There are some amazing [community notes on this course here on Github](https://github.com/tayiorbeii/egghead.io_redux_course_notes).



Fundamentals of Redux Course from Dan Abramov

Tailwind is a utility-first CSS framework for rapidly building custom user interfaces.

tailwind

Migrate from Create-React-App to Gatsby - Start Project

Lessons based on posts from my blog - https://kyleshevlin.com

Topics

Instructors

Content Type