We discuss Elm's strengths and weaknesses for optimizing bundle size, and how find and fix your app's bundle size bottlenecks.

Wolfgang Schuster joins us to discuss generating type-safe SDKs using elm-open-api.

Andrew MacMurray joins us to discuss `elm-concurrent-task` which allows you to run JavaScript functions with a Task style API.

Jakub Hampl joins us to discuss elm-visualization and how it enables powerful flexibility through its low-level building blocks philosophy.

Wolfgang joins us to discuss his philosophy and approach to sharing what's new in the Elm community.

We discuss Code Reading Club, how improving your code reading skills can make you a better programmer, and the readability of Elm code.

We discuss elm-land, how it compares to elm-spa, and its philosophy of making Elm mainstream.

We discuss the role of Open Source Software and how we approach leadership and communication in our projects.

We discuss how to avoid unused Elm code, why it matters, and what leads to unused code in the first place.

Mario walks us through how Evergreen gives you type-safety between versions of your application, and some improvements in Lamdera 1.1.0.

We discuss the new elm-pages v3 release and the new suite of features for full-stack server-side rendered Elm.

We discuss our backstories, our core values and beliefs as developers, and why Elm speaks to us.

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.

We discuss elm-review's Data Extractors and how they open up your elm-review context to external tools like data visualizations.

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.

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.

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.

We discuss the benefits of automating your Elm boilerplate, and design techniques for APIs that generate code.

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.

Simon Lydell joins us to talk about a new approach to URL parsing in Elm that is both simple and powerful.

Lindsay Wardell joins us to talk about Vite and how to set it up for your Elm project.

We discuss elm-pages BackendTasks and how to run them as scripts with a single command.

Georges Boris joins us to share two new packages for theming and stateless widgets with minimal boilerplate.

We discuss what makes Elm's security vulnerability surface area smaller, and what frontend security considerations are important in Elm apps.

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.

We discuss deliberate practice and how it can help you hone your craft, and make you even better at using Opaque Types.

Matthew Griffith joins us to share his new type-safe GraphQL tool, and to compare the query builder and query generator approaches.

We discuss the role of types versus tests, and whether they complement each other or make the other obsolete.

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.

We discuss how betting on Elm has paid off at Vendr and get a CTO's perspective on using Elm at scale.

Matthew Griffith joins us to discuss elm-codegen, a tool for generating Elm safely and conveniently.

Simon Lydell joins us to discuss his new Elm dev server which has a minimalist philosophy and maximal refinement.

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.

We explore false positives and negatives in static analysis tools, and how Elm helps us avoid them.

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.

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.

We discuss how to earn users' trust by giving meaningful feedback and giving predictable results.

We dive into preventing bugs and making your code more maintainable by wrapping early and unwrapping late.

Martin Janiczek joins us to discuss a pattern for declaratively managing loading state for API data across page changes.

Martin Stewart joins us to share the results from the State of Elm 2022 and look at some of the trends.

Georges Boris joins us to discuss elm-book and how it helps iterate on a design language of Elm widgets.

We discuss what it means to use the web platform, and how that helps improve the user and developer experience in Elm apps.

We share our productivity and workflow tips, and how it changes the way we write Elm code.

We discuss how to remove dead code in Elm, or avoid it altogether in your workflow, and why it matters.

Joël Quenneville joins us to help us distill down Category Theory patterns and explore what value it brings us as Elm developers.

We discuss the Primitive Obsession code smell, and how introducing types with semantic meaning can improve your Elm codebase.

Ju Liu joins us to share some tips and techniques from working with a large Elm codebase at NoRedInk.

We talk about Robin's work optimizing Elm, and the opportunities that remain for Elm performance improvements.

What do we really mean when we say "if it compiles it works?" And how do we make sure our apps stay that way?

We look at what we can learn by understanding what's working well for Elm and the Elm ecosystem.

Some Elm friends visit for a Family Feud-style game. Plus a special Holiday roundtable to close out the year!

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.

Using Elm at work means teaching Elm. We learn some tips from Richard on how to introduce people to new Elm concepts.

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.

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.

We talk about performance tuning Elm applications.

elm-pages v2 is here! We discuss the latest features, including pulling in data with the new DataSource API.

Ryan Haskell-Glatz joins us to discuss the latest version of elm-spa, including authenticated pages and the updated file-based router.

We share what we've learned from designing Elm APIs and how it applies when building applications and tools.

Guest Tessa Kelly walks us through some accessibility best practices and how to apply them in Elm.

Guest Joël Quenneville shares his wisdom on transforming and mapping in Elm, and how it applies across many Elm data types.

We discuss different use cases for code generation in Elm applications, and our favorite code generation tips.

We talk about our favorite debugging techniques, and how to make the most of Elm's guarantees when debugging.

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.

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!

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 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.

We revisit elm-review with some tips, useful workflows, and helpful packages that have come out since our intro to elm-review episode.

Some Elm friends visit for a Family Feud-style game. Plus a special Holiday roundtable to close out the year!

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 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.

We talk about the value of taking small steps, and techniques to help break problems down in Elm.

We revisit Evan's classic talk and dive into the process for how and when to split out Elm code into modules.

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.

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.

We discuss the tradeoffs of using the builder pattern and how to get started with it.

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.

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.

We discuss the basics of JSON Decoders, benefits compared to JSON in JavaScript, best practices, and how to get started learning.

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!

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.

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.