 Resources from Elijah Manor in 2021

In this collection of lessons we will create a developer dashboard in the terminal using react-blessed and react-blessed-contrib. We will discuss various ways to layout the dashboard, show how to change fonts, style with colors, and position text within each widget. Then we will shift focus on creating some widgets to display developer content such as an interactive time log, a pomodoro timer, displaying recent commits, currently running docker containers, and more. Once you know the basics you can create a widget of your own to add to the dashboard.

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

Build a Terminal Dashboard with React

Previously, in order to add state or side-effects in React you had to create a Class Component. However, with the introduction of the Hooks proposal (currently pre-released), you can now add state and effects to a Function Component. In addition, you can extract your hook logic and create a custom hook that can be shared across your app.

As I introduce the concepts of React hooks, I'll apply those concepts in various demos to see how they apply in different scenarios. I'll be converting Class Components to Function Components so you can see how they relate to each-other.

By the end of this course, you'll learn how to:

- Run (and Skip) side-effects with the useEffect hook
- Write a custom hook to share logic in your app
- Simplify the Context API with the useContext hook
- Update state with dispatch actions using the useReducer hook 
- Optimize Components with useMemo

Reusable State and Effects with React Hooks

You can’t be everywhere at once. Neither can node packages. But with a utility called npx — included in npm v5.2 and later — you can interact and run with node modules even if they’re not downloaded locally. The same is true for gists and remote branches of GitHub. As long as npm installed, your work can be wherever you are.

This course from Elijah Manor unlocks the power of the npx utility. Over 17 minutes, we will examine the npx package runner and look through various scenarios where the tool is helpful when running node packages from the command line. You’ll learn to use npm to:

- test out various versions of a package
- run packages without globally installing
- run code directly from GitHub
- make working with packages much easier

npm is the package manager for JavaScript. Find, share, and reuse packages of code from hundreds of thousands of developers — and assemble them in powerful new ways.

Execute npm Package Binaries with the npx Package Runner

In this course we will introduce the topic of using npm scripts as a build tool. We will start simple and then continue to build a small website as we introduce new topics. By the end of the course, you'll know how to get started and what tools and techniques are needed for you to create your own set of build scripts.

How to Use npm Scripts as Your Build Tool

