Func Prog Podcast

I sit down with Don Syme, the creator of F#! We chat about language design, the "sweet spot" of type system expressivity, and how A.I. will affect the future of software development.

Topics covered:

• The origin story of F#

• Why types, data modeling, and functions beats type-level wizardry
• The Object-Oriented tidal wave of the 90s
• Designing programming languages for the real world
• The case against type classes, and why simpler systems often win in real engineering.
• How task-oriented AI workflows are reshaping developer productivity.
• Why writing good constraints and guardrails may become as important as writing good code.
• Will programming languages still matter?
• Continuous AI for teams
• Natural language as a programming model
  

• 
  
• What Kind of Programming is Natural Language Programming?
• On Natural Language Programming
• The Early History of F#
• Bora's Law
• On Type Classes
• The Max-Abstraction Impulse, and Everything Else Wrong with Type-Level Genericity

In this episode I sit down with Adam Tornhill, founder of CodeScene, to talk about technical debt, Clojure, and why it's so hard to write good software.

Topics covered

• From electrical engineering to software psychology
• Why writing good code is so hard
• The origin story of CodeScene
• What technical debt really is, and why traditional metrics like cyclomatic complexity fall short
• Code health: measuring what makes code hard to understand
• Visualizing code to align engineering and management
• The story behind Your Code as a Crime Scene
• Making the business case for refactoring
• Lean manufacturing vs. software: the visibility problem
• Code quality and business impact (10× slower, 15× more defects)
• AI-friendly code: when LLMs break (and why)
• How technical debt amplifies AI failure rates
• AI as an engineering force multiplier (or multiplier of chaos)
• The future developer: AI team lead?
• Why Adam chose Clojure for CodeScene
• Immutability, REPLs, and iterative problem solving
• Test-driven development as cognitive support
• Performance myths in dynamic languages
• Parallelism made simple with immutability
• The real drawbacks of Clojure
• Static vs dynamic typing in large codebases
• Hiring in niche languages: small pool, strong engineers
• Naming, domain modeling, and long-term code health

Links

• AI-Ready Code: How Code Health Determines AI Performance
• Code Red: The Business Impact of Code Quality
• Your Code as a Crime Scene
• Treat Your Code as a Crime Scene
• Beating the Averages
• CodeScene.com
• AdamTornhill.com

In this episode, I talk to Giacomo Cavalieri, a core Gleam team member. We cover what makes Gleam special and why developers love it, and how it brings modern type safety to the battle-tested Erlang ecosystem. How did Gleam become Stack Overflow's 2nd most admired language in such a short time? Listen to the episode and find out!

Topics Covered

• Gleam's design philosophy of simplicity and the "one way of doing things" approach
• Statically typed functional programming with the Hindley-Milner type system
• How Gleam targets the BEAM VM and JavaScript for full-stack development
• The history of BEAM and OTP
• Who uses Gleam in production
• The Lustre framework for building web applications in Gleam
• Integrating Gleam with OTP
• How Gleam made it to 2nd Most Admired Language in the Stack Overflow 2025 Survey
• How to speak at conferences
• Why Gleam deliberately excludes type classes and traits
• The future of Gleam

Links

• Gleam.run
• Gleam Language Tour
• Gleam Roadmap
• Gleam Case Studies
• Giacomo Cavalieri's Website
• Giacomo's Func Prog Conference Talk
• Giacomo's GitHub
• Giacomo's BlueSky
• Giacomo's Twitch
• Lustre Web Framework
• Gleam OTP Library
• Stack Overflow Developer Survey 2025
• Func Prog Conference
• Code BEAM Europe
• GOTO Copenhagen
• Lambda Days Conference
• Strand Case Study
• Uncover
• The Zen of Python (PEP 20)
• Paul Graham's Blub Paradox

In this episode, I sit down with Robert Kreuzer, co-founder and CTO at Channable, to hear what it's like using Haskell in production. You will hear the story of Channable, and how Haskell worked its way into their code base.

