Hosted by

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


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.