 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


Using Cursor Chat, you can easily reference an entire directory of files and ask it to generate anything based on those files. This opens up the possibility of using your current code as a reference guide to create new code that follows existing patterns. With this approach, the result can be a polished prompt you can use with any AI to generate consistent and reliable output.

Focus less on crafting the perfect prompt upfront - what matters most is testing and iterating based on the AI's responses. The more results you see from the prompt, the more you can reinforce the good results and prune out the bad results until your prompt is polished enough that you can rely on the prompt to give you consistent quality results.


Create AI Prompts Based on a Directory of Files


With Cursor's "Composer" feature, you can select and entire directory and make changes to every file. This video walks through the process of selecting a folder and refactoring all the files from JavaScript to TypeScript. It also demonstrates other tips around generating terminal commands and customizing your main Cursor "Rules for AI".


Run an AI Refactor on Every File in a Directory with Cursor


This lesson breaks down the concept of asynchronous iterators and generators in JavaScript. Using the Node.js glob function as a practical example, you'll learn how Array.fromAsync facilitates the creation of arrays from asynchronous iterables and how generators can improve performance in file processing tasks.

Efficient File Processing in Node.js with Async Generators and Array.fromAsync

Learn the concept of asynchronous iterators and generators in JavaScript and Node.js Array.fromAsync


With the introduction of Svelte 5, the Svelte team has created a CLI, `sv`, that unifies all the tasks that previously spread across a handful of CLIS (create, add plugins, and migrate).

This lesson will create a Svelte project using the new `sv` CLI and build a counter component to showcase the new `$state`, `$derived`, and `$effect` runes that ship with the new version.



Get Started with Svelte 5 using the sv CLI

You'll create a SvelteKit project using the sv CLI and build a counter component showcasing Svelte $state, $derived, and $effect runes.



pnpm ships with a streamlined, easy way of managing Node.js versions for youself and your team. This video demonstrates why pnpm uses a specific version of Node.js, how to configure it globally, and how to set up your project so that anyone who is running your project will automatically use the same version of Node.js even if that version of Node.js is not installed.


use pnpm as a Node.js version manager

How you build with Angular has changed quite a lot over the years.

For example, the `inject` function was introduced in version 14 but you might still be familiar with Angular's constructor injection.

Similarly, structural directives like `ngif` or `ngfor` have been replaced with `@if` and `@for` blocks since version 17 and beyond.

These are patterns that need to be adjusted if you want to stay up-to-date with the latest Angular has to provide.

Luckily, Angular gives you great tools in the form of a migration CLI for supporting your migration efforts as you incrementally update your App from older version features and patterns. 

When you're done with this course you'll know how to target specific features, folders, and files to migrate to the latest Angular version.

You'll learn how to 'migrate':
- Structural directives with control flow syntax
- Constructor dependency inject to inject function
- Make components standalone
- Lazy load routes
- Input/Output decorators to signal-based API


Angular Migrations in Practice

Migrate old Angular patterns for version 18 and beyond

When we import assets in React components outside of the `public` folder that Nitro reads for assets by default when running the development server we need to tell Nitro how to find them with the `devProxy` configuration option.

```typescript
export default defineNitroConfig({
  renderer: './renderer.ts',
  devProxy: {
    '/app/assets': 'http://localhost:5173/app/assets'
  }
})
```

This is ultimately inadequate in scenarios where you want to import assets arbitrarily and have them "just work" but works in a pinch.



Use devProxy in Nitro Config to Serve Static Imported Assets in Dev Mode via Vite

Learn how to use devProxy in Nitro Config with Vite to serve static assets in React components in dev mode.

Start with a basic Vite React TypeScript app and enhance it for production use by integrating Nitro as the server. 

This requires a custom Vite plugin for nitro as well as a custom renderer and manually creating Nitro config.

The other way to approach this would be to add Vite to a Nitro app instead. Same basic result.

