spotifyovercastrssapple-podcasts

Hosted by

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

Episodes

#070
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.
#069
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.
#068
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.
#067
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.
#066
September 26, 2022
elm-codegen with Matthew Griffith
Matthew Griffith joins us to discuss elm-codegen, a tool for generating Elm safely and conveniently.
#065
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.
#064
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.
#063
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.
#062
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.
#061
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.
#060
July 4, 2022
Building Trustworthy Tools
We discuss how to earn users' trust by giving meaningful feedback and giving predictable results.
#059
June 20, 2022
Wrap Early, Unwrap Late
We dive into preventing bugs and making your code more maintainable by wrapping early and unwrapping late.
#058
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.
#057
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.
#056
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.
#055
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.
#054
April 11, 2022
Developer Productivity
We share our productivity and workflow tips, and how it changes the way we write Elm code.
#053
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.
#052
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.
#051
February 28, 2022
Primitive Obsession
We discuss the Primitive Obsession code smell, and how introducing types with semantic meaning can improve your Elm codebase.
#050
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.
#049
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.
#048
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?
#047
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.
#046
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!
#045
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.
#044
November 22, 2021
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
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.
#042
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.
#041
October 11, 2021
elm-markdown
We discuss the elm-markdown's approach to extensiblility, the markdown specification, and some advanced uses.
#040
September 27, 2021
Phantom Builder Pattern
Jeroen introduces the phantom builder pattern and how it enables new guarantees in Elm API design.
#039
September 13, 2021
elm-charts
Tereza joins us to talk about building charts in Elm using the new elm-charts package.
#038
August 30, 2021
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
August 16, 2021
Performance in Elm
We talk about performance tuning Elm applications.
#036
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.
#035
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.
#034
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.
#033
June 21, 2021
Accessibility in Elm
Guest Tessa Kelly walks us through some accessibility best practices and how to apply them in Elm.
#032
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.
#031
May 24, 2021
Elm Code Generation
We discuss different use cases for code generation in Elm applications, and our favorite code generation tips.
#030
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.
#029
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.
#028
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.
#027
March 29, 2021
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
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.
#025
March 1, 2021
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
February 15, 2021
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
February 1, 2021
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
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.
#021
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.
#020
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!
#019
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.
#018
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.
#017
November 16, 2020
Codecs
Codecs do two-way Encode/Decode. We talk about this pattern in Elm, and some codec tools for JSON and Bytes.
#016
November 2, 2020
elm-graphql
We talk about elm-graphql, how to organize your SelectionSets, and other best practices.
#015
October 19, 2020
Incremental Steps
We talk about the value of taking small steps, and techniques to help break problems down in Elm.
#014
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.
#013
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.
#012
September 7, 2020
elm-spa
We discuss the benefits that using the elm-spa framework bring to your codebase, and how to get started.
#011
August 24, 2020
Parse, Don't Validate
We discuss the Alexis King's article and how those techniques apply in Elm.
#010
August 10, 2020
elm-test
We discuss the fundamentals of test-driven development, and the testing tools in the Elm ecosystem.
#009
July 27, 2020
elm-ui
We discuss the fundamentals of elm-ui, and how to decide if it's the right fit for your team.
#008
July 13, 2020
The Builder Pattern
We discuss the tradeoffs of using the builder pattern and how to get started with it.
#007
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.
#006
May 25, 2020
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
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.
#004
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.
#003
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!
#002
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.
#001
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.