Frontend First artwork

Frontend First

183 episodes - English - Latest episode: 6 days ago - ★★★★★ - 18 ratings

A podcast about modern UI development on the web. Hosted by Sam Selikoff and Ryan Toronto.

Technology technology web javascript ember ember.js software development design
Homepage Apple Podcasts Google Podcasts Overcast Castro Pocket Casts RSS feed

Episodes

The Philosophy of Next.js

March 22, 2024 18:50 - 1 hour - 69.6 MB

Sam and Ryan discuss the core values of the Next.js framework, and how those values motivate several of the framework’s design decisions. They talk about caching, why layouts don’t have access to the URL, and why the router doesn’t expose navigation events, as well as how developers should think about extending Next’s functionality with their own application code. Topics include: 0:00 - Intro 2:58 - Why don’t layouts re-render in Next.js? 7:10 - Push-based vs. pull-based rendering 8:56 ...

Beyond Data Fetching with RSCs

March 13, 2024 21:07 - 1 hour - 63.9 MB

Sam talks to Ryan about refactoring an MDX blog post to a React Server Component. They discuss how RSC’s ability to render server-side content with “client-side holes” turns out to replace MDX for many uses cases. They also talk about other tools that are (surprisingly) a conceptual subset of the RSC architecture, such as custom Webpack loaders. Topics include: 0:00 - Intro 5:05 - The Next.js happy path for MDX: Local files 11:15 - Exploring remote MDX content with mdx-remote 14:46 - Se...

Blog Post Club: React Labs – What We’ve Been Working On

March 01, 2024 19:16 - 1 hour - 76.1 MB

Sam and Ryan read and discuss the latest update from React Labs. Topics include: 0:00 - Intro 5:26 - Opening 6:18 - React Compiler 27:27 - Actions 51:44 - Asset loading 1:13:06 - Next Major Version of React 1:15:42 - Activity Links: React Labs blog post Sam’s video on Strict Mode

Instant URL search params in Next.js

February 21, 2024 15:09 - 45 minutes - 41.7 MB

Sam and Ryan discuss the intuition behind React Transitions, and why React’s new useOptimistic hook is a good fit for building a URL-driven filter panel that stays fully responsive to client interactions. Topics include: 0:00 - Intro 1:12 - The problem: In a world of Server Components, URL updates are blocked by a server-side roundtrip 10:44 - Attempted solution: Use the browser’s Native History API (history.pushState) 15:03 - Realization: The source of truth flips from server to client...

React Deep Dive: useOptimistic

February 14, 2024 18:37 - 51 minutes - 46.8 MB

Ryan and Sam discuss the purpose and usage of the useOptimistic() hook, a new experimental API from React. Topics include: 0:00 - Intro 2:18 - Problem: RSCs require a server roundtrip before the UI can be updated 10:13 - Solution: useOptimistic() lets you merge ephemeral client-side state with server-side data so you can update the UI during a Server Action or Transition 14:03 - How useOptimistic() avoids the notion of identity by discarding the ephemeral state after the app settles 21...

React Deep Dive: cache

February 07, 2024 15:30 - 1 hour - 61.8 MB

Ryan and Sam discuss the purpose and usage of the cache() function, a new experimental API from React. Topics include: 0:00 - Intro 2:29 - Caching in Next.js vs. React cache() 8:11 - Why React invalidates the cache for each server request 14:43 - How cache() enables colocation of data-fetching code 16:14 - Using cache() to share CPU-heavy or I/O-bound tasks between components 19:31 - Why cache() obviates the need for context in Server Components 23:19 - The danger of module scope on ...

Advanced Radix UI | Blog Post Club: React Server

February 01, 2024 18:32 - 55 minutes - 51 MB

Sam and Ryan talk about Advanced Radix UI, Build UI’s newest course. They also read and discuss a blog post that describes the RSC architecture in terms of two processes: React Server and React Client. Topics include: 0:00 - Intro 0:49 - Ceilingless libraries + Advanced Radix UI 21:02 - Read and discuss: “RSC is React Server + Component” Links: Advanced Radix UI course Radix UI RSC is React Server + Component

