Hosted by

Dillon Kearns
Dillon Kearns
elm-pages, elm-graphql, Incremental Elm Consulting
Jeroen Engels
Jeroen Engels
elm-review, @CrowdStrike


December 4, 2023
Optimizing Bundle Size
We discuss Elm's strengths and weaknesses for optimizing bundle size, and how find and fix your app's bundle size bottlenecks.
November 20, 2023
elm-open-api with Wolfgang Schuster
Wolfgang Schuster joins us to discuss generating type-safe SDKs using elm-open-api.
November 6, 2023
elm-concurrent-task with Andrew MacMurray
Andrew MacMurray joins us to discuss `elm-concurrent-task` which allows you to run JavaScript functions with a Task style API.
October 23, 2023
elm-visualization with Jakub Hampl
Jakub Hampl joins us to discuss elm-visualization and how it enables powerful flexibility through its low-level building blocks philosophy.
October 9, 2023
Elm News with Wolfgang Schuster
Wolfgang joins us to discuss his philosophy and approach to sharing what's new in the Elm community.
September 25, 2023
Code Reading Club with Katja Mordaunt
We discuss Code Reading Club, how improving your code reading skills can make you a better programmer, and the readability of Elm code.
September 11, 2023
elm-land with Ryan Haskell-Glatz
We discuss elm-land, how it compares to elm-spa, and its philosophy of making Elm mainstream.
August 28, 2023
The Human Side of Open Source
We discuss the role of Open Source Software and how we approach leadership and communication in our projects.
August 14, 2023
Avoiding Unused Code
We discuss how to avoid unused Elm code, why it matters, and what leads to unused code in the first place.
July 31, 2023
Evergreen Migrations with Mario Rogic
Mario walks us through how Evergreen gives you type-safety between versions of your application, and some improvements in Lamdera 1.1.0.
July 17, 2023
elm-pages v3
We discuss the new elm-pages v3 release and the new suite of features for full-stack server-side rendered Elm.
July 3, 2023
Why We Care About Elm
We discuss our backstories, our core values and beliefs as developers, and why Elm speaks to us.
June 19, 2023
Writing Great Docs
We discuss why the baseline for Elm docs is so high, how to navigate docs as a user, and how to make your own docs great.
May 22, 2023
elm-review Data Extractors
We discuss elm-review's Data Extractors and how they open up your elm-review context to external tools like data visualizations.
May 8, 2023
Elm and Haskell with Flavio Corpa
Flavio Corpa joins us to discuss the similarities and differences between Elm and Haskell, and how learning Haskell can help you write better Elm code.
April 24, 2023
We discuss the power of decoupling from data types using low-level data, and how dillonkearns/elm-form gives you simpler wiring that feels like magic but isn't.
April 11, 2023
Elm and AI
Can we get strong guarantees from AI tools that are known to hallucinate? We discuss some strategies, and ways that Elm might be a great target for AI assistance.
March 28, 2023
Scaffolding Elm Code
We discuss the benefits of automating your Elm boilerplate, and design techniques for APIs that generate code.
March 13, 2023
Color parameters in elm-tailwind-modules with Philipp Krüger
Philipp joins us to talk about color parameters in elm-tailwind-modules and how that brings the tool closer to an ideal expression of a design system in Elm.
February 27, 2023
elm-app-url with Simon Lydell
Simon Lydell joins us to talk about a new approach to URL parsing in Elm that is both simple and powerful.
February 13, 2023
Elm and Vite
Lindsay Wardell joins us to talk about Vite and how to set it up for your Elm project.
January 30, 2023
elm-pages scripts
We discuss elm-pages BackendTasks and how to run them as scripts with a single command.
January 16, 2023
Plug and Play Design Systems with Georges Boris
Georges Boris joins us to share two new packages for theming and stateless widgets with minimal boilerplate.
January 2, 2023
Security in Elm
We discuss what makes Elm's security vulnerability surface area smaller, and what frontend security considerations are important in Elm apps.
December 19, 2022
2022 Holiday Special
Matthew Griffith and Mario Rogic join us to ring in the New Year and look at trends in Elm this year and looking forward next year.
December 5, 2022
Deliberate Practice
We discuss deliberate practice and how it can help you hone your craft, and make you even better at using Opaque Types.
November 21, 2022
elm-gql with Matthew Griffith
Matthew Griffith joins us to share his new type-safe GraphQL tool, and to compare the query builder and query generator approaches.
November 7, 2022
Types vs. Tests
We discuss the role of types versus tests, and whether they complement each other or make the other obsolete.
October 24, 2022
Elm and ADD
We discuss how Elm is a powerful tool for people with ADD, and how lessons learned from ADD can benefit people who don't have ADD.
October 10, 2022
Elm at a Billion Dollar Company with Aaron White
We discuss how betting on Elm has paid off at Vendr and get a CTO's perspective on using Elm at scale.
September 26, 2022
elm-codegen with Matthew Griffith
Matthew Griffith joins us to discuss elm-codegen, a tool for generating Elm safely and conveniently.
September 12, 2022
elm-watch with Simon Lydell
Simon Lydell joins us to discuss his new Elm dev server which has a minimalist philosophy and maximal refinement.
August 29, 2022
Projects We Wish We Had Time For
We discuss the power of the Elm when paired with developer tools, and we go through our notes to look at Elm tools we wish we had the time to build.
August 15, 2022
The Root Cause of False Positives
We explore false positives and negatives in static analysis tools, and how Elm helps us avoid them.
August 1, 2022
elm-test v2 with Martin Janiczek
Martin Janiczek joins us to talk about fuzz testing, why it matters, and how the upcoming elm-test v2 changes the way you write fuzzers in Elm.
July 18, 2022
Exploring a New Form API Design
We dive into some ideas for a new Form design, pulling in a lot of our favorite Elm techniques to make it safe and intuitive.
July 4, 2022
Building Trustworthy Tools
We discuss how to earn users' trust by giving meaningful feedback and giving predictable results.
June 20, 2022
Wrap Early, Unwrap Late
We dive into preventing bugs and making your code more maintainable by wrapping early and unwrapping late.
June 6, 2022
Elm Store Pattern
Martin Janiczek joins us to discuss a pattern for declaratively managing loading state for API data across page changes.
May 23, 2022
State of Elm 2022
Martin Stewart joins us to share the results from the State of Elm 2022 and look at some of the trends.
May 9, 2022
elm-book with Georges Boris
Georges Boris joins us to discuss elm-book and how it helps iterate on a design language of Elm widgets.
April 25, 2022
Use the Platform
We discuss what it means to use the web platform, and how that helps improve the user and developer experience in Elm apps.
April 11, 2022
Developer Productivity
We share our productivity and workflow tips, and how it changes the way we write Elm code.
March 28, 2022
Dead Code
We discuss how to remove dead code in Elm, or avoid it altogether in your workflow, and why it matters.
March 14, 2022
Category Theory in Elm with Joël Quenneville
Joël Quenneville joins us to help us distill down Category Theory patterns and explore what value it brings us as Elm developers.
February 28, 2022
Primitive Obsession
We discuss the Primitive Obsession code smell, and how introducing types with semantic meaning can improve your Elm codebase.
February 14, 2022
Large Elm Codebases with Ju Liu
Ju Liu joins us to share some tips and techniques from working with a large Elm codebase at NoRedInk.
January 31, 2022
Optimizing Performance with Robin Hansen
We talk about Robin's work optimizing Elm, and the opportunities that remain for Elm performance improvements.
January 17, 2022
If It Compiles It Works
What do we really mean when we say "if it compiles it works?" And how do we make sure our apps stay that way?
January 3, 2022
What's Working for Elm
We look at what we can learn by understanding what's working well for Elm and the Elm ecosystem.
December 20, 2021
2021 Holiday Special!
Some Elm friends visit for a Family Feud-style game. Plus a special Holiday roundtable to close out the year!
December 6, 2021
How We Learn
We look at the techniques that helped us learn Elm and that help us continue to learn new techniques today.
November 22, 2021
Andrey Kuzmin walks us through Elm's syntax for writing 3D shaders and using them in a type-safe way from Elm.
November 8, 2021
Teaching Elm with Richard Feldman
Using Elm at work means teaching Elm. We learn some tips from Richard on how to introduce people to new Elm concepts.
October 25, 2021
Comparing TypeScript and Elm's Type Systems
TypeScript and Elm have very different type systems with different goals. We dive into the different features and the philosophy behind their different designs.
October 11, 2021
We discuss the elm-markdown's approach to extensiblility, the markdown specification, and some advanced uses.
September 27, 2021
Phantom Builder Pattern
Jeroen introduces the phantom builder pattern and how it enables new guarantees in Elm API design.
September 13, 2021
Tereza joins us to talk about building charts in Elm using the new elm-charts package.
August 30, 2021
Lamdera lets you build full-stack Elm apps with zero glue code. We discuss the philosophy and the 1.0 release with Mario Rogic.
August 16, 2021
Performance in Elm
We talk about performance tuning Elm applications.
August 2, 2021
elm-pages 2.0
elm-pages v2 is here! We discuss the latest features, including pulling in data with the new DataSource API.
July 19, 2021
elm-spa v6
Ryan Haskell-Glatz joins us to discuss the latest version of elm-spa, including authenticated pages and the updated file-based router.
July 5, 2021
API Design Lessons
We share what we've learned from designing Elm APIs and how it applies when building applications and tools.
June 21, 2021
Accessibility in Elm
Guest Tessa Kelly walks us through some accessibility best practices and how to apply them in Elm.
June 7, 2021
Elm's Universal Pattern
Guest Joël Quenneville shares his wisdom on transforming and mapping in Elm, and how it applies across many Elm data types.
May 24, 2021
Elm Code Generation
We discuss different use cases for code generation in Elm applications, and our favorite code generation tips.
May 10, 2021
Debugging in Elm
We talk about our favorite debugging techniques, and how to make the most of Elm's guarantees when debugging.
April 26, 2021
Writing an elm-review Rule
We walk through how to write an elm-review rule from scratch. Also, how to test your rules, and how to write an automated fix.
April 12, 2021
GitHub Actions
We discuss best practices to setup GitHub Actions to make sure everyone has the same source of truth for checking your Elm code and deploying to production.
March 29, 2021
We discuss using elm-tailwind-modules to build type-safe Tailwind views. It's composable, uses Elm's built-in dead code elimination, and is a delightful way to style Elm apps!
March 15, 2021
Funding Open Source with Evan Czaplicki
Evan shares what he's learned about Open Source funding and the tradeoffs of different models.
March 1, 2021
elm-ts-interop is a tool that keeps types in sync between your Elm ports and JavaScript (or TypeScript) wiring code. We talk about the new design and compare it to the original.
February 15, 2021
Aaron VonderHaar joins us to share the fundamentals and best practices for his high-level Elm testing package, elm-program-test.
February 1, 2021
We discuss the core features and philosophy of elm-format, as well as some hidden productivity tricks for getting more out of it.
January 18, 2021
elm-tooling with Simon Lydell
elm-tooling helps you manage versions of tools like elm-format and elm. It downloads them more efficiently and securely. We discuss with the author, Simon Lydell.
January 4, 2021
elm-review Tips
We revisit elm-review with some tips, useful workflows, and helpful packages that have come out since our intro to elm-review episode.
December 21, 2020
Holiday Special!
Some Elm friends visit for a Family Feud-style game. Plus a special Holiday roundtable to close out the year!
December 14, 2020
Scaling Elm Apps
The techniques for managing state as an application grows look very different in Elm than they do in Object-Oriented and component-based frameworks. We discuss the differences and best practices.
November 30, 2020
Lighthouse Scores
Lighthouse can show you a lot of low-hanging fruit to improve your site's performance. It also points out ways to make your site more accessible, follow best practices, and perform better with SEO.
November 16, 2020
Codecs do two-way Encode/Decode. We talk about this pattern in Elm, and some codec tools for JSON and Bytes.
November 2, 2020
We talk about elm-graphql, how to organize your SelectionSets, and other best practices.
October 19, 2020
Incremental Steps
We talk about the value of taking small steps, and techniques to help break problems down in Elm.
October 5, 2020
The Life of a File
We revisit Evan's classic talk and dive into the process for how and when to split out Elm code into modules.
September 21, 2020
Make Impossible States Impossible
We discuss two classic talks and how to apply the ideas of Make Impossible States Impossible to your codebase.
September 7, 2020
We discuss the benefits that using the elm-spa framework bring to your codebase, and how to get started.
August 24, 2020
Parse, Don't Validate
We discuss the Alexis King's article and how those techniques apply in Elm.
August 10, 2020
We discuss the fundamentals of test-driven development, and the testing tools in the Elm ecosystem.
July 27, 2020
We discuss the fundamentals of elm-ui, and how to decide if it's the right fit for your team.
July 13, 2020
The Builder Pattern
We discuss the tradeoffs of using the builder pattern and how to get started with it.
June 29, 2020
Extending Elm
We discuss what Elm is intended for, techniques for going beyond that, and how to make tools nice to use when you do.
May 25, 2020
We discuss parsers, how to build them in Elm, and how to try to make your error messages as nice as Elm's.
May 11, 2020
How (And When) to Publish a Package
We cover the mechanics of publishing your first Elm package. Best practices for making a great package, and how to learn the API design skills to build great tools.
April 27, 2020
JSON Decoders
We discuss the basics of JSON Decoders, benefits compared to JSON in JavaScript, best practices, and how to get started learning.
April 8, 2020
Getting started with elm-review
elm-review lets you extend guarantees that Elm provides before running your code, by inspecting your project with custom rules that you write in pure Elm!
April 3, 2020
Intro to Opaque Types
Opaque Types are a fancy way of saying "custom type with a private constructor." We talk about the basics, how to get started, and some patterns for using Opaque Types.
April 3, 2020
Getting started with elm-pages
elm-pages lets you build fast, SEO-friendly static sites with pure Elm. We go over the core concepts, explain Static Sites vs. JAMstack, and give some resources for getting started with elm-pages.