JSONAPI Operations, Caching in FastBoot, and Ember's Strengths

FromFrontend First

Start listening View podcast show

JSONAPI Operations, Caching in FastBoot, and Ember's Strengths

FromFrontend First

ratings:

Length:

45 minutes

Released:

Feb 22, 2018

Format:

Podcast episode

Description

Sam and Ryan talk about the upcoming Operations addition to the JSON:API spec, adding FastBoot support to Storefront, how to think about caching in Fastboot, and a thought experiment around how Ember might niche down and focus on its strengths.

Released:

Feb 22, 2018

Format:

Podcast episode

Titles in the series (100)

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

Skip carousel

Babel Plugins, Compile-time Components, and Extending Integration Tests: Sam and Ryan talk about writing Babel plugins, components that can be transformed to plain HTML at compile-time, the differences between run-time and compile-time error messaging, and one way to make integration tests more reusable and domain-specific. by Frontend First
50 min listen
Avoiding Imperative APIs and Expired Data: Sam and Ryan chat about Sebastian Markbage’s 2015 React Europe talk “DOM as a Second-Class Citizen,” and how to deal with stale data in an Ember app. by Frontend First
38 min listen
Luke Melia on Styleguides: Special guest Luke Melia chats with Sam and Ryan about styleguides, CSS patterns, Ember Freestyle and more. by Frontend First
40 min listen
Robert Jackson and Tom Dale on Ember at LinkedIn: Robert and Tom join Sam and Ryan to chat about how LinkedIn uses Ember, when teams should use Engines, build optimizations that are coming to Ember CLI and more. by Frontend First
65 min listen
Concretions and abstractions: Sam and Ryan chat about Tailwind and compilers (again), Ryan's EmberJS homepage teardown, and releasing with git tags. They also answer some listener questions. by Frontend First
48 min listen
Photo Uploads, Server Errors in Ember Data, NPM Dependencies and Ember CLI Addon Docs: Sam and Ryan talk about uploading images to S3, a new Storefront API for dealing with server errors in Ember Data, how to be a good community citizen when it comes to publishing consumable libraries given that our package managers now use lockfiles, and some ongoing work on the Ember CLI Addon Docs addon. by Frontend First
41 min listen
FastBoot, Structural Components and Ember Data Transactions: Sam and Ryan chat about adding FastBoot to EmberMap's codebase, the difference between reusable and structural components, and the road to adding transactions to Ember Data. by Frontend First
33 min listen
Let's be optimistic: Sam and Ryan talk about how to deal with building non-optimistic UIs using Ember and Ember Data, and how constrained visual design tools might help us build better UIs. They also answer some questions and talk about their current series on Functional CSS and Rendering tests. by Frontend First
53 min listen
Forms, Authentication, Ember 3.0, and Liquid Tether: Sam and Ryan discuss using contextual components to clean up forms, a unique authentication scenario using cookies and JWT, the release blog post about Ember 3.0, and building animations with the Liquid Tether addon. by Frontend First
33 min listen
Sketch Prototyping and Amazon Workspaces: Sam and Ryan chat about Sketch’s new Prototyping feature, using Amazon Workspaces to develop Ember apps in a Windows environment on a Mac, and how to use git tag to ensure your project’s dependencies don’t disappear. They also answer some listener questions. by Frontend First
54 min listen
Wrapping libraries reponsibly: Sam and Ryan chat about what to do when a node module breaks in FastBoot, how to best wrap 3rd-party libraries in an Ember Addon, and how to test the filesystem. They also answer some listener questions. by Frontend First
52 min listen
Alex Matchneer on Routing Patterns: Alex Matchneer chats with Sam and Ryan about challenging routing patterns in Ember, his involvement with the Ember community, and what Ember’s next router might look like. by Frontend First
89 min listen
Async Relationships, Store Forking, and Batch Saving in Ember Data: Sam and Ryan discuss community feedback on Ember Data's pain points, including asynchronous relationships, store forking and batch saving. by Frontend First
39 min listen
Glimmer, Ember's reputation and Tachyons: Listen to Sam and Ryan chat about their experience using Glimmer, how Ember is perceived in the larger front-end community, and their experience with Tachyons, the functional CSS library. by Frontend First
26 min listen
Jen Weber on imaginary bars: Jen talks to Sam and Ryan about her journey learning from and giving back to Ember, and how she keeps her community contributions sustainable by tying them back to personal goals and rewards. by Frontend First
38 min listen
Test before commit: Sam and Ryan chat about Ember at Microconf, two-way bindings, and TDD vs. "Test before commit". by Frontend First
41 min listen
Bugs vs. features: Sam and Ryan chat about some ideas around caching in FastBoot, different ways of prioritizing work, and the difference between easy things and hard things in Ember. by Frontend First
68 min listen
Declarative Data Fetching, Disposable Code, Easier Upgrades, and the Upfront Cost of Ember: Sam and Ryan talk about a new Storefront API and why routes should declare their data needs, patterns that make your code more disposable, how Ember CLI Update simplifies the process of upgrading your Ember apps, and what teams should consider when choosing Ember for their next project. by Frontend First
38 min listen
Mirage, meet Node: Sam and Ryan talk about their initial attempts to get Mirage running in Node, the benefits and workflows that it will unlock, some different approaches for using code in both the browser and Node, and how we might test FastBoot apps in the future. by Frontend First
55 min listen
Oli Griffiths on the Benefits of Static Typing and How Broccoli Works: Oli Griffiths joins Sam and Ryan to talk about his experience using typed languages, what kinds of benefits static could bring to the Ember developer experience, and his upcoming EmberConf training on Broccoli.js. by Frontend First
51 min listen
Compose wisely: Sam and Ryan chat about the challenges of testing custom asynchronous code. They also talk about React's new Hooks API, and discuss situations where hooks might be more composable than yields and contextual components. by Frontend First
59 min listen
Making the impossible, impossible: Sam and Ryan talk about their Functional CSS training at EmberConf, some ideas for hiding styling implementation details from templates, a new setup for multiple staging environments, an idea from data modeling called "Making the impossible, impossible", and how to use data down actions up effectively in forms. They also answer some listener questions. by Frontend First
48 min listen
Incremental Ember upgrades: Sam and Ryan discuss a new process for upgrading Ember apps and Sam's experience using it on EmberMap's codebase. They also talk about leadership in Open Source projects and lessons learned from Mirage. by Frontend First
59 min listen
Adam Wathan on Tailwind CSS: Adam joins Sam and Ryan to talk about coupling in HTML and CSS, different approaches to styling applications, and his popular open-source library Tailwind CSS. by Frontend First
67 min listen
Jonathan Jackson on FastBoot Rehydration and Codemods: Jon joins Sam and Ryan to talk about his recent work on rehydration in FastBoot and all the creative ways we can use Codemods to automate the routine parts of our jobs. by Frontend First
88 min listen
Recursive partial application: Sam and Ryan discuss an elegant solution to the async nested dropdown problem, a FastBoot success story regarding inlined CSS, pre-warming FastBoot's cache, and implementing a new design alongside an existing design language. by Frontend First
62 min listen
Tom Dale on Static Analysis, Upstreaming Glimmer, and Ember in 2018: Tom Dale chats with Sam and Ryan about static analysis and compilers, upstreaming learnings from Glimmer, and what sort of size and speed improvements Ember.js will see in 2018. by Frontend First
57 min listen
A man can dream: Sam and Ryan talk about bringing the ideas of declarative rendering over to our data layers, how easy it is for data to become stale in SPAs, and more stories from their recent adventures in FastBoot land. by Frontend First
50 min listen
Breaking Production, Functional CSS and UI Components, and Testing Async Errors: Sam and Ryan chat about all the different ways you can make sure your app is working, some of their latest thoughts on functional CSS and presenter components in Ember, and how to test asynchronous errors in an acceptance test. by Frontend First
47 min listen
Steelman vs. strawman: Sam and Ryan talk about their new series, “Declarative rendering,” and why we should use steelman arguments instead of strawman arguments when talking about technology. They also answer some listener questions. by Frontend First
47 min listen