The SQL Injection Slide

November 06, 2023 15:51 - 1 hour - 80.3 MB

Ian Landsman & Aaron Francis join Sam to discuss React Server Actions & Server Components, why it's important to have one set of opinions, and yes, the infamous SQL Injection Slide at NextConf. This is a crossover episode with the excellent podcast Mostly Technical. Topics include: 0:00 - The Most Memed Man on the Internet 09:06 - High Floor vs. High Ceiling 19:20 - What the Hell Is Next? 23:22 - The Third Phase of React 29:09 - Your App Is Not Unique 35:23 - Server Actions & Server ...

The Remix Architecture

October 14, 2023 18:06 - 46 minutes - 42.6 MB

Sam and Ryan talk about the key parts of Remix’s architecture in the context of the Work Journal app from Build UI’s latest course. They discuss how Remix’s conventions around Links, Forms, Actions, and Loaders allow developers to eliminate boilerplate and take advantage of the best HTTP has to offer, while still providing a seamless way to enhance their UIs using the full power of client-side React. Topics include: 0:00 - Intro 0:31 - The Work Journal app 2:20 - Making dynamic pages wit...

Implementing RSC, Part 2: Server Actions

October 04, 2023 18:18 - 57 minutes - 52.3 MB

Ryan continues to share the details behind his custom RSC implementation. He talks with Sam about how Server Actions allow the client to reference server-side code (in the same way client components allow the server to reference client-side code), how Server Actions are bundled and invoked, and the security concerns associated with blurring the lines between the server and the client. Topics include: 0:00 - Intro 0:52 - Ryan’s course on React Server Components 3:06 - Motivating Server Ac...

Implementing RSC, Part 1: Rendering

September 29, 2023 14:03 - 58 minutes - 53.8 MB

Ryan shares how building his own RSC implementation from scratch helped him better understand React’s new paradigm. He and Sam talk about how a client React app can fetch an RSC Payload from a server endpoint to update the UI, how an RSC server renders and bundles Client code that’s part of a Server Component tree, and how a client-side Router can be used to fetch new RSC trees based on the URL. Topics include: 0:00 - Intro 2:48 - Making a server endpoint that a client React app can use t...

Should a navigation and a refresh show the same page?

September 20, 2023 17:06 - 45 minutes - 41.3 MB

Ryan and Sam talk about how to invalidate Next.js’ client-side cache when a different session makes changes to backend data, and ultimately discuss whether clicking a link to a URL vs. hitting refresh on that same URL should render the same page if no backend data has changed. Topics include: 0:00 - Intro 1:00 - Suspense boundary identity and the Await component 11:07 - How to refresh RSC using a Server Action 27:17 - The difference between a navigation and a page refresh Links: Ryan’...

Tim Neutkens on the Next.js App Router

August 16, 2023 18:35 - 1 hour - 96.2 MB

Tim joins Sam to talk about his work on the new app router in Next.js 13. He explains how the app router leverages Server Components and React’s new cache API to bring a new level of composability to server-side code, how Server Actions are being designed to enable partial revalidation in a single round trip to the server, and how to think about UI updates as a result of server-side state changes. Topics include: 0:00 - Intro 2:53 - Rendering Server Components and the RSC payload 21:49 -...

Understanding prop passing from RSC to Client Components

August 09, 2023 14:34 - 48 minutes - 44.1 MB

Sam and Ryan discuss how TypeScript helped them understand the mechanics of how props get passed from Server Components to Client Components, and how to properly type client component props if the prop starts out as a rich data type on the server. They also clarify some points from last episode’s discussion about the RSC payload. Topics include: 0:00 - Intro 0:40 - Clarifying what the RSC Payload actually is 10:12 - Understanding prop serialization when passing props from Server Componen...

Server-side rendering vs. Server Components

