Hosted by

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


elm-codegen with Matthew Griffith
Matthew Griffith joins us to discuss elm-codegen, a tool for generating Elm safely and conveniently.
elm-watch with Simon Lydell
Simon Lydell joins us to discuss his new Elm dev server which has a minimalist philosophy and maximal refinement.
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.
The Root Cause of False Positives
We explore false positives and negatives in static analysis tools, and how Elm helps us avoid them.
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.
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.
Building Trustworthy Tools
We discuss how to earn users' trust by giving meaningful feedback and giving predictable results.
Wrap Early, Unwrap Late
We dive into preventing bugs and making your code more maintainable by wrapping early and unwrapping late.
Elm Store Pattern
Martin Janiczek joins us to discuss a pattern for declaratively managing loading state for API data across page changes.
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.
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.
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.
Developer Productivity
We share our productivity and workflow tips, and how it changes the way we write Elm code.
Dead Code
We discuss how to remove dead code in Elm, or avoid it altogether in your workflow, and why it matters.
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.
Primitive Obsession
We discuss the Primitive Obsession code smell, and how introducing types with semantic meaning can improve your Elm codebase.
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.
Optimizing Performance with Robin Hansen
We talk about Robin's work optimizing Elm, and the opportunities that remain for Elm performance improvements.
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?
What's Working for Elm
We look at what we can learn by understanding what's working well for Elm and the Elm ecosystem.
2021 Holiday Special!
Some Elm friends visit for a Family Feud-style game. Plus a special Holiday roundtable to close out the year!
How We Learn
We look at the techniques that helped us learn Elm and that help us continue to learn new techniques today.
Andrey Kuzmin walks us through Elm's syntax for writing 3D shaders and using them in a type-safe way from Elm.
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.
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.
We discuss the elm-markdown's approach to extensiblility, the markdown specification, and some advanced uses.
Phantom Builder Pattern
Jeroen introduces the phantom builder pattern and how it enables new guarantees in Elm API design.
Tereza joins us to talk about building charts in Elm using the new elm-charts package.
Lamdera lets you build full-stack Elm apps with zero glue code. We discuss the philosophy and the 1.0 release with Mario Rogic.
Performance in Elm
We talk about performance tuning Elm applications.
elm-pages 2.0
elm-pages v2 is here! We discuss the latest features, including pulling in data with the new DataSource API.
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.
API Design Lessons
We share what we've learned from designing Elm APIs and how it applies when building applications and tools.
Accessibility in Elm
Guest Tessa Kelly walks us through some accessibility best practices and how to apply them in Elm.
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.
Elm Code Generation
We discuss different use cases for code generation in Elm applications, and our favorite code generation tips.
Debugging in Elm
We talk about our favorite debugging techniques, and how to make the most of Elm's guarantees when debugging.
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.
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.
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!
Funding Open Source with Evan Czaplicki
Evan shares what he's learned about Open Source funding and the tradeoffs of different models.
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.
Aaron VonderHaar joins us to share the fundamentals and best practices for his high-level Elm testing package, elm-program-test.
We discuss the core features and philosophy of elm-format, as well as some hidden productivity tricks for getting more out of it.
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.
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.
Holiday Special!
Some Elm friends visit for a Family Feud-style game. Plus a special Holiday roundtable to close out the year!
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.
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.
Codecs do two-way Encode/Decode. We talk about this pattern in Elm, and some codec tools for JSON and Bytes.
We talk about elm-graphql, how to organize your SelectionSets, and other best practices.
Incremental Steps
We talk about the value of taking small steps, and techniques to help break problems down in Elm.
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.
Make Impossible States Impossible
We discuss two classic talks and how to apply the ideas of Make Impossible States Impossible to your codebase.
We discuss the benefits that using the elm-spa framework bring to your codebase, and how to get started.
Parse, Don't Validate
We discuss the Alexis King's article and how those techniques apply in Elm.
We discuss the fundamentals of test-driven development, and the testing tools in the Elm ecosystem.
We discuss the fundamentals of elm-ui, and how to decide if it's the right fit for your team.
The Builder Pattern
We discuss the tradeoffs of using the builder pattern and how to get started with it.
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.
We discuss parsers, how to build them in Elm, and how to try to make your error messages as nice as Elm's.
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.
JSON Decoders
We discuss the basics of JSON Decoders, benefits compared to JSON in JavaScript, best practices, and how to get started learning.
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!
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.
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.