 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

Mock Service Worker is an API mocking library that allows you to write client-agnostic mocks and reuse them across any frameworks, tools, and environments.



Mocking WebSocket APIs with Mock Service Worker


While using anonymous functions might seem convenient, they can create difficulties when trying to identify performance bottlenecks during profiling. This lesson will demonstrate how named functions make it easier to pinpoint and address performance issues, ultimately leading to more efficient and debuggable code. Learning this practice will greatly improve your ability to locate and fix performance issues in complex projects.

Always Name Functions in JavaScript


When attempting to load the same module twice in JavaScript you'll hit a cache and code won't re-run. In scenarios where you actually do want to have state in your modules, you'll have to use a cache-busting technique by passing a query parameter to a dynamic import. This lesson walks through how to add a query parameter, how to add the appropriate types for loading dynamic modules in TypeScript, and when these techniques are valuable.

Import the Same JavaScript Module Multiple Times with Cache Busting



The include keyword in GitHub Actions empowers you to add custom variables to your matrix strategy, providing flexibility beyond standard configurations. In this video, we'll explore how include allows you to define specific combinations of variables, enhancing control over your workflow runs. You'll see how this feature enables you to tailor jobs for unique environments or scenarios not covered by the default matrix options. By leveraging include, you can efficiently manage complex build processes with greater precision. This technique helps you streamline your CI/CD pipeline, making it more adaptable to your project's evolving needs.

Use GitHub Actions Matrix Include for Complex Job Configurations

While running `zod` schema validation agains domain-rich objects, the error message saying that _a string is not a number_ might not be really useful.

Especially, when you need to provide a meaningful feeback to the user, e.g. after they have submitted a form with lots of data.

`zod` allows to customize messages on a very granular level. We can also extract repeatable customization to `zod` error maps.

Finally, in order to process an error message further (e.g. display it to the user), we need to handle the `zod` validation errors effectively. Especially, when a big object validation has failed and we could receive a handful of errors.

That's what we learn in this lesson. 🔥

Customize zod Error Messages and Handle zod Errors Effectively

customize zod validation messages, customize zod schema property messages, reuse error maps across different schemas, navigate through zod error objects

You might want to run `zod` schema checks in different styles.

Sometimes you prefer to conditionally throw the error - that's what `parse` does. But another time you'd prefer to receive a `boolean` property that determines whether the validation was successful or not - and perform further actions accordingly.

Additionally, the error-throwing API of `parse` works extremely well with [TypeScript assertion functions](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions). Their combination is just... perfect! 👌

That's what we learn in this lesson.

Use parse and safeParse Runtime Type-checks with zod

use zod parse function to conditionally throw ZodError, use zod safeParse to get a boolean value and run typescript type guard over success property

In this lesson we learn that TypeScript cannot guarantee correct shapes of responses. That's due to TS performing checks in compile-time, while the response will be availbale in runtime - when TS doesn't exist anymore.

In some situations, such as HTTP requests, runtime type checks such as `zod` are essential for providing quick feedback around data-related errors.

Understand where are the possible mistakes to make while using TypeScript with HTTP calls. Use `fetch` and `axios` along with `zod` schema checks.

Also, note that similar mistakes or mistakes could happen while using web storage (e.g. `localStorage`)

Validate HTTP API Response with zod, fetch and axios

use zod as an HTTP response validation tool along with fetch and axios in order to make sure that the response has expected data structure

In this lesson we learn that the `zod` schemas become the single source of truth.

We shall not update TypeScript types manually, since they are generated automatically from the schema.

Same with validation functions.

Whenever the schema changes, all the rest will update accordingly. It's an important mind shift.

Treat zod Schemas as Single Source of Truth

Zod Schemas are the single source of truth for both typescript types, and interfaces - and runtime validation functions. Schemas should be updated first.

`zod` is powerful, but writing the schemas manually for existing JSON objects, especially big ones, can be time-consuming.

But that's what `quicktype` is for! You can get 80% work done instantly! 🥳

Depending on your need - whether you want to automate the process, or do it just one time, you can:
- use an online app
- use an IDE extension
- run a CLI script
- generate a script to be executed within CI/CD environment/tooling

And this is what we learn in this lesson! 🔥🔥🔥

Get started with zod quickly!

Generate zod Schemas Automatically using Quicktype App, Extensions and Scripts

Use quicktype app, extension or scripts to automatically generate zod schemas from existing json files. Save time and get started with zod quickly!

`zod` is a powerful library allowing to run runtime type-checks.

It's complementary to TypeScript, which does type checks in compile time.

In this lesson we create few schemas that represent primitive type values, along with `zod` utilities which make these more precise. We also create object schemas and nest one inside another.

All schemas are being validated against example values. We analyze how to interpret error messages in case of failures.

Perform Runtime Type-checks on Primitives and Objects with zod

Create zod schemas to validate primitive type and object type values in runtime. Analyze the errors to see how a value doesn't correspond to schema expectations

Joe Previte

Search Results