July 12, 2023 17:03 - 50 minutes - 46.2 MB

Sam and Ryan explore different ways to think about the RSC architecture, including what problems RSC solve, why RSC are valuable even in a world without server-side rendering, and how React’s reconciliation phase enables RSC to make partial updates to the UI as a result of server-side events. Topics include: 0:00 - Intro 5:45 - What if RSC were introduced before SSR? 10:54 - What does it mean to render RSC? 25:41 - Why SSR does not apply to Server Components 35:31 - Server-driven UI up...

Reusable pending UI for forms with Server Actions

July 05, 2023 13:20 - 42 minutes - 38.7 MB

Ryan shares his thoughts on how Server Actions and the useFormStatus hook are letting him build reusable pending UI for any form in his Next.js side project. Sam talks about how TypeScript prevents an entire class of data-loading bugs that have plagued single-page applications built with a client-side cache. Topics include: 0:00 - Tailwind Connect 2:38 - Using TypeScript to prevent data-loading errors 19:27 - Building reusable form UI with Server Actions and useFormStatus Links: Server...

How Suspense led to Server Components (React Roundtable reaction)

June 07, 2023 18:51 - 51 minutes - 46.7 MB

Sam and Ryan share their thoughts on the recent React Roundtable with core team members Sebastian Markbåge and Andrew Clark. They talk about the evolution of Server Components from the perspective of solving the problem of fetching data in React apps, how SPAs have a lower baseline but higher ceiling in terms of the user experience they can deliver, and what they’d like to see from frameworks that are built on the RSC architecture. Topics include: 0:00 - Intro 0:36 - Recap of Server Compo...

Learning by copy-paste

May 24, 2023 14:57 - 41 minutes - 37.5 MB

Sam and Ryan use some recent Twitter discussion on copying + pasting code (instead of abstracting it for reuse) as a springboard for a discussion about how their thinking on low-level UI components and design systems has changed over the years. Topics include: 0:00 - Intro 2:16 - Copy-paste vs. creating abstractions 11:43 - How we used to build shared UI components 15:34 - How we use UI components today 22:42 - Is copy-paste the easiest way for developers to implement consistent design...

What problems do React Server Components solve?

May 17, 2023 10:00 - 51 minutes - 46.8 MB

Sam and Ryan share their learnings from working with Server Components in earnest over the past week. They talk about how Server Components can simplify client components by passing them props, why it makes sense for a component that can run everywhere to be a Server Component by default, whether RSC is causing unnecessary churn in the ecosystem, and how to think about choosing Server Components vs. client components for a given task. Topics include: 0:00 - Intro 0:48 - Lessons learned fr...

Implicit time zones and the TZ environment variable

May 11, 2023 14:16 - 46 minutes - 42.4 MB

Sam shares some recent learnings around hydration mismatches when rendering time zoned dates on the server and the client. He talks about using the TZ environment variable to reproduce the issue locally, and how he solved his problem by avoiding impure format and transformation functions from date-fns. Topics include: 0:00 - Intro 0:50 - Sever vs. client time zone mismatches, and the TZ environment variable 14:34 - Which date-fns functions are impure? 23:56 - Using intervals and compari...

React email previews and radial gradients

May 03, 2023 14:00 - 42 minutes - 38.5 MB

Sam and Ryan talk about using MJML to design, build and send transactional emails with React directly in the browser. They also chat about how to use Framer Motion to get a CSS radial gradient to follow the mouse cursor and the differences between React state, refs, Motion Values, and external stores. Topics include: 0:00 - Intro 1:10 - Building in-browser email previews with MJML 18:50 - Using radial gradients and Motion Values to build a moving spotlight treatment Links: MJML React ...

Blending modes and secure redirects

April 26, 2023 10:00 - 37 minutes - 34.5 MB

