Learn Ethereum, Git and Npm

Next.js is a minimalistic framework for server-rendered React applications.

This project is a Next.js example of Kent C Dodd's Frontend Masters Advanced Remix Workshop project.

The aim of this project and course is to take a large project using the traditional Next.js pages architecture and migrate the full project to use the new app directory architecture.

We will fork project repo and clone it to get setup with the project locally. 

Fork and Clone the Next.js 13 Project to Get Started

Ethereum is a decentralized, open-source blockchain with smart contract functionality. 

ethereum

Welcome to Noah's course on Introduction to Smart Contracts with Ethereum and Solidity. 

Introduction to Introduction to Smart Contracts with Ethereum and Solidity

Web3 is a paradigm shift in how applications are interacted with, ran, and built. 

It’s not just a Pump-and-Dump scheme on cryptocurrencies or Bored Ape NFT profile pictures you can put on Twitter.

A fundamental tenet of Web3 is bringing ownership back to the user. You no longer have to trust that your data is being properly handled on someone else’s server (although, currently Web3 ecosystem mainly depends on centralized infrastructure such as GitHub).  

This ownership is achieved through blockchain, cryptocurrencies, NFTs, and smart contracts.

A great example of this type of ownership is through how you exchange money in Web3. There is no intermediary like Stripe, or PayPal to process your transactions. You can even build your own smart contracts that receive crypto (e.g. Ethereum or ‘eth’ for short) and then process that eth how you’d like.

Building this type of smart contract is exactly what Matías is going to show you how to do right now.

Matías builds out a Web3 application that allows you to receive tips in the form of eth in a tip jar on your website. This means your application will be backed by a smart contract that’s accepts eth, stores data, and emits Solidity events.

The frontend application uses SvelteKit which you’ll see how easy it is to get up and be productive with in minutes. A huge benefit here is that the JavaScript you write is just that, JavaScript. You’ll be able to take what you learn and implement it into any framework of your choosing.

While you build this application you will learn how to:

- Write a smart contract using Solidity language
- Test the smart contract using just JavaScript through the waffle framework
- Communicate and interact with the smart contract using ethers.js in a SvelteKit application
- Deploy your smart contract to make it public and accessible to anyone

Solidity is an object-oriented, high-level language for implementing smart contracts.

solidity

Full Stack Web3 and Blockchain Development on Ethereum with SvelteKit

There are several Ethereum test networks like Ropsten, Rinkeby and Kovan that you can use to deploy your contract to have it publicly available without having to use the mainnet and real ETH.
In this course you'll deploy to Rinkeby netwok (but, the process is the same for the other networks).

The first step will be update your Metamask Wallet to connect to the Rinkeby network.

