 Courses from Michel Weststrate

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

The UI we’ve build in the previous lessons works fine. But, we can make it way more efficient and we will use the React profiler to analyse our app.

Since parts of the state tree that haven’t changed compared to the previous state, are shared, we can optimize. This lesson uses the “memo” and “useCallback”  functions from React to benefit from structural sharing.

Profile React Rendering and Optimize with memo to Leverage Structural Sharing

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

Once we’ve written a bunch of producer functions, we quickly discover a recurring pattern: In practice producers can be defined purely in terms of the draft (and any remaining arguments). Therefor we can factor out the function nesting by leveraging currying. We will also look at the “original” function.

Simplify Immer Producer Functions using Currying

In the immutable data paradigm, it is quite important that we don’t accidentally change the data somewhere. It would break the paradigm in ways that are very hard to debug. In this lesson we’ll discover how Immer can help us by automatically freezing all data that is produced.

Furthermore, when writing reducers by hand it is quite easy to accidentally create new state trees, where this wasn’t needed. We will discover how Immer avoids this problem.

Produces Immutable Data and Avoid Unnecessary Creation of New Data Trees with Immer

Occasionally, you might want to write a producer that doesn’t change the draft, but rather returns a completely new data set. This can be achieved by using the return keyword.

Return Completely New State from an Immer Producer

Sometimes our update logic is asynchronous. In this lesson we will investigate two ways in which we can write asynchronous update logic. 

…But, we will also discuss why asynchronous producers should be avoided, and how that can be done by better separating our logic. 

This lesson also demonstrates the “createDraft” and “finishDraft” APIs

Write Asynchronous Producers in Immer and Why You Shouldn’t

When using immutable data as state representation; update logic is often captured in reducers. In this lesson we will take our existing logic, and express it using a typical reducer.

Update Immutable State with React useReducer through Immer

Since Immer records the changes we are trying to apply to our state, it can produce JSON patches. They describe the minimal difference between two versions of the state. This lesson introduces the “produceWithPatches” API.

Capture Patches to Distribute Changes in App State with Immer produceWithPatches

In this lesson we will send patches over a WebSocket to our server, and distribute them again from there.

Create a Simple WebSocket Server to Distribute Patches from Immer

Continuing on the previous lesson, in this one we will make sure that clients can receive patches, and apply them to their local state so that we get real time synchronization. This lesson introduces the “applyPatches” API.

Apply Patches using Immer applyPatches to Synchronize State across Clients

Our naive synchronization implementation has some flaws. In this lesson we are going to address one of them, by changing our index-based storage to key based storage, which enables us to better deal with synchronization issues. 

Create Stable Patches in Immer by updating with Id instead of Indices

Many cool things can be done with immutable data and patches. In this lesson we will highlight one fun trick: Compressing patches by replaying and re-recording them so that we end up with the least amount of patches to end up in the correct final state.

Compress the Immer Patch History by Replaying Patches on a setInterval

In our last lesson we will add another big feature, undo that works even when multiple users are present. We will build undo by using inverse patches, that are like patches, but can be used to replay from the next state to the previous state.

Use Immer inversePatches to Build Undo Functionality

In this lesson we will capture our undo history with a stack and a pointer, so that we will able to implement redo as well.

Use Immer Patches to Build Redo Functionality

Using immutable data to store state has many interesting benefits. Immutable data makes it easy to trace state over time. It can be distributed easily, and by leveraging structural sharing we can leverage optimization techniques such as memoization.

In this course we will build a multi user gift-list, in which we will discover how using immer doesn’t just significantly simplifies our state manipulation code. It also provides us with very useful tools such as patches that can help us to distribute changes, build undo/ redo, etc.

Introduction to the in-depth Immer course

Our core logic of the Gifts application is written using pure functions, that produce an entirely new, immutable state. This allows us to reap the benefits of immutability in the remainder of the course.

Capture Application Logic in Pure Functions to Create Immutable State

Our “app” now stores it state using immutable values. However, that wasn’t easy. Luckily Immer can help us to write logic in way more straight-forward ways, without loosing any of the benefits of immutability. We will introduce the concepts “produce”, “draft” and “recipe”

Simplify Deep State Updates using Immer produce

It is time to create a simple front-end for our application. As example, we will use React in this course to render our data. We will use setState to store our application’s state, and hook the event handlers up to the logic we wrote before.

Render Immutable Data using React

The great thing about having producers outside components is that it is becomes very straightforward to test them independent of our UI logic.

However, in some cases your logic might be so simple that you want to use Immer inside some of your react components. In this lesson we will discover how. For example by using “useImmer” or “useImmerReducer” from the use-immer package.

Immutable Update State inside React components with useImmer

A small caveat with Immer is that arrow functions that consist of just an expression, and not a function block, always return a value.

In this lesson we will show that in these cases the `void` keyword can be used to avoid accidentally returning new state in addition to modifying the draft.

Avoid Accidental Returns of New State by using the void Keyword

Because the code put in recipe functions is plain, native, mutable JavaScript code, Immer is naturally suited to be used in conjunction of TypeScript (or Flow). 

In this lesson we will discover how to combine Immer with TypeScript, and how to type our data types both with simple types and with readonly types.

Type Immutable Immer Data with TypeScript

Using immutable data structures provides many benefits, including making your code easier to reason about and less prone to bugs.

However, since JavaScript doesn't include support for immutable data structures out of the box, you need to use a third party library. But which one to choose?

In this self-paced workshop, Immer's creator Michel Westrate will guide you through the creation of a multi-user Gift Tracking app.

You'll learn the basics of using Immer to handle immutable state updates, then go further into change distribution and implementing an undo/redo.

After this workshop, you'll be ready to leverage immutable data structures in your own applications!

Immutable JavaScript Data Structures with Immer

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


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


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.


Michel Weststrate

Search Results