Oli Griffiths on the Benefits of Static Typing and How Broccoli Works

FromFrontend First

Start listening View podcast show

Oli Griffiths on the Benefits of Static Typing and How Broccoli Works

FromFrontend First

ratings:

Length:

51 minutes

Released:

Mar 7, 2018

Format:

Podcast episode

Description

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.

Released:

Mar 7, 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

42: “Pragmatic priorities”, with special guest Ted Kremenek: Ted Kremenek, manager of the Languages and Runtimes team at Apple, joins John to talk about Swift 5 — focusing on ABI stability and what it means for the future of the language, how the underpinnings of String have been improved in this release, how Apple is using Swift internally, and much more. by Swift by Sundell
49 min listen
Episode 171: Compose Testing by Android Developers Backstage
40 min listen
Episode 340: RR 333: RubyMotion and the Aesthetic of Ruby with Amir Rajan by Ruby Rogues
69 min listen
Episode 301: JSJ 298: Angular, Vue and TypeScript with John Papa by JavaScript Jabber
43 min listen
Monomania - Mono, MonoTouch, MonoSpace, and MonoVS with Joseph Hill and Scott Bellware: Scott chats with Mono Product Manager Joseph Hill and Monospace conference organizer and continous learner Scott Bellware about the state of Mono. Is Mono competition or diversity? How hard are cross platform apps? Can you really write apps for your iPhone in C#? Where can you learn more about Mono? by Hanselminutes with Scott Hanselman
43 min listen
297: The Functional Rubyist with Joe Leo: Joe Leo is the CEO of Def Method, an agile Ruby software consultancy, and the co-author of The Well-Grounded Rubyist, Third Edition. He and Brittany discussed functional programming in Ruby and their thoughts on the Ruby community after Rubyconf 2019. by The Ruby on Rails Podcast
37 min listen
SE Radio 608: Lane Wagner on Revisiting the Go Language: Lane Wagner of Boot.dev speaks with host about Go, the programming language that's popular for web, cloud, devops, networking, and other types of development. In addition to discussing existing features such as structs, interfaces, concurrency, and... by Software Engineering Radio - the podcast for professional software developers
68 min listen
Creating a Language: Elixir vs. Roc with José Valim and Richard Feldman (Elixir Wizards X Software Unscripted Podcast): For the final episode of Elixir Wizards’ Season 11 “Branching Out from Elixir,” we’re featuring a recent discussion from the Software Unscripted podcast. In this conversation, José Valim, creator of Elixir, interviews Richard Feldman, creator of Roc. They compare notes on the process and considerations for creating a language. by Elixir Wizards
69 min listen
Episode 20: Fonts and Audio: Tor and Chet talk with Raph Levien from the Android UI Toolkit team, who works on font technology for Android. The conversation wanders freely into areas such as Raph's creation of the Inconsolata font, his work on Ghostscript, and tinkering he's done wit by Android Developers Backstage
51 min listen
202: I Left it All on The Dance Floor: In this week's episode, Chris and Steph discuss how working with typed-languages influences their work with dynamic languages. They also chat about the benefits of pair programming, tracking performance events using Rails' Instrumentation API and respond by The Bike Shed
32 min listen
Native Mobile Applications vs. HTML5 Apps with the Developertown Crew: Native Mobile Applications vs. HTML5 Apps with the Developertown Crew by Private Equity Funcast
60 min listen
We Almost Always Get the Default Wrong: This week we chat with Vittorio Romeo about the pros and cons of backwards compatibility in C++, and his proposal to get the best of both worlds: Epochs. As well as language compatibility, we also discuss _ABI_ compatibility - why breaking these things is such a problem, but how _not_ breaking them is increasingly becoming a problem. We also, finally, get an answer to the age of question of, 'how many programmers does it take to change a lightbulb?' by cpp.chat
58 min listen
Lying in TypeScript: 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. by Frontend First
48 min listen
Indie Game Dev with Amir Rajan - Dragon Ruby and Ruby Motion by Remote Ruby
50 min listen
Episode 338: RR 331: 30 days to Elixir then Crystal and back again to Ruby with Fabio Akita by Ruby Rogues
64 min listen
Protocols in Elixir with Yiming Chen: Today on the show we are grateful to get the chance to speak with Yiming Chen from Tubi, where we hear all about how he likes to use Elixir and the contributions he has made to the community. by Elixir Wizards
42 min listen
Episode 150: Software Craftsmanship with Bob Martin: This episode is a conversation with "Uncle Bob" Bob Martin about agile software development and software craftsmanship specifically. We talk about the history of the term, the reasons for coming up with it some of the practices and the relationship to ... by Software Engineering Radio - the podcast for professional software developers
59 min listen
Functional Geekery Episode 112 - Micheal Sperber: Functional Geeks, Geeking Functionally by Functional Geekery
53 min listen
S13:E5 - Why you should consider learning Ruby ( Jay McGavren): Ruby, it's a real gem by CodeNewbie
35 min listen
SE Radio 582: Leo Porter and Daniel Zingaro on Using LLMs in the Classroom: Dr. Daniel Zingaro and Dr. Leo Porter, co-authors of the book Learn AI-Assisted Python Programming, speak with host about teaching programming with the aid of large language models (LLMs). They discuss writing a book to use in Leo's introductory CS... by Software Engineering Radio - the podcast for professional software developers
62 min listen
53: “The Swift Apple”, with special guest Brent Simmons: Longtime Apple platforms developer Brent Simmons joins John to discuss how SwiftUI is ushering in a new era for Apple’s developer tools, and how we as third party developers can prepare for it. Also, Mac development, lots of tips for writing efficient code, and dynamic programming in Swift. by Swift by Sundell
76 min listen
S19:E5 - What are some common mistakes people make when learning to code (Ceora Ford): It's not just you by CodeNewbie
38 min listen
SE Radio 610: Phillip Carter on Observability for Large Language Models: Phillip Carter, Principal Product Manager at Honeycomb and open source software developer, talks with host about observability for large language models (LLMs). The episode explores similarities and differences for observability with LLMs versus more... by Software Engineering Radio - the podcast for professional software developers
65 min listen
Episode 188: AiA 187: Teaching Angular through Rhyme.com with Minko Gechev by Adventures in Angular
47 min listen
Functional Geekery Episode 63 - Yan Cui by Functional Geekery
53 min listen
MonoGame and Xamarin make shipping Infinite Flight a reality: Scott's at the Xamarin Evolve conference and talks to Dean Ellis who works on the MonoGame framework and Philippe Rollin from Infinite Flight. Philippe, along with business partner Matthieu Laban have created an amazing flight simulator using C# that's available in AppStores now! How did they do it? by Hanselminutes with Scott Hanselman
34 min listen
Building Desktop and Mobile Video Games with DragonRuby with Amir Rajan - RUBY 572 by Ruby Rogues
70 min listen
Episode 260: JSJ 259 Clean Code JavaScript with Ryan McDermott by JavaScript Jabber
54 min listen
Building actually maintainable software: with sam boyer and Ian Lopshire by Go Time: Golang, Software Engineering
72 min listen
S1 E36 - The Future of Angular: What is the future of Angular? What new features and improvements are being thought of and worked on? Will the developer experience improve? Panelists Brian Love and Aaron Frost sat down with Minko Gechev, a member of the developer relations team for... by The Angular Plus Show
50 min listen

Discover this podcast and so much more

Oli Griffiths on the Benefits of Static Typing and How Broccoli Works

Oli Griffiths on the Benefits of Static Typing and How Broccoli Works

Description

Titles in the series (100)

More Episodes from Frontend First

Related podcast episodes