Topics covered:

How Channable got started

How pivoting from their initial idea made Channable a success

Using Haskell in production

What are the pros and cons of using Haskell?

Haskell VS Rust

Hiring for Haskell

Links:

Channable

Channable jobs

The origin story of Haskell at Channable

Effectful

David Christensen - Coding for Types

Robert Kreuzer on LinkedIn

What is the future of Haskell, program generation and AI? I sit down with Matthías Páll Gissurarson and try to figure this out, along with the optimal development setup... and of course, deadlifts!

Topics covered:

Haskell

Typed holes

Using AI for code generation

Lift weights, not just monads

Links:

Starting Strength

Pumping Iron

You come to me at runtime, to tell me the code you are executing does not compile

The Lambda Cube

Ghost in the Haskell

Matthias website

CSI: Haskell

Synthesis and Repair for Functional Programming: A Type- and Test-Driven Approach

The Spectacular paper

PropR: Property-Based Automatic Program Repair

In this episode I talk with Almir Mesic about all things F#! 

We cover topics like:

The advantages of F#

Introducing F# at an C# company

How thinking in functions helps you improve your code

Domain-Driven Design

The “units of measure” feature in F#

Almir has also prepared a special promo code for his course F# Bite-sized!

Use the code FUNCPROG at checkout and you will get a 25% discount.

https://fsbitesized.com/

Links

F# Bite-sized—use the code "FUNCPROG" at checkout for a 25% discount!

Gabriella Gonzalez — “Thinking in Algebras” (Elucidations podcast, Episode 147)

Gary Bernhardt — “Boundaries”

Domain Modeling Made Functional — Scott Wlaschin

Scott Wlaschin — Dependency Injection post

Essential F# — Ian Russell

F# for Fun and Profit — Scott Wlaschin

Mark Seemann — blog

In this episode I talk to Elisabeth Stenholm about dependent types, proof assistans and homotopy type theory! If you're ready to take your type safety to the next level, then this episode is for you!

We cover topics like:

Homotopy type theory

Proof assistants

Languages Rocq, Lean4, Agda, Idris

Proving theorems in Lean4

How to get started with dependent types and proof assistants

Links

• Theorems for free 
• Propositions as types
• Elisabeth’s Func Prog presentation 
• Formally verified C compiler 
• Property-based testing in F#
• Building Idris in Idris 
• Elisabeth's PhD thesis

In this podcast I get down to business with Robert Smith, the creator of Coalton, a language-within-a-language for Common Lisp. We cover a bunch of things, including:

LISP through the years

REPL-driven development (and why you might not always want a REPL attached!)

What makes Common Lisp special

How Coalton brings a powerful, Haskell-like type system to Common Lisp

Writing efficient code without turning your beautiful Common Lisp code into pulp

Had I given my podcasts titles, this one could be called "Much Ado About Macros"

Episode links:

Toward safe, flexible, and efficient software in Common Lisp

Debugging Lisp in space

A Road to Common Lisp

Coalton

Hackett

stylewarning.com

@stylewarning

Hécate is a Haskell engineer and prolific contributor to the Haskell ecosystem—in this episode we talk about using Haskell in production, effect systems and how empathy can help you build better software.

Topics covered:

Effect systems

Effectful

Input validation using validation-selective

Archery

How to get started with Haskell

Links:

Flora

How to write a Haskell program

Effectful

Haskell Programming From First Principles

Finding Success (and Failure) in Haskell

Effect Systems in Practice

Haskell Discourse

In this mind-bending episode I do a deep dive into the world of programming language design and type systems with Aram Hăvărneanu.

We cover a lot of things, including:

The difference between Curry- and Church-style type systems

How types can be used to represent meaning

Set-theoretic types

The limitations of Rust

How fully embracing linear logic opens up new types of program safety

Dependent types

Links:

CUE

Aram's post about Curry-style type systems

Rich Hickey's "Maybe Not" talk

Church VS Curry Types

The Verse Calculus