Next, you'll need some test/fake Ethere to use for testing the Dapp in the network, for that you'll need to use a [faucet like this one](https://www.rinkebyfaucet.com/). Just visit that faucet and add your wallet address.

You will also deploy your web application to vercel to see your project live on the internet!

Deploy your Smart Contract to Goerli Test Network and App to Vercel

The magical disappearing UI framework

 - The web's JavaScript bloat crisis, solved. Svelte turns your templates into tiny, framework-less vanilla JavaScript.
 - Simple and familiar. Build apps out of composable, easy-to-write blocks using languages you already know.
 - Super fast, rock solid. Compile-time static analysis ensures the browser does no more work than it needs to.

svelte

Now that we have an application that is accepting tips to the smart contract that was defined, we need to be able to withdraw the funds that are sent to the contract. The smart contract function for this is already defined so we will just need to call the function from the front end.

To do this we will create a new route to display the contract information. We will then check if the current user is the contract owner and if so allow that user to withdraw the contract funds by clicking a button that we wire up to call the withdraw function from the smart contract.

## Important

SvelteKit is still in beta. Expect bugs! Read more here, and track progress towards 1.0 here. 

This lesson was recorded before the latest breaking changes, the content is still valid but it sometimes references a file that does not exists anymore.

Now: 
`src/routes/index.svelte` is called `src/routes/+page.svelte`

`src/routes/__layout.svelte` is called `src/routes/+layout.svelte`


Everything else is 100% valid. This particular content will be updated when Sveltekit reaches 1.0.0 stable.

Withdraw eth from a Smart Contract in a Svelte Application

It is time to interact with the contract, let's send some eth!

For this you'll need a form that is rendered only when the wallet is connected.
This form use the `sendTip` function and gather some required information. On submit, it will read the `sendingTip` loading state variable and disable or enable the button.

## Important

SvelteKit is still in beta. Expect bugs! Read more here, and track progress towards 1.0 here. 

This lesson was recorded before the latest breaking changes, the content is still valid but it sometimes references a file that does not exists anymore.

Now: 
`src/routes/index.svelte` is called `src/routes/+page.svelte`

`src/routes/__layout.svelte` is called `src/routes/+layout.svelte`


Everything else is 100% valid. This particular content will be updated when Sveltekit reaches 1.0.0 stable.

Create a Form in Svelte and Send a Tip to an Solidity Smart Contract

Now is time to setup the client to talk with the contract, for that you will need to store and access the contract ABI (this is a file generated by the contract compilation) as well as use ethers to set up a connection to the contract. 

Once set up is complete, we will listen to any tip events that come in from the contract and display tip information in the application.

## Important

SvelteKit is still in beta. Expect bugs! Read more here, and track progress towards 1.0 here. 

This lesson was recorded before the latest breaking changes, the content is still valid but it sometimes references a file that does not exists anymore.

Now: 
`src/routes/index.svelte` is called `src/routes/+page.svelte`

`src/routes/__layout.svelte` is called `src/routes/+layout.svelte`


Everything else is 100% valid. This particular content will be updated when Sveltekit reaches 1.0.0 stable.

Interact with a Solidity Smart Contract Using Ethers and the Contract ABI in SvetleKit

Now the UI is capable to connect to the Ethereum network by using the wallet, but we need two more things to continue.

1. Avoid re-connecting every time the browser is refreshed
2. Get more information about the user and the network.

For the first, let's run a little function every time the component is mounted.

Then, let's read and display some more information:

- The user balance
- The network that the user is currently connected

## Important

SvelteKit is still in beta. Expect bugs! Read more here, and track progress towards 1.0 here. 

This lesson was recorded before the latest breaking changes, the content is still valid but it sometimes references a file that does not exists anymore.

Now: 
`src/routes/index.svelte` is called `src/routes/+page.svelte`

`src/routes/__layout.svelte` is called `src/routes/+layout.svelte`


Everything else is 100% valid. This particular content will be updated when Sveltekit reaches 1.0.0 stable.


Retrieve Ethereum Network and Account information on Mount and Display it in Svelte

The first step in this part of the journey, will be to setup a simple UI that allow you to connect the current user to the blockchain through it's wallet.

To do this, let's write some code.

Sveltekit applications works by using a file system routing method, meaning that you need to create files under the `src/routes/` folder and those will be then reflected as routes (urls) in your app. Let's keep ti simple and just use the default route here, open `src/routes/index.svelte` and delete the content of it.

You're first step will be create a button that allow the user to "sing-in" to your new dapp and allow the UI to react to that showing a different content if the authorization process was successful.


Connect a Metamask Account to a Svelte Application

Before jumping into the Dapp code you need to setup an Ethereum wallet.
There are bunch of wallet applications and types outher, but for this project we're going to use Metamask.

### What is an ethereum Wallet

A wallet is an application that let's you interact with your Ethereum account. You're wallet is the one that works as a gate between the Dapp and your data, through it the applications can read your balance, send transactions, etc.

You can swap wallet providers at any time or manage multiple accounts in one application. This is because the wallet are non-custodial, meaning that they don't hold your assets, you do.

Just to set some concepts down:

- An Ethereum account is an "entity" that can send transactions and store some assets, it "lives" inside the blockchain.
- The accout have an address (like your profile URL of some social app or your email address) that can be used to send or receive funds.
- A wallt is an application that allow you to interact with the Ethereum account.

There are different types of Wallets:

- Hardware wallets that hold your crypto assets offline - The most secure of all
- Mobile apps, like Argent.
- Web wallets, that let you interact through the browser: Like Metamask.
- Desktp apps

Set up a Metamask Wallet with your local Ethereum Network

Now you need a way to keep a local network alive, deploy the smart contract there and then interact with it. You can think on this like a local web server. When you develop an API you have a local server running it so the client application can talk to it so you can develop and test, this is the same idea.

Head over to your terminal and run tthe following command.

```bash
$ npm run hardhat node
```

This will ramp up a local ethreum network using hardhat and will show in the console a set of accounts and private keys that can be used for testing pruposes.

These are 20 test accounts and addresses created for your. Each account is also rich! are loaded with 10000 ETH. (fake eth btw).

Right now this is just an empty blockchain. There are no blocks nor smart contracts on it. But you want to create a new block and put the smart contract that you just created there, for that you need to create a little script that will use ethers.js power to compile and deploy.

Deploy a Solidity Smart Contract with Hardhat to a Local Ethereum Network

To reduce the amount of gas used, we will create a withdraw function that lets the owner of the contract withdraw funds that have been added when they want rather than withdraw with every transaction.

Your smart contract is ready to be used, since you have confidence in the code after testing it.

But there are a few things that you can add to improve the behavior and security of it.

Let's start by adding events.

Similar to any other programming language Events in solidity are a way to inform the calling application about the current state of the contract. Like notifying the javascript client about a change made to the contract allowing the client application to react to it.

Events are defined within the contract as a global and are called from inside a function. To declare an event you use the `event` keyword, followed by an identifier and the parameter list. The values passed to the parameters are then used to log the information that is saved as part of the transaction inside the block.

To send the event you'll use the `emit` keyword from anywhere inside the contract by passing the name of the event and the corresponding parameters.

For this contract you want to let the client application to know when a tip was successfully sent. To do that you'll create a new event named `NewTip` like this

```javascript
event NewTip(address indexed from, string message, string name, uint256 amount);
```

It will accept an address to identify who sent the tip, the message of the tip and also the name and the amount of eth sent,

And then, it will be emitted from the `sendTip` function

```javascript
// send the event
emit NewTip(msg.sender, _message, _name, msg.value);
```

This event will use the same parameters that the rest of the `sendTip` operation.

- `msg.sender` to get the address of who sent the tip
- `_message` the string with the message sent
- `_name` the name of the sender
- `msg.value` the amount of `eth` sent.

Add eth Withdraw Functionality in a Smart Contract and Emit Solidity Events

Tests are important, as always but it may be more important when you are developing an smart contract. Why?
Because the blockchain is immutable.

The main difference between Solidity development and other languages or environment is that after the implementation of an smart contract in the Ethereum network the contract is immutable, meaning that it will never be modified or updated again.

The first code that get's deployed is the one that will remains unchanged for the rest of time. This is because one the main concerns of Solidity is security. If there's a flaw in your contract code, there is no way to patch it later. You would have to tell to the users of the contract to use a different contract (identified by an `address`) to get the fix.

Sounds uncomfortable right? But, believe it or not, this is a **feature**. The code that your wrote it becomes a **law**. IF you read the code of an smart contract (and verified that that code is actually the one deployed) you can be sure that every time you call a function it will behave exactly as the code says it.

So you need to be sure before deploy and the best way to get that confidence is by testing.

[Hardhat](https://hardhat.org/) (the development environment of choice for this course) offers the tools to test the smart contract using Javascript or Typescript by leveraging the power of [Ethers.js](https://docs.ethers.io/) to interact with the Ethereum network and [Waffle](https://getwaffle.io/), a testing library built on top of Ethere.js

You already dip your toes on a bit of testing code, now let's add a more robust test to check that the contract behaves as expected.



Test Smart Contract Functionality with Ethers and Hardhat

It's time to add functionality to our smart contract. In this lesson we will define a function `sendTip` that accepts a `_message` and `_name`. We will check the senders balance and if it's higher than the tip amount transer the eth specified. We will also increment our `totalTips` contract variable and  add the tip to our Tips array.

While adding this function you'll learn how to handle errors within Solidity functions

Create a Smart Contract Function that Transfers eth from One Address to Another

Now, we have the base contract to work on. The goal of the contract is to act as a tip jar, a way to allow users or followers to send you some ETH through the web, including some message. But also, to showcase the people that sent you that money by making the actions public in the web too. This means that the contract need to:

1. Identify to who to send the tip
2. Store the tip sender data including the message, and the amount of eth.
3. Allow a way to retrieve the actions (the tips sent) made through it.

We will add an `address payable` variable of owner to tell the contract that the contract will receive payments. 

For the actual tip data, we will define a Tip `struct` that will have all the information needed to send a tip.

Store Data in a Smart Contract struct Variable

The first step in this journey will be get your hands into a new language to harness the power of the blockchain. I'm talking about Solidity

**This isn't a Solidity focused course but we will review some concepts to get you up to speed with it.

The first thing to notice is that Solidity is an statically-typed language created specifically to create smart contracts for the Ethereum network.

An smart contract is like "real life" contract. Is a way to establish terms for an agreement. But the "smart" part it's because this type of contract is declared as machine code that is executed in a blockchain. This expand the idea of the original blockchain, Bitcon, aout sending and receiveing money without a centralized intermiediary to create trust and make possible to automate and dcentralize virtually any kinf of deal or transaction.

Since the contracts run in the blockchain (like Ethereum network) they offer high security, trust, inmmutability and reliability.

Since the blockchain is immutable you have to be care on what are you deploying. After deployed it cannot be change and you'll need to deploy a new contract.

For Solidity, a contract is a collection of code (a program) and data (the state) that lives inside the blockchain, it can be identify by its Ethereum address. You can leverage your previous knowledge and use some analogies to understand the smart contract.

You can think on the contract as your "backend" or "server side" program. This server expose an API and store some data (the state) into the a databse (the blockchain), but the database is not written nor query with a different language like SQL, you can imagine that Solidity is automatically connected to the database and everything you deeclare (like a variable) is stored in the database.

Create and Test a Solidity Smart Contract with a Public Variable

We'll start our project by installing all of the necessary tools to get started with Web3 development. 

This project will use SvelteKit Tailwind CSS for it's UI. We have some handy initializers that we will run to do the configuration for us. 

On the Web3 side of things we will use Hardhat, Ethers.js, and hardhat-waffle for smart contract development.

Set up an Ethereum Project using SvelteKit with Tailwind CSS and Hardhat

We will start up a local blockchain that behaves like Ethereum, allowing us to test and prototype our smart contracts' behavior rapidly. It provides useful features out of the box, such as logging so we can follow the executions as they happen and pre-funded accounts with their corresponding private keys.

**Please Be Warry!** Never use or send money to the addresses on mainnet Ethereum. These keys are the same every single time. There are sure to be bots waiting to drain these wallets when funds get sent to them.

Start a Local Blockchain With Anvil

A Monorepo is where you have multiple projects inside a singular repository.

monorepo

Introduction to Monorepos with NPM Workspaces

npm is the package manager for JavaScript. Find, share, and reuse packages of code from hundreds of thousands of developers — and assemble them in powerful new ways.

Thank you for completing my course!

You’ve learned what monorepos are, how to create them from scratch, how to install different projects inside of it, and how to run different scripts inside of a monorepo. 

So where do you go from here? I suggest creating your own Monorepo project template and publish it on Github. Take a look at Yarn Workspaces, pnpm, Learna, Nx and Turborepo for different monorepo tools. 

I also highly suggest Migrating some of your existing projects to a monorepo. Have a main frontend application that consumes a shared UI library package and a backend service. Another way would be to have a backend service, a mobile application and a frontend application. 

Best of luck and happy coding!

Intro to Monorepos with NPM Workspaces Outro

All of our applications and libraries have `test` and `typecheck` commands already written inside of them. We are able to run both the `test` and `typecheck` commands all at the same time as well. 

This has a downside. They don’t run at the same time, it’s just one after the other. To make them run at the same time, we will implement `concurrently` again.

Running Quality Checks in your Monorepo

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