More Episodes from Frontend First

Skip carousel

CodeMirror | Radix Themes: Sam tells Ryan about his experience setting up an in-browser code editor with CodeMirror that he plans on using for blog posts and code recipes, as well as what he thought about using Radix Themes for the first time in earnest on a side project of his currently styled with Tailwind. by Frontend First
45 min listen
Throw is about control flow – not error handling: Sam and Ryan talk about why it’s better to think of throw as a general-purpose JavaScript language feature rather than something that should only be used for error handling. They discuss the ambiguity around the phrase “error handling”, situations that call for dealing with errors locally vs. globally, and how throw can be useful for non-error control flow. They also discuss the problems with trying to shoehorn dynamic features into a static site. by Frontend First
64 min listen
The Philosophy of Next.js: 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. by Frontend First
76 min listen
Beyond Data Fetching with RSCs: 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. by Frontend First
70 min listen
Blog Post Club: React Labs – What We’ve Been Working On: Sam and Ryan read and discuss the latest update from React Labs. by Frontend First
83 min listen
Instant URL search params in Next.js: 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. by Frontend First
45 min listen
React Deep Dive: useOptimistic: Ryan and Sam discuss the purpose and usage of the useOptimistic() hook, a new experimental API from React. by Frontend First
51 min listen
React Cache: Deep Dive by Frontend First
67 min listen
Advanced Radix UI | Blog Post Club: React Server: 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. by Frontend First
56 min listen
The SQL Injection Slide: 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](https://mostlytechnical.com/). by Frontend First
88 min listen
The Remix Architecture: 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. by Frontend First
46 min listen
Implementing RSC, Part 2: Server Actions: 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. by Frontend First
57 min listen
Lessons learned from implementing RSC: Part 1: 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. by Frontend First
59 min listen
Should a navigation and a refresh show the same page?: 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. by Frontend First
45 min listen
Tim Neutkens on the Next.js App Router: 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. by Frontend First
105 min listen
Understanding prop passing from RSC to Client Components: 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. by Frontend First
48 min listen
Server-side rendering vs. Server Components by Frontend First
50 min listen
Reusable pending UI for forms with Server Actions by Frontend First
42 min listen
How Suspense led to Server Components (React Roundtable reaction) by Frontend First
51 min listen
Learning by copy-paste by Frontend First
41 min listen
What problems do React Server Components solve? by Frontend First
51 min listen
Implicit time zones and the TZ environment variable by Frontend First
46 min listen
React email previews and radial gradients by Frontend First
42 min listen
Blending modes and secure redirects by Frontend First
38 min listen
React Aria Components by Frontend First
35 min listen
JavaScript needs a model layer by Frontend First
43 min listen
Server Components and the React paradigm by Frontend First
51 min listen
HTML, HTTP, and React by Frontend First
61 min listen
Caching strategies by Frontend First
69 min listen
Saying goodbye to static generation by Frontend First
60 min listen

Discover this podcast and so much more

JSONAPI Operations, Caching in FastBoot, and Ember's Strengths

JSONAPI Operations, Caching in FastBoot, and Ember's Strengths

Description

Titles in the series (100)

More Episodes from Frontend First