 Courses from Joe Previte

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

This is a workshop that Joe held in preparation for Shareable Custom Hooks in React.

Hooks are awesome because they're "first-class" utility functions provided by React to let you hook into state and other features while writing components. The cool thing about Hooks is that you can build on top of them to make your own. It’s like writing a function on top of lodash. You can gather something that might be reusable, and then package it up into a custom hook. That is the beauty of writing a shareable custom Hook in React.

Shareable Hooks Workshop

GitHub fosters a fast, flexible, and collaborative development process that lets you work on your own or with others.

github

Learn how to open a git repo in the browser on [github.com](https://github.com/) using the GitHub CLI. In the folder of your repo, run `gh repo view watch` to open that repo in your browser. If you haven't done this before, you'll have to run through the login process by following the prompts in your terminal.

To learn more about the GitHub CLI, read the [manual](https://cli.github.com/manual/). 

Open Repo in Browser using GitHub CLI

Learn how to install the [GitHub cli](https://github.com/cli/cli). It's as simple as running `brew install github/gh/gh` in your terminal. 

Install the GitHub CLI

Learn how to add suggestions in a PR review. In the files changed view on GitHub, select the line you want to make a suggestion like you would a regular comment. Right above the text box, simply click the first button that says `Insert a suggestion`. On the main page, it shows the suggested change and even has a way for the author to merge the change. 

This is a way to give specific feedback that allows the author to commit your changes with the click of a button from the browser. 

Add Suggestions in a GitHub PR Review

Learn how to re-request a PR review. At the bottom, above the `Merge` button, there should be a `change requested` header if someone has requested a change. Click the down arrow then the three buttons and you can request another review. 

If the reviewer requests changes, this is the best way to notify them that the PR is ready for a second look. 

Re-Request a PR Review on GitHub

In this lesson, you will learn how to open a draft pull request on GitHub. When you open a new PR, before you click the create pr button, click the dropdown and select `Create Draft Pull Request`. It will have a flag on it stating that the PR is still a work in progress, helping to stop merges before your branch is ready. 

If you prefer to learn by reading, you can read the accompanying [blog post](https://joeprevite.com/open-a-draft-pr-on-github).

Open a GitHub Draft Pull Request 

In the settings of your repository, in the `Merge Button` section, select `Automatically Delete Head Branches`. Now when you merge a branch, the branch that is being merged will automatically be deleted. 

If you prefer to learn by reading, you can read the accompanying [blog post](https://joeprevite.com/automatically-delete-branches-after-merging-pull-requests).

Automatically Delete Branches after Merging Pull Requests on GitHub

Learn how to automatically squash commits on GitHub when merging pull requests. You can make this automatic in your repo's settings on GitHub or by clicking it in the dropdown menu when you go to merge a PR. 

If you prefer to learn by reading, you can read the accompanying [blog post](https://joeprevite.com/automatically-squash-commits-merging-pr-github).

Automatically Squash Commits on GitHub when Merging Pull Requests

In this lesson, you will learn how to automatically assign pull requests to other collaborators on GitHub. Create the file `.github/CODEOWNERS` and use the code `* {github_usernames}` and you're done. 

If you prefer to learn by reading, you can read the accompanying [blog post](https://joeprevite.com/auto-assign-pull-requests-github).

To learn more about the syntax for code owners, read the [GitHub docs](https://help.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners).


Auto-Assign a Pull Request on GitHub

Learn how to create a GitHub issue template inside of your repository. We make a template for feature requests by creating the file `.github/ISSUE_TEMPLATE/feature_request.md` inside of our repository. Then it's as simple as filling out the template with the form you want people to fill out.

This can save you time by adding basic requirements to bug reports and feature requests. If you prefer to learn by reading, you can read the accompanying [blog post](https://joeprevite.com/github-issue-template).

Link to example [GitHub issue template](https://gist.github.com/jsjoeio/024b2fac12413fc74d910d52bcc14aff).


Create a GitHub Issue Template 

Learn how to create a GitHub PR template in your repositories. It's as simple as creating a `.github` folder and a `pull_request_template.md` file in that folder. Then just fill out the template how you want. 

This can save you time and standardize your PR process. If you prefer to learn by reading, you can read the accompanying [blog post](https://joeprevite.com/github-pr-template).

Link to example [GitHub PR template](https://gist.github.com/jsjoeio/8f561ddb3415bdeb5a53955b4b16b88d).

Create a GitHub PR Template

GitHub is one of the most popular places for a developer to store their code. There are a lot of benefits that come with using GitHub such as easy collaboration on code with other programmers and developers and version control for your repositories. 

These help you to have a productive workflow but there are a lot more tools that are built into GitHub that you might not know about!

Dive into the weeds with Joe Previte as he provides for you some helpful tips and tricks you’ll need to run a productive repository with your team. 

He teaches you how to setup PR Templates to make sure your team doesn’t leave out vital information. You’ll learn about auto-assigning reviewers to your PR’s so that they don’t get missed. You’ll even get to learn a little about the GitHub CLI!

Joe teaches you how to:

- Creating issue templates
- Automatically delete branches after merging PR’s
- Open repositories in your browser using the GitHub CLI

... And more! 

So take your productivity up a notch when using GitHub and take Joe’s course today!

GitHub Tips & Tricks

In this video, we'll learn how to modify the default screenshot keyboard shortcut on macOS so that it copies our screenshot to our clipboard. This comes in handy if you share screenshots often.

Change Default Screenshot Key to Copy to Clipboard

Joe Previte is an active egghead instructor and blogger. This is a collection of screencast versions of selected blog posts. You can find his blog here: [joeprevite.com](https://joeprevite.com/)

Joe's Blog Posts as Screencasts

In this lesson, you will learn how to take a class component which uses state and convert it to a function component which utilizes the State Hook. The state hook returns a two-item array: the first item is the state value and the second value is the function to update the state value. 

Remember, Hooks can only be used in function components.

Change a Stateful React Class Component to a Function Component with the State Hook

Similar to the State Hook, the [Effect Hook](https://reactjs.org/docs/hooks-effect.html) is “first-class” in React and handy for performing side effects in function components. The Effect Hook is called by passing a function as the first argument. Here, you can perform side effects. If needed, you can pass an optional second argument, which is an array of dependencies. This tells React, "Only run my effect when these values change."

A tip from Ryan Florence on using the dependency array:

"[with which state does this effect synchronize with](https://twitter.com/ryanflorence/status/1125041041063665666?s=20)."

Use the React Effect Hook in Function Components

Writing your own custom State Hook is not as a daunting as you think. To keep things simple, we'll refactor our `text` state value that uses `useState` and instead create a custom hook called `useText`.

Write a Custom State Hook in React

Similar to writing a custom State Hook, we’ll write our own Effect Hook called `useStarWarsQuote`, which returns a random quote and a loading state.

Remember, hooks can only be used inside function components.

Write a Custom React Effect Hook

After writing your own custom hook, you can extract it into it’s own module using create-react-hook. This will let you bundle it as an npm package to easily share between projects and with the open source community. We'll extract our `useStarWarsQuote` from the previous video in it's own module. 


Extract a Custom Hook into its own Module with create-react-hook

It's always important to test your code, especially if you're open-sourcing it for others to use. In this video, we'll learn how to use [`react-hooks-testing-library`](https://github.com/testing-library/react-hooks-testing-library) to write a few tests for our custom hook.

Test your Custom Hook Module with react-hooks-testing-library

Before we publish our package, we want to make sure everything is set up correctly. We’ll cover versioning, preparing our package, adding a proper README, and updating our `package.json`.

Prepare a Custom React Hook to be Published as an npm Package

When comparing two visually similar websites, it can often be challenging to precisely identify the subtle differences between them. To facilitate a rapid analysis of these discrepancies, a practical technique involves leveraging Chrome's integrated developer tools to capture full-page screenshots of each site. Subsequently, these screenshots can be uploaded to a platform like AI Studio. There, the AI can analyze the images and generate a report detailing the variations. This entire process, leveraging a few quick shortcuts, can be completed in under a minute, delivering a comprehensive breakdown of the differences for efficient comparison and analysis.

Quickly Compare Two Sites Using AI Studio with Chrome Full Page Screenshots

It's fairly trivial to create a React project, but there's always a big hurdle between creating it locally and making it shareable so that someone else can run it. This lesson walks you through the process of automating creating a React project locally, creating the repository where it's going to be hosted, and creating shareable links where it can be run so that you can quickly and easily create single one-off demos and shoot them over to your friends and coworkers for sharing your code ideas in a working environment.


```bash
share-react-project() {
  if [[ -z "$1" ]]; then
    echo "Usage: share-react-project <project_name>"
    return 1
  fi

  local project_name="$1"
  local github_username=$(gh api /user --jq '.login')

  echo "Creating Vite project: $project_name"
  pnpm create vite "$project_name" --template react

  cd "$project_name"

  echo "Initializing Git repository"
  git init

  echo "Adding all files to Git"
  git add .

  echo "Creating initial commit"
  git commit -m "Initial commit"

  local codesandbox_link="https://codesandbox.io/p/github/${github_username}/${project_name}"

  echo "Adding CodeSandbox link to README.md"
  echo "" >> README.md
  echo "## CodeSandbox" >> README.md
  echo "[![Open in CodeSandbox](https://assets.codesandbox.io/github/button-edit-blue.svg)](${codesandbox_link})" >> README.md

  echo "Adding README.md to Git"
  git add README.md

  echo "Committing README.md changes"
  git commit -m "Add CodeSandbox link"

  echo "Creating GitHub repository: $github_username/$project_name"
  gh repo create "$github_username/$project_name" --public

  echo "Pushing to remote 'origin'"
  git push -u origin main

  echo "Project '$project_name' created successfully!"
  echo "GitHub repository: https://github.com/$github_username/$project_name"
  echo "CodeSandbox link: $codesandbox_link"
}
```

Automate Creating a Local React Project, GitHub Repository, and Live Hosted Demo in a Single Command

[Verdaccio](https://verdaccio.org/) is a fully featured NPM registry that you can run locally on your machine. It’s a great tool for testing your release process, running end-to-end tests, and simulating real-world scenarios like deploying packages, installing them, and verifying functionality as an end user would.

Nx includes a [generator](https://nx.dev/features/generate-code) that simplifies setting up Verdaccio. To configure it, run:

```shell
npx nx g @nx/js:setup-verdaccio   
```

This command installs the necessary NPM packages and creates a `project.json` file with a `local-registry` target. To start the local registry, open a new terminal window and run:

```shell
npx nx local-registry
```

This will:
- Launch the Verdaccio registry.
- Configure NPM to point to the local Verdaccio server at `http://localhost:4873`.

> **Note:** A `project.json` file provides an advanced way to define scripts, offering more flexibility than a traditional `package.json` for managing complex targets.

Setup local Verdaccio server to release NPM packages

Learn how to spin up a local NPM registry powered by Verdaccio to test deploy your NPM packages.

In TypeScript, developers often begin by defining the structure of their data using type definitions or interfaces, which is a powerful way to ensure type safety. However, as applications grow and become more complex, simply defining the shape of an object might not be enough to guarantee its consistent creation and behavior throughout the codebase. This often leads to situations where objects that are intended to be of a certain "type" might be missing crucial properties or have incorrect data, which can be difficult to track down and debug.

This lesson tackles the question of when and why to move beyond basic type definitions and embrace classes in TypeScript. It demonstrates how classes provide a more robust mechanism for defining object structure, enforcing type constraints, and ensuring consistent object creation. By establishing a clear blueprint for objects, classes not only improve compile-time type safety but also offer runtime benefits and better code organization, ultimately helping developers avoid common pitfalls associated with loosely structured objects in larger TypeScript projects.

Stop Avoiding Classes in TypeScript

Karabiner isn't only for your keyboard. It can also hijack your mouse buttons and enable them to be similar to layers on your keyboard, where holding down a mouse button can allow you to tap keys on your keyboard to trigger commands and macros that can completely revolutionize your workflows. For example, you can hold down the right mouse button and tap on R to go to references in VS Code. Or hold down the right mouse button and tap the left mouse button to chop up videos and Screenflow.

This completely unlocks a whole new world of possibilities and use cases for your mouse as you can hover your mouse over anywhere on the page. And just tapping keys on your keyboard allows you to trigger mouse actions, to trigger keyboard actions, or to trigger macros and applications and terminal commands. and anything that your imagination can come up with. 

Karabiner: Rethinking Right-Click as a Macro Command Center

Make an HTML table more readable on mobile devices by using the ::before pseudo-element. We add labels to each cell, so they appear like cards when the table is viewed on smaller screens. The ::before content is set using a data-label attribute for each cell to enhance mobile viewability without horizontal scrolling.



Create a mobile friendly table with the before pseudo-element

Learn to use CSS ::before pseudo-element for mobile-friendly HTML tables. Add labels to cells for enhanced readability on mobile, avoiding horizontal scroll.

Any app of a decent size has event flows and messages being passed around. At a certain point it becomes complicated to explain it through prose and you want to turn towards diagrams. Now setting aside the time to create diagrams that accurately describe what's happening in your codebase can be quite time consuming. Luckily, with today's AI tools, we can now just do basic walkthroughs with rough recordings over codebase dictating what's going on along the way and then upload that to tools like AI Studio and then ask it to generate diagrams in a text-based format such as Mermaid that will then generate the flowcharts and diagrams for us. So this video walks us through this process of recording a rough video, uploading it to AI Studio and then asking AI Studio to generate the proper Mermaid diagram syntax.

Generate Mermaid Flow Chart Diagrams with Gemini 2.0 from Rough Screen Recordings

I'm a diehard Karabiner user and anytime I start doing something repetitively I always move it into my Karabiner configuration. Sometimes I'll fall into scenarios where I want to trigger a command, but I also want to know if that command succeeded or failed. Since Karabiner can trigger any command, setting up the command is fairly straightforward, but knowing whether it succeeded or failed became much more difficult. Luckily for me there is a package called terminal-notifier that you can install from homebrew and you can pipe the output of your command to terminal-notifier. And have a seamless way of triggering your keyboard shortcut which runs a command and you can be notified of the results.

Use Karabiner to Trigger a Terminal Command and Get Notified of the Results

There are a lot of scenarios when inspecting a site in Chrome where you don't want any click events to fire and you don't want any scripts to run. Or maybe something is animating in and out of the page and you want to capture it at a certain moment. This is a great use case for pausing script execution, which is kind of using the debugger manually by going into the Chrome DevTools and the Sources tab and clicking the pause button to essentially pause the entire page. This will give you a chance to inspect any of the elements and styles you want to inspect. And you don't have to worry about fire and click events or anything that might interrupt your investigation into the elements and styles that you want to find.

Pause Script Execution in Chrome to Easily Inspect Elements

Gemini 2.0 has a context window of a million tokens, and this means that you can upload hundreds of files and allow it to inspect and analyze massive refactors across entire code bases. 

This lesson demonstrates concatenating an entire code base into a single file and then uploading it to AI Studio. Once within AI Studio, we ask it to find the types of tasks that it can evaluate for us. Then we select one of the tasks and ask it to generate instructions for that task. Once those instructions are complete, we then turn them over to Windsurf's Cascade agent, and we allow Windsurf's Cascade to do all of the work for us as we sit back, relax, and let the AI do our jobs.

Joe Previte

Search Results