Sam and Ryan talk about building an animated tabs component with CSS’s mix-blend-mode property and Framer Motion’s layout animations. They also talk about how to use the URL constructor in JavaScript to help implement secure arbitrary redirects, as well as their initial reactions to new framework APIs that blur the lines between server and client code. Topics include: 0:00 - Intro 0:35 - Animated tabs with mix-blend-mode exclusion and Framer Motion’s layoutId 14:26 - Using the URL constr...

React Aria Components

April 20, 2023 11:53 - 35 minutes - 32.3 MB

Sam tells Ryan about his experience building an animated toggle with React Aria Components. He gives his first impressions of the new library and discusses some of functionality included from the lower-level React Aria hooks. Ryan also talks about his recent use of GitHub Copilot. Topics include: 0:00 - Intro 1:15 - Using GitHub Copilot to keep you working at higher levels of abstraction 8:15 - react aria components toggle. pressed state. When to use browser defaults vs headless for form...

JavaScript needs a model layer

April 12, 2023 10:00 - 43 minutes - 39.4 MB

Sam and Ryan talk about updating Build UI to support lifetime memberships. They chat about the site’s current architecture, the strengths and weaknesses of objects vs. functions, how the full stack JavaScript community could benefit from a proper model layer like ActiveRecord, the challenges of using GraphQL on the backend, Prisma, and more. Topics include: 0:00 - Intro 1:09 - Current architecture + single purchase 6:30 - Rails model layer. OOP vs functional 13:55 - What are classes goo...

Server Components and the React paradigm

March 15, 2023 15:00 - 50 minutes - 46.5 MB

Ryan and Sam use some recent Twitter conversation to guide a discussion about the design and purpose of React Server Components. They talk about how client trees and rendered on the server today, why a server-side rendered prepass is wasteful in light of RSC, how hydration of a client tree works, why RSC are never hydrated, how RSC is a purely additive technology, how server and client components can be interleaved, how RSC can be refreshed in-place without loss of any client state, how RSC ...

HTML, HTTP, and React

March 08, 2023 08:00 - 1 hour - 56.1 MB

Sam and Ryan share their thoughts on the latest server-centric developments taking place among React frameworks like Remix and Next.js. They discuss the declarative nature of HTML and HTTP, the evolution of frontend development from imperative libraries like jQuery to declarative libraries like React, why developers started creating SPAs in the first place, the power and limitations of server-side links and forms, whether the frontend community has overcomplicated web development, the proble...

Caching strategies

March 01, 2023 14:04 - 1 hour - 63 MB

Sam and Ryan have an open-ended conversation about different caching APIs and what kinds of benefits they might afford app developers. They discuss transparent caching layers, cache keys and surrogate keys in systems like Fastly, how SSG is effectively a high-level caching solution, Next.js 13.2’s cache API, Russian doll caching in Rails, whether a fetch cache is too high-level of an abstraction, and other topics. They also have a retro on choosing to use Hygraph as Build UI’s CMS, discussi...

Saying goodbye to static generation

February 22, 2023 11:00 - 59 minutes - 54.8 MB

Sam and Ryan chat about their recent work migrating Build UI from a statically generated site to a run-time server-rendered app using Next.js. They talk about their past experience working on server-rendered apps, the problems that static sites were created to solve, and the tradeoffs involved within the static-to-dynamic continuum. Topics include: 0:00 - Intro 2:05 - How we built EmberMap with SSR + caching buckets with Redis 8:36 - How we launched Build UI as a static site with dynamic...

Building user search with React Server Components

February 15, 2023 21:12 - 1 hour - 59.7 MB

Ryan talks about a demo he built in Next.js 13 with React Server Components. He explains how RSC driven by the URL eliminated client-side states, how he used React 18 Transitions to enhance the UI, and how he was able to fine-tune the experience differently for the initial render vs. subsequent client-side navigations. Topics include: 0:00 - Intro 1:37 - Overview of Ryan’s user search page 14:06 - React 18 Transitions and how RSC eliminates client states 28:25 - How to change the UX for...

Ship Small, Ship Fast

February 08, 2023 11:00 - 30 minutes - 28.2 MB