The [Nitro config reference](https://nitro.unjs.io/config) is a great read of you'd like to explore more options.


Configure a Vite React TypeScript Application on a Basic Nitro Server

Configure a Vite React TypeScript app by integrating Nitro for production, using custom plugins, renderers, and configs.

Quick Get Started style introduction to Vite using `pnpm create vite` with the React TypeScript template.

See [more in the official docs](https://vite.dev/guide/).

Create a Vite App with the React TypeScript Preset

Quick guide to start a Vite app using React TypeScript template with pnpm.

Over the years, your application have grown huge. Sometimes, really HUGE.

Many developers have contributed to the codebase. One day they pushed one coding style, a different one another day. Sometimes even different patterns and solutions for similar problems.

You want to keep your codebase consistent. In the Angular ecosystem, there were well established patterns for doing things the right way ™️. But the old solutions are being challenged by signal-based approach.

Eventually, you ask yourself the key question: **Should you integrate with the NEW solutions or stick to the battle-tested ones, but already considered LEGACY**?

That's a very good question indeed. Don't rush with architectural decisions 🤓.

## First, think of what problems you want to solve by introducing the change.

Do you have 1k LoC Angular components? Maybe even 2k? Do you and your team enjoy working with these? 😏

Where does the **domain logic and state management code** belong to - do you have a clear guidance on which code should be put where? Have you spot that different devs implement similar features in totally different ways?

Do you keep on asking the same questions over and over again: **whether this certain piece of code** should be **imperative** (plain old object properties and variables) or **reactive** (streams)? It'd be nice to keep all thinga reactive, but more often than not, it introduces complexity.

## Second, think of long-term consequences.

You are going to have more than one way to **manage the state**. But is that really an issue? If your codebase is modular, separate modules should not depend on each other in any way. Inner abstractions of one should be invisible to the other, etc.

You are going to introduce a **new tool**. On one hand, you need to learn it, and so does your team. But on the other hand, it's a breathe of fresh air. And it's useful to question the way you've been doing things so far. Maybe there's a more effective way?

You are going to embrace signal-based APIs. And that means taking taking advantage of Zoneless Angular. This means using all modern Angular APIs. And you know that signals are the future. Why would you want to stick to the **less performant, less type-safe, less flexible and, objectively, less effective solutions**?

## Finally, plan your INCREMENTAL integration.

INCREMENTAL is the absolute keyword here. You don't want to tell your PM you need to stop delivering features because of a refactor.

Actually, there's no need for a "refactor". Just pick the first new feature to be implemented. Or pick the one that needs to be extended.

NGRX Signal Store allows you to create both very simple & small stores, as well as bigger ones. **Composition** is the key here.

**Start simple**.

Create a `withState` section with the signals that hold the state. That's already reactive. And relatively simple.

```ts
const initialState: CartState = {
  items: ...,
  rebate: ...,
}

export const CartStore = signalStore(
  withState(initialState)
);
```

Create a `withMethods` section to provide ways to change the state:

```ts
export const CartStore = signalStore(
  ...
  withMethods((store) => ({
    addItem(item: ShoppingItem): void {
      patchState(store, (state) => ({ items: [ ...state.items, item ] }));
    },
    ...
);
```

Create a `withComputed` section to provide all derived computations:

```ts
export const CartStore = signalStore(
  ...
  withComputed(({ items }) => ({
    totalPrice: computed(() => items().reduce(...))
    ...
);
```

**Start simple**.

Now you can (literally) **`inject` this code into your existing solution**. All you need is to inject your brand new NGRX Signal Store implementation into a component, or a service:

```ts
@Injectable()
class ExistingBigService {
  cartStore = inject(CartStore)
  //...  
}
```

and that's it! What's beatiful is that NGRX Signal Store should remain an implementation details (of a component, service, etc). It **shouldn't leak outside to the entire application unintentionally**. Small NGRX Signal Stores help us to **keep logic more modular**.

Don't hesitate - give NGRX Signal Store a try! Start with the [_**Scalable Signals Angular Architecture with NGRX Signal Store**_](https://egghead.io/courses/scalable-signals-angular-architecture-with-ngrx-signal-store-a33abd39) course now!

Integrating NGRX Signal Store with an existing Angular application

Integrate NGRX Signal Store into your Angular app incrementally for modular, reactive state management. Improve consistency and performance with modern APIs.

Joe Previte

Search Results