Breaking Production, Functional CSS and UI Components, and Testing Async Errors

FromFrontend First

Start listening View podcast show

Breaking Production, Functional CSS and UI Components, and Testing Async Errors

FromFrontend First

ratings:

Length:

47 minutes

Released:

Jan 10, 2018

Format:

Podcast episode

Description

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.

Released:

Jan 10, 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

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
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
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
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
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
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
JSONAPI Operations, Caching in FastBoot, and Ember's Strengths: 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. by Frontend First
45 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
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
Your frontend is ready for production: Sam and Ryan talk about their upcoming email course on Ember component patterns, wrapping up their EmberMap series on Functional CSS, refactoring some FastBoot code in Node, and how Mirage might be useful if it could run as a real server. by Frontend First
55 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
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
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
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
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
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
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
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
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
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
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
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
Toran Billups on Hot Reloading: Toran talks to Sam and Ryan about his project Ember CLI Hot Loader, which is an implementation of component-based hot module reloading for Ember apps. by Frontend First
42 min listen
You gotta feel the pain: Sam and Ryan talk about APIs that empower developers, even if it means giving them enough freedom to make mistakes. They also talk about building a component with dynamic children in both Ember and React. by Frontend First
94 min listen
Melanie Sumner on empowering JavaScript engineers: Mel chats with Sam about getting into Ember, lessons learned from collaborating at work and in open source, and how to make it easier for JavaScript engineers to use better UI patterns. by Frontend First
53 min listen
From build-time to run-time: Sam and Ryan chat about using GitHub Issues to power Mirage's blog, and what implications run-time and build-time data have for the architecture of the AddonDocs site. They also discuss Simon Sinek's "Celery Test" in the context of Ember.js. by Frontend First
65 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

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

Related podcast episodes

Skip carousel

Episode 360: RR 353: Removing Business Logic from Rails Controllers with Aaron Sumner by Ruby Rogues
58 min listen
8: Sean Devine - Ember and API first: In this episode, Adam talks with Sean Devine, host of the Ruby on Rails podcast. Sean gives Adam an introduction to building applications with Ember, and how it's different than the way you might sprinkle AngularJS into a mostly server-side app. They talk by Full Stack Radio
58 min listen
The elephant in the room: Sam and Ryan discuss the difficulty of working with a design system that doesn't have good escape hatches, how implementing HTML and CSS can be more complex and time-consuming than coding user behavior, and some creative approaches to ensuring JSON:API payloads represent canonical server-side state. by Frontend First
65 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
Can small libraries be conventional?: Sam and Ryan chat about two new EmberMap series, Forms and Async testing, as well as Sam's keynote at EmberCamp and the best way to avoid product gaps in open-source software. They also answer some listener questions. by Frontend First
66 min listen
183: Sean Devine Interview on Full Stack Radio about API-First Development: This episode is an interview from Full Stack Radio about API-first development, Ember, and Ruby on Rails. by The Ruby on Rails Podcast
63 min listen
Testing is inescapable: 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. by Frontend First
36 min listen
Everyone's sidestepping useEffect. Is everyone wrong, or is it React? by Frontend First
67 min listen
Your frontend is ready for production: Sam and Ryan talk about their upcoming email course on Ember component patterns, wrapping up their EmberMap series on Functional CSS, refactoring some FastBoot code in Node, and how Mirage might be useful if it could run as a real server. by Frontend First
55 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
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
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
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
Adventures with Amplify by Frontend First
67 min listen
Explained - Buzz Words and Concepts: In this Hasty Treat, Scott and Wes explain more buzz words like schema, promises, async, sync, dom vs shadow dom vs page HTML, props, and more. Appwrite - Sponsor Appwrite is a self-hosted backend-as-a-service platform that provides developers with... by Syntax - Tasty Web Development Treats
22 min listen
7: Shawn McCool - BDD and DDD: In this episode, Adam talks with Shawn McCool about Behavior Driven Development and Domain Driven Design. They talk about how you can use these ideas to better understand your clients' needs and to build software that closely models their business. They a by Full Stack Radio
61 min listen
#321: Understanding the AWS Serverless Application Model (SAM): Do you want to deploy Serverless applications faster, easier and more reliably? The AWS Serverless A by AWS Podcast
20 min listen
How to solve a SSR/CSR mismatch using the DOM: 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. by Frontend First
52 min listen
021: From Idea To Production: Part 1: We discuss an idea for a web app and identify ways to turn it into a real-life product on the web. We start with describing the domain and the problems the app should solve. Then we identify the personas that will interact with the app. We discuss the... by PHPRoundtable Podcast
75 min listen
At the Cutting Edge & Node with Nader Dabit: This week Nader Dabit, who works in developer relations at Edge & Node, joins Corey to chat. What is Edge & Node? Nader breaks it down for us. He also discusses his career and unconventional background that lead up to joining Edge & Node, and how he is al by Screaming in the Cloud
37 min listen
#625: AWS Application Composer: AWS Application Composer helps teams collaborate as they build well-architected applications backed by AWS Podcast
19 min listen
Provide this!: Sam and Ryan chat about provider components in Ember, including the first renderless components they wrote, the different types of data components can provide, and the patterns of template composition that providers unlock. They also talk about the need for a unified API for styling Ember components. by Frontend First
52 min listen
SE Radio 603: Rishi Singh on Using GenAI for Test Code Generation: Rishi Singh, founder and CEO at Sapient.ai, speaks with SE radio’s about using generative AI to help developers automate test code generation. They start by identifying key problems that developers are looking for in an automated test-generation... by Software Engineering Radio - the podcast for professional software developers
49 min listen
Mitigating at Design Time - Shaun Lamb - ASW #95: In this interview segment, Mike and John interview Shaun Lamb about strategies for how best to design applications so they are "secure by default" and have fewer incidents and vulnerabilities, How DevOps or DevSecOps positively changes the... by Application Security Weekly (Video)
37 min listen
Mitigating at Design Time - Shaun Lamb - ASW #95: In this interview segment, Mike and John interview Shaun Lamb about strategies for how best to design applications so they are "secure by default" and have fewer incidents and vulnerabilities, How DevOps or DevSecOps positively changes the... by Security Weekly Podcast Network (Video)
37 min listen
Episode 339: RR 332: Exploring Connections Between Your Apps and the Web with Justin Weiss by Ruby Rogues
46 min listen
S2 E19 - Dynamic Module + Component Loading Using any Observables: Single Page Applications (SPA) have many advantages, including increased interactivity, responsiveness, and user experience. However, a SPA often requires sending large chunks of JavaScript code to the client. This code must be downloaded and parsed... by The Angular Plus Show
63 min listen
#449: [INTRODUCING] AWS App Runner: AWS App Runner is a fully managed container application service that makes it easier and faster for by AWS Podcast
19 min listen
How Suspense led to Server Components (React Roundtable reaction) by Frontend First
51 min listen
Playing with Server Components in Vercel’s Edge Runtime: 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 whether their theme preference is dark or light mode. by Frontend First
51 min listen

Discover this podcast and so much more

Breaking Production, Functional CSS and UI Components, and Testing Async Errors

Breaking Production, Functional CSS and UI Components, and Testing Async Errors

Description

Titles in the series (100)

More Episodes from Frontend First

Related podcast episodes