Ryan and Sam read a recent article by Derrick Reimer called “Ship Small, Ship Fast” and offer their thoughts on it. They discuss how implementation details can lead to reductions in scope, the relationship between shipping small and agile, and why quickly getting the first steps of a user flow into production is a good protocol for software teams to follow. Topics include: 0:00 - Intro 2:06 - Ship Small, Ship Fast read-a-long 7:22 - Reactions Links: Ship Small, Ship Fast by Derrick Rei...

Lying in TypeScript

January 26, 2023 16:14 - 47 minutes - 43.9 MB

Sam and Ryan talk about seams in TypeScript programs where lies can sneak in. They chat about how API calls, form inputs, and URLs all relate to this problem, the similarity between drifting types and service mocks in testing, zod, and how type-safe languages like Elm eliminate this problem entirely. Topics include: 0:00 - Intro 2:41 - Lying in Typescript Links: Zod Elm language

Animating a Stable Diffusion side project

January 19, 2023 11:00 - 47 minutes - 43.9 MB

Ryan tells Sam about a side project of his that involves running the text-to-image deep learning model Stable Diffusion on his laptop in response to web requests. Ryan asks Sam questions about animating this UI, including how to animate indeterminate progress, how to avoid unintentional layout animation, and how to automatically repeat a set of items while scrolling rather than stopping at the end. Topics include: 0:00 - Intro 0:24 – Overview of Ryan’s Stable Diffusion project - 9:36 – S...

Lessons from stitching GraphQL services with Hasura

January 11, 2023 11:00 - 54 minutes - 49.6 MB

Ryan talks about the pros and cons of exposing Build UI’s environment-independent CMS from Hasura via schema stitching. He also talks about writing a Postgres function to add a derived field to a database model. Sam shares a debugging story about fixing his personal website due to a breaking change in a minor version of npm. Topics include: 0:00 - Intro 1:50 - Debugging Sam’s personal website due to a breaking change in npm related to peer dependencies 18:00 - Pros and cons of using a Po...

How to solve a SSR/CSR mismatch using the DOM

December 29, 2022 13:24 - 51 minutes - 47.2 MB

Sam and Ryan chat about how to avoid a flicker of content on initial render due to mismatched server/client rendering. They also chat about the pros and cons of React Hooks, and using StackBlitz containers to debug OSS issues. Topics include: 0:00 – Intro 1:46 – Ryan Florence’s tweets about Hooks, useEffect and refs 18:12 – How to avoid SSR/CSR rendering mismatches when your initial render depends on client-side APIs 37:40 – Using StackBlitz for reproduction in open source 45:17 – Isol...

Why we’re adding a CMS to Build UI

December 02, 2022 16:54 - 41 minutes - 38.4 MB

Sam and Ryan chat about issues they’ve run into in the past when building media sites that store content alongside other dynamic data like user accounts, and how they’re using a CMS to alleviate these problems in Build UI. They also talk about the approach they’ll be using for access control to the CMS. Topics include: 0:00 – Intro 0:27 – Unintentional security attack vectors 11:20 – Environment-specific vs. environment-independent data 23:43 – Architecture discussion for an environment...

Testing is inescapable

September 16, 2022 19:42 - 36 minutes - 33.1 MB

Sam and Ryan chat about building their new site using services, and how they’re thinking about testing it. They talk about how testability is one of the biggest costs of using third-party hosted services, why they continue to like services in spite of this downside, and the fact that you always end up testing your app whether you eventually automate it or not. Topics include: 0:00 - Intro 0:59 - How to run automated integration tests against a site that’s built with services

Type safety from Hasura to SWR

September 02, 2022 20:22 - 55 minutes - 50.8 MB

Ryan shares his experience getting end-to-end type safety from a Hasura backend into a React application. He tells Sam about the different ways GraphQL codegen can be used to generate types, and how he ultimately landed on a solution that combines the TypedDocumentNode type and the zod library. Topics include: 0:00 - Intro 2:51 - Using GraphQL Language Server to get autocomplete + linting 13:05 - Getting type information on the return object from a query passed to SWR 24:06 - Generating...