Lessons about new features of the [Create React App 2.0](https://reactjs.org/blog/2018/10/01/create-react-app-v2.html) release.

Bite-size video tutorials for badass web developers.

egghead

Create React App 2.0

As an alternate to useState, you could also use the useReducer hook that provides state and a dispatch method for triggering actions. In this lesson, we’ll centralize logic that is spread across a web application and centralize it using the useReducer hook.


Use the useReducer Hook and Dispatch Actions to Update State 

React changed their Context API in version 16.3 to include Provider and Consumer components. Inside of a Function Component you can leverage the useContext hook to wire-up a consumer instead of using the Render Props Consumer component.


Use the useContext Hook to Wire-up the React Context API 

Historically, only Class Components could extend PureComponent or implement their own shouldComponentUpdate method to control when it's render was actually invoked. However, now you can use React.memo HOC to provide this same type of control with Function Components. This isn't specific to Hooks, but was released in React 16.6 and complements the hooks API.


Simulate PureComponent with a React Function Component

Certain calculations or operations can take a long time. React provides a useMemo hook that will return cached results from previous calculations, which can dramatically speed up render time.

Leverage the React useMemo Hook for Expensive Operations

Render Props is a popular pattern in React, but sometimes the nesting of Components can get quite deep. Thankfully, React Hooks can help provide an alternate way to structure your code for reuse. In this lesson, we will take an existing Render Props Component and convert it to use a hooks instead.

Convert a Render Props Component using a Custom React Hook

In this course we start by getting your environment setup for hooks and then we’ll introduce the idea of adding state to a function component and unpacking several ways to interact with that state.

There are a few rules that you need to follow when you start using hooks, but thankfully there's a custom ESLint plugin that’ll help enforce these rules. I’ll show how to setup the hooks plugin and talk about some of the rules that should be followed.

Things get more interesting and involved once we introduce side-effects to our function component with the useEffect hook. We’ll uncover numerous things to consider while using this particular hook.

One of the cool features of hooks is that it’s easy to abstract out code for reuse with custom hooks. The React community has already created lots of custom hooks that you can start playing with today.

Once I've introduced the main concepts of useState and useEffect, I'll start to unpack other hooks such as useRef, useReducer, useContext, useMemo, and useCallback.

Introduction to Reusable State and Effects with React Hooks

Cascading Style Sheets bring order and beauty to our applications.

Firefox DevTools has an awesome feature that helps you determine Inactive CSS, to know why it's inactive, it gives you hints on how to fix it, and even links to documentation for additional help.

Understand why CSS has no effect with the Inactive CSS rules indicator in Firefox DevTools

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

node

When you or your team work on various npm or yarn projects it gets hard to remember which one is which. This lesson shows you how to create a custom `npm` zsh function alias to remind yourself to use yarn commands when there is a `yarn.lock` file in the directory.

Make a zsh function alias to enforce using yarn commands when in a yarn project

In this lesson we focus on toggling animations on and off using the prefers-reduced-motion media query. The sample web app has 3 types of animations (CSS, SVG SMIL, and JavaScript) and we will toggle these animations using different techniques such as @media, matchMedia, and a custom hook.

Use the `prefers-reduced-motion` media query to toggle CSS and JavaScript animations

In this lesson we are going to build a React Teleprompter web application using the [`Web Speech API`](https://developer.mozilla.org/en-US/docs/Web/API/Web_Speech_API). In particular, we'll use the [`SpeechRecognition`](https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition) interface to recognize the user's voice, match the words to a predefined script, and automatically scroll to the next unspoken position. 

Create a React Teleprompter using SpeechRecognition, string-similarity, and scrollIntoView

In this lesson we will start to create a terminal React application with [`react-blessed`](https://github.com/Yomguithereal/react-blessed), which is a custom renderer for React. If you already know how to use React with the DOM, then you should be able to leverage a lot of what you already know to build an app for the terminal.

Bootstrap a `react-blessed` Terminal Application

This code at this point in the React Terminal Dashboard series is minimal, but as code starts to accumulate it'll be helpful to statically analyze the validity of our code going forward with ESLint and several plugins that are specific to React.

Add ESLint Rules to a `react-blessed` Application

In order to make text a bit more interesting in a `react-blessed` terminal app, we'll use the `figlet` node module to spice up our text with a bit of fancy ASCII Art. We'll define an array of various fonts and iterate through them every second as we experiment with this feature.

Change text font with `figlet` inside a `react-blessed` Application

Currently most of the code for our React Terminal Dashboard is all in one big file. This can become a problem as we continue to build the dashboard as it can hard to managed. So, we'll move out each section of our dashboard (which is just one at the moment) into their own React component. Along the way, we'll refactor a useEffect/setTimeout to leverage the useInterval custom hook.

Extract a `react-blessed` Component and Add the `useInterval` Hook

In this lesson we will be adding weather information to our `react-blessed` Terminal Dashboard using the `weather-js` node module. This module uses an error-first callback style API, but we'll convert it to a promise with `util.promisify` so that we can use it via `async`/`await`.

Fetch the current weather with `weather-js` and display in `react-blessed`

While extracting a custom useRequest hook from our Terminal React Dashboard we encounter a run-away useEffect bug. As a result we introduce the [stop-runaway-react-effects](https://github.com/kentcdodds/stop-runaway-react-effects) tool to help detect the bug and then fix the it with useMemo and then the [use-deep-compare-effect](https://github.com/kentcdodds/use-deep-compare-effect) hook.

Topics

Instructors

Content Type