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
(https://dsyme.net/)
What Kind of Programming is Natural Language Programming? (https://dsyme.net/2025/09/02/what-kind-of-programming-is-natural-language-programming/)
On Natural Language Programming (https://dsyme.net/2025/08/27/on-natural-language-programming/)
The Early History of F# (https://fsharp.org/history/hopl-final/hopl-fsharp.pdf)
Bora's Law (https://chrisbora.substack.com/p/boras-law-intelligence-scales-with)
On Type Classes (https://dsyme.net/2021/09/09/my-position-on-type-classes/)
The Max-Abstraction Impulse, and Everything Else Wrong with Type-Level Genericity (https://dsyme.net/2022/09/01/the-max-abstraction-impulse-and-everything-else-wrong-with-type-level-genericity/)
2 Mar 2026
#16 Adam Tornhill
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 (https://codescene.com/hubfs/whitepapers/AI-Ready-Code-How-Code-Health-Determines-AI-Performance.pdf)
Code Red: The Business Impact of Code Quality (https://arxiv.org/abs/2203.04374)
Your Code as a Crime Scene (https://pragprog.com/titles/atcrime/your-code-as-a-crime-scene/)
Treat Your Code as a Crime Scene (https://www.youtube.com/watch?v=7FApEq8wum4)
Beating the Averages (https://www.paulgraham.com/avg.html)
CodeScene.com (https://codescene.com/)
AdamTornhill.com (https://www.adamtornhill.com/)
30 Jan 2026
#15 Giacomo Cavalieri
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 (https://gleam.run/)
Gleam Language Tour (https://tour.gleam.run/)
Gleam Roadmap (https://gleam.run/roadmap)
Gleam Case Studies (https://gleam.run/case-studies/strand/)
Giacomo Cavalieri's Website (https://giacomocavalieri.me/)
Giacomo's Func Prog Conference Talk (https://www.youtube.com/watch?v=LMrKEaAi4RI)
Giacomo's GitHub (https://github.com/giacomocavalieri)
Giacomo's BlueSky (https://bsky.app/profile/giacomocavalieri.me)
Giacomo's Twitch (https://www.twitch.tv/giacomo_cavalieri)
Lustre Web Framework (https://github.com/lustre-labs/lustre)
Gleam OTP Library (https://hexdocs.pm/gleam_otp/)
Stack Overflow Developer Survey 2025 (https://survey.stackoverflow.co/2025/)
Func Prog Conference (https://funcprogconf.com/)
Code BEAM Europe (https://codebeameurope.com/)
GOTO Copenhagen (https://gotocph.com/2024)
Lambda Days Conference (https://www.lambdadays.org/lambdadays2025)
Strand Case Study (https://gleam.run/case-studies/strand/)
Uncover (https://www.uncover.co/)
The Zen of Python (PEP 20) (https://peps.python.org/pep-0020/)
Paul Graham's Blub Paradox (https://www.paulgraham.com/avg.html)
24 Nov 2025
#14 Robert Kreuzer
Robert Kreuzer from Channable discusses Channable's origin story and explains the pros and cons of using Haskell in production, including comparing it to Rust, in an interview with the host.
31 Oct 2025
#13 Matthías Páll Gissurarson
Host interviews Matthías Páll Gissurarson about the future of Haskell, exploring program generation, AI's role, and optimal development setups.
9 Oct 2025
#12 Almir Mesic
Almir Mesic discusses the advantages of F#, introducing it in C# companies, and how functional thinking improves code, in an interview on functional programming.
25 Sept 2025
#11 Elisabeth Stenholm
Elisabeth Stenholm explores dependent types, proof assistants, and homotopy type theory with the host, revealing how to enhance type safety in programming through formal verification techniques in this interview.
10 Sept 2025
#10 Robert Smith
Host John Doe interviews Robert Smith, creator of Coalton, about Lisp's evolution, REPL development, and Coalton's Haskell-like type system for Common Lisp.
27 Aug 2025
#9 Hécate
Haskell engineer Hécate discusses production Haskell, effect systems, and empathetic software development with the host.
30 Jul 2025
#8 Aram Hăvărneanu
Aram Hăvărneanu explores programming language design and type systems, discussing Curry- versus Church-style approaches, set-theoretic types, and the potential of linear logic for enhanced program safety in this interview.
16 Jul 2025
#7 Eric Torreborre
Eric Torreborre discusses the unique features of the Unison programming language, including its database-centric approach to source code and avoidance of serialization boilerplate, in an interview with the host.
25 Jun 2025
#6 Fernando Borretti
Fernando Borretti, creator of the Austral programming language, discusses the unique features of Austral, including linear types for resource management, and shares insights on programming language creation in an interview with the host.
11 Jun 2025
#5 Sashan Govender
Sashan Govender, a senior developer, discusses the benefits of F#, a language merging functional programming with productivity, power, and pragmatism, in this interview episode.
28 May 2025
#4 Gabriela Moreira
Gabriela Moreira, lead developer of Quint, discusses formal methods and model checkers, highlighting how functional programming offers a different approach to development in an interview.
13 May 2025
#3 Peter (PEZ) Strömberg
Peter Strömberg, aka "PEZ", is a Clojure programmer and creator of the popular Calva plug-in for VSCode. In this episode we do a deep-dive into Clojure and explore the power of Lisp and dynamically typed functional programming.
Topics covered:
REPL-driven development
Data-oriented programming
Lisp and Macros
What makes Clojure special
Popular Clojure libraries
Episode links:
Func prog conf (https://funcprogconf.com/)
Calva (https://calva.io/)
Structure and Interpretation of Computer Programs (https://web.mit.edu/6.001/6.037/sicp.pdf)
Guardrails (https://github.com/fulcrologic/guardrails)
Jank (https://jank-lang.org/)
Babashka (https://babashka.org/)
Squint (https://github.com/squint-cljs/squint)
Malli (https://github.com/metosin/malli)
The Value of Values (https://www.youtube.com/watch?v=-6BsiVyC1kM)
Simple Made Easy (https://www.youtube.com/watch?v=SxdOUGdseq4)
"Just use maps" (https://youtu.be/aSEQfqNYNAc?si=PhPD_dczjvb_8DTv)
Kandria (https://kandria.com/)
GOAL - Game-oriented Assembly Lisp (https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp)
Purely Functional Data Structures (https://www.cs.cmu.edu/~rwh/students/okasaki.pdf)
Paul Graham's Lisp paper (https://paulgraham.com/lisp.html)
David Nolen (https://github.com/readme/stories/david-nolen)
Parens of the Dead (https://www.parens-of-the-dead.com/)
Fred Overflow (https://github.com/fredoverflow/karel)
Christian Johansen (https://github.com/cjohansen)
Easel Editor (https://easel.run/)
30 Apr 2025
#2 Lachezar Yankov
In this episode we do a deep-dive into Scala and Zio with Lachezar Yankov! We talk about how a strong type system can help productivity, what the Zio ecosystem has to offer, and much more...
The appeal of static typing
The pragmatic side of statically typed functional programming
The basics of Zio
Effect Systems
Headline-oriented programming
Episode links:
Lachezar's personal website (https://yankov.se/)
Lachezar's Zio presentation (https://www.youtube.com/watch?v=Fbiu-0mMT0w)
Zio (https://zio.dev/)
Ziverge on YouTube (https://www.youtube.com/c/Ziverge)
Zionomicon (https://www.zionomicon.com/)
Scala Times (https://scalatimes.com/)
16 Apr 2025
#1 Sergei Winitzki
Sergei Winitzki is a functional programming aficinado with a background in theoretical physics. We get into a whole bunch of topics, including:
What makes a good programming language?
Why the future of programming is declarative.
How to design a programming language.
Dhall and System F Omega.
Why recursion is more dangerous than you might think.
Episode links:
The Science of Functional Programming (https://github.com/winitzki/sofp)
Programming in System F⍵ (https://leanpub.com/f-omega)
Alan Kay - Is it really "Complex"? Or did we just make it "Complicated"? (https://www.youtube.com/watch?v=ubaX1Smg6pY)
Beautiful Racket (https://beautifulracket.com/)
The Dhall Configuration Language (https://dhall-lang.org/)
Scall - A Dhall implementation in Scala (https://github.com/winitzki/scall)
Dhall implementation guide (https://github.com/dhall-lang/dhall-lang/blob/master/standard/README.md)
Intro Music: Lofi Rnb Music by SigmaMusicArt (https://pixabay.com/music/beats-lofi-rnb-music-296542/)
Who has been a guest on Func Prog Podcast
Names identified in recent episode analyses. Showing up to five guests.
Robert Kreuzer
Matthías Páll Gissurarson
Almir Mesic
Elisabeth Stenholm
Robert Smith
Reach and audience
Public platform figures. Ratings count people who left a rating, not total listeners.
Spotify
5.0 / 5
8 ratings
Podcast Authority Score: 25 / 100
A composite of feed quality, social presence, YouTube performance and engagement. Read the methodology.
Quality
37
Social presence
0
YouTube
0
Engagement
32
Contact Func Prog Podcast
Guest appearances
Books guests
Based on episode analysis; this does not confirm that the show is currently accepting guests.
Host of Func Prog Podcast?
Claim your podcast to manage its listing and keep your show details accurate.
Pod Engine is an independent podcast discovery and analytics service and is not affiliated with or endorsed by this podcast. Artwork and show content belong to their owners. Full legal notice.
Explore this show Podcast research with Pod Engine