Playing with Server Components in Vercel’s Edge Runtime

August 22, 2022 16:44 - 51 minutes - 47.1 MB

Ryan tells Sam about some experiments he’s been running using Server Components in Vercel’s new edge runtime. He talks about how components that suspend in the node runtime cause the static build of your Next.js app to wait until they unsuspend, while components that suspend in the edge runtime stream back fallback responses as data is being fetched. Ryan also tells Sam about a blocking JS trick he learned to alter the initial render of your clientside app based on client-specific data, like...

The problem with buttons on the web

July 20, 2022 12:24 - 55 minutes - 50.7 MB

Sam and Ryan chat about issues with default HTML buttons on the web across different devices and browsers. They talk about the Extensible Web Manifesto, how the React Aria library helps standardize button behavior across platforms, and the difference between state-based and event-based animations. Topics include: 0:00 - Intro 2:09 – The problem with default buttons on the web - 17:26 – How we got here, and the Extensible Web Manifesto - 26:22 – React Aria’s unified Press interface - 32...

Should you use merge commits or rebase when working on large codebases?

June 06, 2022 18:54 - 55 minutes - 53.5 MB

Sam and Ryan talk about whether you should use merge commits or you should rebase commits in your PRs when working on large, fast-moving codebases. They also talk about implementing build-time client-side search with Stork, and why layering in animation code shouldn’t materially affect your existing React code. Topics include: 0:00 - Intro 1:48 – How to use D3 with React elements - 9:14 – Why you should unmount Modals and Dialogs when they’re not visible - 24:36 – Using Stork to impleme...

Read and discuss: Next.js Layouts RFC

May 31, 2022 23:32 - 57 minutes - 52.4 MB

Sam and Ryan read and discuss the first two sections of the new Next.js Layouts RFC, Nested Layouts and Server Components. They also reflect on their experience using nested layouts in other frameworks. Topics include: 0:00 – Intro - 10:21 – Layouts and creating UI (Apple Music example) - 33:40 – React Server Components - Links: Layouts RFC Framer Motion Course update

All about useEvent

May 12, 2022 16:17 - 59 minutes - 54.4 MB

Sam and Ryan talk about the new useEvent RFC, and how useEvent lets you extract event logic from your side effects. They also read and discuss Dan Abramov’s recent Twitter thread on how useEvent addresses the problems people are encountering with React 18’s Strict Mode behavior around running effects twice on mount. Topics include: 0:00 - Intro 0:34 - How useEvent relates to the changes to Strict Mode in React 18 12:04 - Dan Abramov’s thread on how useEvent relates to “fixing” useEffect ...

Strict Mode Behaviors in React 18

May 06, 2022 18:03 - 44 minutes - 41.2 MB

Sam and Ryan talk about the motivation behind the changes to Strict Mode in React 18, and in particular why React simulates an immediate unmount and remount by re-running component effects. They also talk about the tradeoff between database consistency and speed. Topics include: 0:00 - Intro 1:12 - The tradeoff between data that’s fast but stale, vs. data that’s slow but consistent 11:55 - Strict mode in React 18, the proposed Offscreen API, and the implications for internal vs. external...

Reacting to Remix!

March 25, 2022 19:19 - 1 hour - 59.6 MB

Sam and Ryan share their experiences building with Remix for the very first time. Sam built a simple exercise tracking app using the Indie starter stack, and Ryan built a blog using server rendering in both Remix and Next.js, and talks about the differences between the two frameworks. They both discuss what the larger React community can learn from the ideas that Remix has to offer. Topics include: 0:00 - Intro 2:33 - Sam’s Remix app 6:34 - The Indie stack 19:36 - Creating the data mode...

Client apps, server apps, and the real reason DX matters

March 17, 2022 14:38 - 1 hour - 70.5 MB

