spotifyovercastrssapple-podcasts

Hosted by

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

Episodes

#045
How We Learn
We look at the techniques that helped us learn Elm and that help us continue to learn new techniques today.
#044
elm-webgl
Andrey Kuzmin walks us through Elm's syntax for writing 3D shaders and using them in a type-safe way from Elm.
#043
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.
#042
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.
#041
elm-markdown
We discuss the elm-markdown's approach to extensiblility, the markdown specification, and some advanced uses.
#040
Phantom Builder Pattern
Jeroen introduces the phantom builder pattern and how it enables new guarantees in Elm API design.
#039
elm-charts
Tereza joins us to talk about building charts in Elm using the new elm-charts package.
#038
Lamdera
Lamdera lets you build full-stack Elm apps with zero glue code. We discuss the philosophy and the 1.0 release with Mario Rogic.
#037
Performance in Elm
We talk about performance tuning Elm applications.
#036
elm-pages 2.0
elm-pages v2 is here! We discuss the latest features, including pulling in data with the new DataSource API.
#035
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.
#034
API Design Lessons
We share what we've learned from designing Elm APIs and how it applies when building applications and tools.
#033
Accessibility in Elm
Guest Tessa Kelly walks us through some accessibility best practices and how to apply them in Elm.
#032
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.
#031
Elm Code Generation
We discuss different use cases for code generation in Elm applications, and our favorite code generation tips.
#030
Debugging in Elm
We talk about our favorite debugging techniques, and how to make the most of Elm's guarantees when debugging.
#029
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.
#028
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.
#027
elm-tailwind-modules
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!
#026
Funding Open Source with Evan Czaplicki
Evan shares what he's learned about Open Source funding and the tradeoffs of different models.
#025
elm-ts-interop
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.
#024
elm-program-test
Aaron VonderHaar joins us to share the fundamentals and best practices for his high-level Elm testing package, elm-program-test.
#023
elm-format
We discuss the core features and philosophy of elm-format, as well as some hidden productivity tricks for getting more out of it.
#022
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.
#021
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.
#020
Holiday Special!
Some Elm friends visit for a Family Feud-style game. Plus a special Holiday roundtable to close out the year!
#019
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.
#018
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.
#017
Codecs
Codecs do two-way Encode/Decode. We talk about this pattern in Elm, and some codec tools for JSON and Bytes.
#016
elm-graphql
We talk about elm-graphql, how to organize your SelectionSets, and other best practices.
#015
Incremental Steps
We talk about the value of taking small steps, and techniques to help break problems down in Elm.
#014
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.
#013
Make Impossible States Impossible
We discuss two classic talks and how to apply the ideas of Make Impossible States Impossible to your codebase.
#012
elm-spa
We discuss the benefits that using the elm-spa framework bring to your codebase, and how to get started.
#011
Parse, Don't Validate
We discuss the Alexis King's article and how those techniques apply in Elm.
#010
elm-test
We discuss the fundamentals of test-driven development, and the testing tools in the Elm ecosystem.
#009
elm-ui
We discuss the fundamentals of elm-ui, and how to decide if it's the right fit for your team.
#008
The Builder Pattern
We discuss the tradeoffs of using the builder pattern and how to get started with it.
#007
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.
#006
elm/parser
We discuss parsers, how to build them in Elm, and how to try to make your error messages as nice as Elm's.
#005
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.
#004
JSON Decoders
We discuss the basics of JSON Decoders, benefits compared to JSON in JavaScript, best practices, and how to get started learning.
#003
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!
#002
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.
#001
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.