Learn Redux, Riot and Scikit-learn

Redux is a predictable state container for JavaScript apps.
It helps you write applications that behave consistently, run in different environments (client, server, and native), and are easy to test.

redux


With our migration complete, you notice that there is A TON of Redux code we can simply delete. We no longer have to manually handle all the server interactions that our application requires to function. Redux can handle the client-side state that it was meant to handle and RTK Query can take care of fetching and caching our network data.

Not only is our code base cleaner and easier to understand but it also provides a significant boost in the user experience of our application by making features like prefetching, optimistic updates, loading and error states easier to include.

If you're running a redux application in production I suggest taking a serious look at RTK Query. After this course you should have all the tools you need to make that happen.


Delete Unused Redux Code After Migrating to RTK Query

RTK Query is built on top of Redux which has the huge benefit of utlizing the [Redux DevTools](https://chrome.google.com/webstore/detail/redux-devtools/lmhkpmbekcpmknklioeibfkpmmfibljd?hl=en). Every RTK Query operation is represented with the actions and state modifications that happen in the DevTools. 

There's also RTK Query tab in Redux DevTools so that you can take a detailed look at the various queries and mutations you have going at any given time.

In this lesson you'll get a basic overview of the Redux DevTools and how it works with RTK Query.

Debug RTK Query Applications with the Redux DevTools Chrome Extension

The previous prefetching that we did with the `initiate` method is most useful for data that will existing on your initial page load. For other data throughout your application pre-loading can still come in handy, but you need to be thoughtful about what gets loaded, and when.

RTK Query gives you a `usePrefetch` hook that you can sprinkle throughout your application depending on what your user is doing. In this lesson, we prefetch dog data when the user hovers over the dog and services links, indicating their intent to load those page. With this approach to pre-fetching it's unlikely your users will ever see a loading spinner.

The documentation for RTK Query's `usePrefetch` hook can be found here:
https://redux-toolkit.js.org/rtk-query/usage/prefetching#prefetching-with-react-hooks


Prefetch Data in Response to User Interactivity with RTK Query's usePrefetch hook


RTK Query can start fetching data in your application before React is even available. This can be handy when your application relies heavily on data that you need to fetch. This data is cached so your users won't be refetching this data when they navigate through out the application.

Prefetching relies on the powerful `api.endpoints.<queryName>.initiate()` method that underlies much RTK Query's internals. For RTK Query to process and store initiate() calls properly they have to be sent into the redux store with `store.dispatch()`.

An advanced variation of this splits your main app file into the data pre-fetching (done first) and then your react application (lazy-loaded with `import()`). The idea being that you want to start your data calls before JS has to even start process what's likely to be a large bundle file.

For more information about prefetching with RTK Qyery see: https://redux-toolkit.js.org/rtk-query/usage/prefetching#prefetching-without-hooks.


Prefetch Data in RTK Query using an Endpoint's initiate() Method

In this lesson we look at the options for modifying headers on your queries. We start with adding a `headers` object to an individual query. That requires moving our query from returning a url string, to returning an object with the URL and the new `headers` property. We also add `headers` to our `baseQuery`, but replace that with the more flexible [prepareHeaders](https://redux-toolkit.js.org/rtk-query/api/fetchBaseQuery#prepareheaders).

`prepareHeaders` relies on the [Headers object](https://developer.mozilla.org/en-US/docs/Web/API/Headers) that is part of the Fetch API. As a second argument you also can access the current redux state. Accessing the redux state is helpful if you want to access saved data such as an authentication token.

Here's an example of using `prepareHeaders` for setting an `authorization` header:
https://redux-toolkit.js.org/rtk-query/api/fetchBaseQuery#setting-default-headers-on-requests


Customize Query and Mutation Headers in RTK Query with prepareHeaders


The thing about optimistic updates is that sometimes the worst case happens: your server fails. RTK Query makes handling this case incredibly easy.

In your `onQueryStarted` handler you have access to the original promise (similar to the results of `unwrap()`) in a value called `queryFulfilled`. With this value you can add a `.catch()` which will be ready to handle any non-200 response and in there you can call `.undo()` on the results of dispatching `api.util.updateQueryData`.

Doing that will revert your redux and rtk query state to where it was before your made the change. It's honestly kind of magical.

The document for optimistic updates and undo can be found here: https://redux-toolkit.js.org/rtk-query/usage/manual-cache-updates#optimistic-updates


Undo an Optimistic Update in RTK Query with queryFulfilled


Optimistic updates are great for user experience. In this lesson we purposefully setup the remove dogs handler to wait several seconds to return. That meant for an awkward experience for users while waiting for the dog deletion to go through. It's going to go through 99% of the time right? Why not just respond like it worked? That's what optimistic updates allow you to do.

In every query or mutation you define, you have the option of including an `onQueryStarted` listener, which will be executed just as the query is fired off. In there you receive the arguments passed into the query or mutation as the first, and then a number of utilities including `dispatch` passed as the second argument.

This will let you `dispatch(api.util.updateQueryData(<queryName>, <queryArgument>, <modificationFn>))` and modify the cached data stored for that particular query.

If you're using `invalidateTags` with your mutation as well as manually modifying the cache, your cache will be updated immediately and then refetched after the mutation was successful.

Two example of optimistic updates with RTK Query can be found here:

- https://redux-toolkit.js.org/rtk-query/usage/manual-cache-updates#optimistic-updates
- https://redux-toolkit.js.org/rtk-query/usage/examples#react-optimistic-updates


Perform Optimistic Updates in RTK Query by Dispatching the updateQueryData Action


This is a small lesson that covers a tiny feature of RTK Query that enables two additional refetch options: `refetchOnMount` and `refetchOnReconnect`.

In order to support them you need to include `setupListeners()` in your redux store. And then you'll have the ability to automatically refetch data when your page comes into focus or reconnects to the network. The main idea is if you're outside of the page on a different app and come back it will make sure your users are seeing the most up-to-date information.

More information about these options can be found here:

- https://redux-toolkit.js.org/rtk-query/overview#configure-the-store
- https://redux-toolkit.js.org/rtk-query/api/createApi#refetchonfocus
- https://redux-toolkit.js.org/rtk-query/api/createApi#refetchonreconnect


Refetch Data on Focus And Reconnect with RTK Query's setupListeners


The tags feature shown in this lesson is arguably RTK Query's best feature. It's conceptually simple, but incredibly powerful. If you can know ahead of time which operations will invalidate your data, then you should always refresh the data after you perform those operations.

The basic premise is that you specify which tags queries rely on with `providesTags` and then which tags a mutation will invalidate with `invalidatesTags`.

One of the advanced things you can do with tags, which we don't cover here is configuring mutations to invalidate tags with a specific ID. So imagine if you edit an entry, you don't want it to invalidate every other entry, just that one AND the list. This is covered in the [automated refreshing](https://redux-toolkit.js.org/rtk-query/usage/automated-refetching) section of the RTK Query Docs. There's also information in the docs about [how to handle pagination with tags](https://redux-toolkit.js.org/rtk-query/usage/pagination#automated-re-fetching-of-paginated-queries).


Invalidate RTK Query Cache Entries Automatically using providesTags and invalidateTags


This lesson demonstrates how to use the [keepUnusedDataFor](https://redux-toolkit.js.org/rtk-query/api/createApi#keepunuseddatafor) of APIs and queries to modify the default timeout of cached items when they're not being used. "Used" here refers to components subscribing to them via query hooks. If you're actively relying on the data on the page you're in, RTK Query won't just go and pull data fresh, but if you move away for long enough and then come back, it will make sure your data is up-to-date.

This is actually a brilliant feature, but the specific number for how long the timeout should be is going to depend on the usage patterns of your users and how frequently the data changes on the server. If your data changes infrequently there may not be any reason to have this enabled at all, you could set it to `3600s` (1 hr) for example.


Invalidate the RTK Query Cache using keepUnusedDataFor


This lesson is about a powerful combo, refetch and unwrap.

The first and simplest concept is [refetch](https://redux-toolkit.js.org/rtk-query/usage/queries#frequently-used-query-hook-return-values), which forces whatever query you're subscribed to, to pull the latest data from the server. Refetch takes no arguments and doesn't let you change the query in any way. It just forces it to be called again. Another way to manually call refetch is to use `initiate` on your query's endpoint. For example, `api.endpoints.getDogs.initiate(undefined, { forceRefetch: true })` would do the same thing as our `refetch` call here, but `refetch` is a lot cleaner.

The second part is around [unwrap](https://redux-toolkit.js.org/api/createAsyncThunk#unwrapping-result-actions), which lets you access the original promise result from a mutation, which you can then use to immediately trigger some action, such as refresh. Or, you can use it to display an error message when the mutation fails.

Manually Refetch Data After an RTK Query Mutation with unwrap() and refetch()


Here we use `builder.mutation()` to define a mutation in our API. What is a mutation? Well it's basically a POST request or anything that would modify something on the server. You'll notice `builder.mutation()` and `builder.query()` look very similar except here we are passing the URL in an options object and that's only because we want to pass `method` and `body` as well. The query here could potentially also be a string just like in `builder.query`.

You probably noticed that we removed the refetch that was happening with `dispatch(getDogs())`. That will be replaced in the next lesson with the `refetch` method.

More information about the options you can pass into `builder.mutation` can be found here:
https://redux-toolkit.js.org/rtk-query/usage/mutations


Migrate a Thunk in a Redux Application to an RTK Query Mutation


This lesson covers two important principles. The first is memoized selectors with [createSelector](https://redux-toolkit.js.org/api/createSelector) and RTK Query's built-in [endpoint selectors](https://redux-toolkit.js.org/rtk-query/api/created-api/endpoints#select).

RTK Query doesn't give you an easy way to access its cache manually but it does give you these enpoint selector helpers that allow you to reach into the cache when you need it.

Using these memoized endpoint selectors are recommended because they only calculate a new value any time the data arguments change while the previous selectors we had would be re-run on every re-render.

While not mentioned in the lesson you don't need to use endpoint selectors with createSelector. This would work perfectly fine:

```js
export const getServicesForLuckyDog = (state) => {
  const { data: dogs } = api.endpoints.getDogs.select()(state);
  const { data: services } = api.endpoints.getServices.select()(state);

  // if you don't have a lucky dog, show all of the services
  const dog = dogs?.[state.dogs.luckyDog];
  if (!dog) {
    return services;
  }
  // ...
};
```


Access the RTK Query Cache in a Memoized Selector Using an Endpoint's select() Method

We're currently modifying the data we get from RTK Query at the component level with `useMemo`. This works great when you have a single component that needs to have access to the data in a unique way. However, when you need to access that modified data in multiple components, it's better to use `transformResponse`.

Using [transformResponse](https://redux-toolkit.js.org/rtk-query/usage/customizing-queries#customizing-query-responses-with-transformresponse) moves the data transformation into your cache, so any component subscribed to a given query will receive data in the updated format.


Transforming RTK Query Data before Caching with transformResponse


In this lesson we rely on `useMemo` to to give additional properties to data returned from our query hook. This is **not the recommended approach** to modifying a server response. That would be the `transformResponse` property shown in the next lesson, but I wanted to demonstrate how easy it was to combine typical react features like `useMemo` with RTK Query results. This approach can work well if you need to modify data in a single component and no where else. It can also be combined with a custom hook that encapsulates both the query and the `useMemo` call to be made more reusable. In the sample code I've provided an example of what that hook might look like.

Transform Cached RTK Query Data before Rendering with useMemo

This our longest lesson. It covers territory that we've already covered, but in a more advanced way. Here are some of the main points.

1. When you migrate redux state into RTK Query, by mindful that you may have had initial state, which should usually be replaced with an `isLoading` check
2. Like everywhere else we rely on [destructuring asignment](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#object_destructuring) to give meaningful names to the generic `data` property returned from our query hook.
3. We're also using [optional chaining](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining) to deal with  `data` before we receive a server response
4. We're continuing to update our `getServicesForLuckyDog` selector here and pass in additional data, this time for our dogs


Migrate a Redux Thunk to RTK Query

In this lesson we learn about the `isSuccess` state that accompanies a successful mutation. We also use the `isLoading` state from a mutation hook to prevent a user from filling out a form multiple times.

Initially, we display a sent message powered with `useState` and a `setTimeout` that gets removed after 2s. In this lesson we display the message after our query's `isSuccess` value returns `true`. We also rely on the combination of `isLoading || isSuccess` to prevent additional form submissions.

- Our form submission relies on the [FormData](https://developer.mozilla.org/en-US/docs/Web/API/FormData) web API
- Read [Frequently Used Mutation Hook Return Values](https://redux-toolkit.js.org/rtk-query/usage/mutations#frequently-used-mutation-hook-return-values)


Handle Form Submission States with RTK Query's isLoading and isSuccess Values

Here we use `builder.mutation()` to define a mutation in our API. What is a mutation? Well it's basically a POST request or anything that would modify something on the server. You'll notice `builder.mutation()` and `builder.query()` look very similar except here we are passing the URL in an options object and that's only because we want to pass `method` and `body` as well. The query here could potentially also be a string just like in `builder.query`.

The most interesting thing about mutations is optimistic updates which we'll cover in a later lesson about `onQueryStarted`.

More information about the options you can pass into `builder.mutation` can be found here:
https://redux-toolkit.js.org/rtk-query/usage/mutations

Migrate a POST Request in a Redux App to an RTK Query Mutation

Both queries and mutations in RTK Query return `isLoading` and `error` values from the hook you call in your component. There are also about [8 other values](https://redux-toolkit.js.org/rtk-query/usage/queries#frequently-used-query-hook-return-values) you have access to in your component.

While `isLoading` is pretty obvious it's important to understand how the `error` value is put together. They contain the `status` and `data` properties, where `data` is whatever is returned from the server. Also unlike `fetch`, RTK Query will respond with an error on non-200 responses. However, RTK Query won't ever throw unless you call `.unwrap()` on a failed request.

See https://redux-toolkit.js.org/rtk-query/usage/error-handling#overview for more info.

Handle Loading and Error States in RTK Query with isLoading and Error Values

If you have a hook for a query such `useGetDogQuery()` what you pass in that hook will be accessible in your builder.query's `query` option.

So if I said `const {data} = useGetDogQuery(id)` I could access that value here `builder.query({ query: (id) => "dog/" + id })`. But it doesn't just have to be a string, this would also be valid. `useGetDogQuery({ id })` and `builder.query({ query: (options) => "dog/" + options.id })`, for example.

You can read more about defining queries here:
https://redux-toolkit.js.org/rtk-query/usage/queries

Migrate a GET Request with a Dynamic URL to RTK Query with builder.query()

Passing data into selectors is a really easy way to handle the migration from plain redux to RTK Query. Even though the data does exist in redux, it's not exactly obvious how to bring it out in a selector. 

If you do want to avoid passing in the data to your selector, you can also do this to get that value.
`api.endpoints.getServices.select()(state)`

In a later lesson I'll show you how to use this approach with a memoized selector, which will usually be slightly more performant.

There are some advanced docs about selectors here:
https://redux.js.org/tutorials/essentials/part-8-rtk-query-advanced#selecting-values-from-results

Pass RTK Query Data into Redux Selectors

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.

In React 19, managing script tags efficiently within components can lead to performance enhancements and simpler code structures.

Originally, using script tags directly in a React component involved complex setups, like using `useEffect` to dynamically add JavaScript code. For instance, a component might dynamically inject script tags to load external widgets. This approach, while functional, resulted in multiple script tags and duplicate iframe elements. This duplication not only cluttered the output but also negatively impacted performance by loading scripts multiple times.

The workaround for this would be to manually hoist any common scripts and maybe load them when they weren't needed by any components.

With React 19 we now have a more effective method. This involves directly placing the script tag within the React component's return statement. This approach ensures that React handles the script loading, avoiding the duplication of script tags.

By implementing the script tags this way, the loading initiator becomes React DOM, which efficiently manages script loading and deduplication. This setup prevents multiple requests for the same script when the component is rendered multiple times, enhancing the overall application performance.

Furthermore, directly embedding the script tag simplifies the code, making the component cleaner and more maintainable.

Efficiently Render Script Tags in React 19 Components

Learn how to efficiently render script tags in React 19 components to improve performance by avoiding duplicate script loads and simplifying your code.

Let's learn how to dynamically manage title tags in React 19 applications. Rendering `<title>` dynamically is simple enough, however, a challenge arises when multiple title tags are present in the document, which can lead to issues with screen readers and search engine optimization (SEO). The solution presented involves ensuring that only one title tag is rendered at a time by using conditional rendering.

Also we need to make sure to have a single string within the title tag using a template literal, ensuring our HTML remains valid and optimized.


Deduplicate Title tags with React 19

Learn to manage multiple title tags in React 19 dynamically. Ensure accessibility and SEO by preventing duplicate title tags with clear examples.

In React 19, we can easily add a title tag like "Starship Deets" which then appears in the head section of the HTML even when we render it inside our components. This method also applies to meta tags such as character set and viewport settings, which are also lifted to the head section automatically.

This is an awesome feature because it maintains the same composition style we are familiar with in React components. It simplifies the handling of HTML head elements without needing extra setups like `useEffect` for accessing the head section. Even in situations where our components are rendering within a body element, like within a div, we can manage our head content directly within our components. React takes care of hoisting these elements where they need to go.


Hoist Title and Meta tags in React 19

Hoisting title and meta tags directly in React 19 components allows for simpler composition, similar to other React elements. Manage meta and title tags.

<PodcastLinks />

Dax Raad, known for his strong opinions on Twitter, sat down for a chat about web dev, career moves, and building cool stuff. He's not afraid to throw some heat at popular tools like [Next.js](https://nextjs.org/), though he still helps people use it. Dax is particularly excited about local-first development, which he thinks isn't getting enough attention. He argues that sometimes the best web dev move is to step away from web dev entirely and explore other areas of programming.

When it comes to career growth, Dax encourages developers to think beyond the "web dev" label and see themselves as programmers capable of tackling any challenge. He advocates for trying out weird stuff and learning unusual languages, as these experiences can lead to unexpected opportunities. Taking smart risks in your career can open doors to awesome possibilities.

In the business world, Dax is a fan of making "asymmetric bets" - moves with low downside but huge potential upside. He applies this philosophy to his work on [SST](https://sst.dev/), reasoning that even if it fails, he'll walk away with valuable experience. He also emphasizes the importance of resisting quick payouts in favor of potentially bigger wins down the road.

Looking to the future of tech, Dax is betting on local-first development. He sees potential in getting in early on emerging technologies like [Solid.js](https://www.solidjs.com/). Building in public and making connections in new tech communities can pay off in unexpected ways.

Dax also challenges the notion of constant hyper-productivity in tech. He suggests balancing focused work with time for exploration and learning. Sometimes, he points out, what seems like a "dumb" choice (like learning a niche language) can turn out to be a smart career move in the long run.

## Good Stuff Mentioned

- [Next.js](https://nextjs.org/)
- [Vercel](https://vercel.com/)
- [SST](https://sst.dev/)
- [Elixir](https://elixir-lang.org/)
- [Solid.js](https://www.solidjs.com/)
- [RepliCache](https://replicache.dev/)
- [Linear](https://linear.app/)
- [Remix](https://remix.run/)
- [Shopify](https://www.shopify.com/)
- [React](https://react.dev/)

Developer Career Growth and Asymmetric Bets with Dax Raad

<PodcastLinks />

Dev and Joel discuss React Miami conference, praising its fun atmosphere and location. They chat about React Server Components, with Dev sharing his experience building a mini framework. They talk about Vinxi, Nitro, and the unjs ecosystem as tools for creating custom frameworks. The conversation touches on Vue's popularity outside web dev circles and non-web dev conferences. They discuss the benefits of TypeScript and strongly-typed APIs. Dev mentions his upcoming talk on durable objects at [a conference in Dallas](https://x.com/DThompsonDev/status/1829674506237194456). They end by discussing WebSockets, PartyKit, and platform-specific frameworks.

## What's Good?

- [React Miami Conference](https://www.reactmiami.com/) 
- [Brenley Dueck's blog post on Simple RSC with Vinxi:](https://www.brenelz.com/posts/simple-rsc-with-vinxi/)
- [Vinxi](https://github.com/nksaraf/vinxi)
- [Nitro](https://nitro.unjs.io/guide/configuration)
- [unjs ecosystem](https://unjs.io/)
- [Solid Start](https://start.solidjs.com/)
- [TanStack Router](https://tanstack.com/router/latest) 
- [PartyKit](https://github.com/partykit/partykit) 
- [Durable Objects (Cloudflare)](https://developers.cloudflare.com/durable-objects/)
- [Flightcontrol](https://www.flightcontrol.dev/) 
- [SST](https://sst.dev/)
- [OpenNext](https://open-next.js.org/)

Nitro, Vinxi, and RSCs - What's Good with Dev Agrawal

**Note:** This course is being actively developed and more lessons will be added in the future.

Cursor is an AI-enhnaced code editor that allows you to call upon the robots to refactor or stub out functions for you with natural language. 

In this course, John will show you workflows that will save you time and effort by utilizing the features such as its mult-line editing and context.

In particular, by giving Cursor's AI the proper context, whether that's lines of code or multiple files, you'll get better output when trying to extend or refactor logic that's present.


Bite-size video tutorials for badass web developers.

Search

Search Results