Sam and Ryan chat about Remix and the differences between data fetching and mutations on the client vs. the server. They also talk about whether a framework’s APIs or the actual apps it enables developers to build are more important when choosing which tool to use. Topics include: 0:00 - Intro 2:17 - What matters more to developers when choosing a framework: their experience using the APIs, or what they can build with it? 18:38 - Remix and data fetching on the client vs. the server 36:3...

Auth-based route guards in Next.js and debugging in production

March 08, 2022 16:39 - 1 hour - 61.6 MB

Sam and Ryan chat about adding authentication-based route guards to Next.js, tradeoffs between one-shot data loading vs. reactive pages in React apps, and instrumenting errors with Sentry. Topics include: 0:00 - Intro 8:07 - Auth-based route guards and synchronized spinners in Next.js 26:34 - Tradeoffs of loading once on render vs. fully reactive pages 42:30 - Ryan’s video on Deploy notifications 47:45 - Errors + stale auth + Sentry Links: Fixing Twitter's loading screen using Synchr...

What’s the link between Server Components and Suspense for Data Fetching?

February 25, 2022 17:33 - 1 hour - 66.5 MB

Sam and Ryan talk about why Suspense for Data Fetching isn’t ready yet, and how both it and the Server Components feature of React 18 rely on the ability to evict a cache that’s internal to React. They also talk about Transitions. Topics include: 0:00 - Intro 5:19 - Using startTransition with a router 9:36 - How React 18 yields 21:37 - Why both Suspense for Data Fetching and Server Components need a way to invalidate React’s cache 37:24 - How Server Components can remove the need for e...

Internal apps vs. public websites

February 17, 2022 01:26 - 1 hour - 55.5 MB

Sam and Ryan chat about the differences between building internal apps vs. public websites, and why public sites get talked about more on forums like Twitter. They also talk more about their experiments with Suspense and Transitions in React 18. Topics include: 0:00 - Intro 2:35 - How to trigger Suspense by accessing an unresolved promise 11:04 - Tension between flexibility of Transitions and Suspense vs. best practices around data fetching 21:00 - Semantics of React APIs when using Con...

How to bridge the gap from module scope to React rendering

February 04, 2022 17:05 - 47 minutes - 43.3 MB

Sam and Ryan talk about using Promises and state libraries like Valtio to cross the bridge from changing module scope to React component state. Ryan also talks about writing an end-to-end Cypress test that verifies image uploads to S3. Topics include: 0:00 - Intro 1:50 - Using Promises and state libraries to bridge the gap from module scope to React rendering 23:05 - How to test image file uploads given the security constraints of the browser Links: Valtio Removing State and Effects w...

Is Suspense “backwards compatible”, and thoughts on Remix & web standards

January 29, 2022 16:20 - 1 hour - 60.9 MB

Sam and Ryan chat about how Suspense lets you remove defensive and confusing useEffect code from your React components. They also share some initial thoughts about how Remix is positioning itself in the frontend dev space. Topics include: 0:00 - Intro 4:53 - How compatible are non-Suspense APIs with Suspense, and how can we bridge these two worlds? 33:35 - Impressions about Remix’s positioning around web standards Links: Sam’s video for this week Remix The Cursed Computer Iceberg Mem...

Twitter Mentions

@samselikoff 21 Episodes
@ryantotweets 16 Episodes
@dan_abramov 7 Episodes
@sebmarkbage 3 Episodes
@ryanflorence 3 Episodes
@rich_harris 2 Episodes
@rauchg 2 Episodes
@garybernhardt 2 Episodes
@pzuraq 1 Episode
@joshwcomeau 1 Episode
@davewasmer 1 Episode
@lukemelia 1 Episode
@floydophone 1 Episode
@katiegengler 1 Episode
@keystonelemur 1 Episode
@jwwweber 1 Episode
@getajobmike 1 Episode
@nselikoff 1 Episode
@derrickreimer 1 Episode
@tantantanmian 1 Episode