#9 Hécate

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 wizardryThe Object-Oriented tidal wave of the 90sDesigning programming languages for the real worldThe 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 teamsNatural language as a programming modelWhat Kind of Programming is Natural Language Programming?On Natural Language ProgrammingThe Early History of F#Bora's LawOn Type ClassesThe 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 coveredFrom electrical engineering to software psychologyWhy writing good code is so hardThe origin story of CodeSceneWhat technical debt really is, and why traditional metrics like cyclomatic complexity fall shortCode health: measuring what makes code hard to understandVisualizing code to align engineering and managementThe story behind Your Code as a Crime SceneMaking the business case for refactoringLean manufacturing vs. software: the visibility problemCode quality and business impact (10× slower, 15× more defects)AI-friendly code: when LLMs break (and why)How technical debt amplifies AI failure ratesAI as an engineering force multiplier (or multiplier of chaos)The future developer: AI team lead?Why Adam chose Clojure for CodeSceneImmutability, REPLs, and iterative problem solvingTest-driven development as cognitive supportPerformance myths in dynamic languagesParallelism made simple with immutabilityThe real drawbacks of ClojureStatic vs dynamic typing in large codebasesHiring in niche languages: small pool, strong engineersNaming, domain modeling, and long-term code healthLinksAI-Ready Code: How Code Health Determines AI PerformanceCode Red: The Business Impact of Code QualityYour Code as a Crime SceneTreat Your Code as a Crime SceneBeating the AveragesCodeScene.comAdamTornhill.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 CoveredGleam's design philosophy of simplicity and the "one way of doing things" approachStatically typed functional programming with the Hindley-Milner type systemHow Gleam targets the BEAM VM and JavaScript for full-stack developmentThe history of BEAM and OTPWho uses Gleam in productionThe Lustre framework for building web applications in GleamIntegrating Gleam with OTPHow Gleam made it to 2nd Most Admired Language in the Stack Overflow 2025 SurveyHow to speak at conferencesWhy Gleam deliberately excludes type classes and traitsThe future of GleamLinksGleam.runGleam Language TourGleam RoadmapGleam Case StudiesGiacomo Cavalieri's WebsiteGiacomo's Func Prog Conference TalkGiacomo's GitHubGiacomo's BlueSkyGiacomo's TwitchLustre Web FrameworkGleam OTP LibraryStack Overflow Developer Survey 2025Func Prog ConferenceCode BEAM EuropeGOTO CopenhagenLambda Days ConferenceStrand Case StudyUncoverThe 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 startedHow pivoting from their initial idea made Channable a successUsing Haskell in productionWhat are the pros and cons of using Haskell?Haskell VS RustHiring for HaskellLinks:ChannableChannable jobsThe origin story of Haskell at ChannableEffectfulDavid Christensen - Coding for TypesRobert 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:HaskellTyped holesUsing AI for code generationLift weights, not just monadsLinks:Starting StrengthPumping IronYou come to me at runtime, to tell me the code you are executing does not compileThe Lambda CubeGhost in the HaskellMatthias websiteCSI: HaskellSynthesis and Repair for Functional Programming: A Type- and Test-Driven ApproachThe Spectacular paperPropR: 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# companyHow thinking in functions helps you improve your codeDomain-Driven DesignThe “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/LinksF# 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 WlaschinScott Wlaschin — Dependency Injection postEssential F# — Ian RussellF# for Fun and Profit — Scott WlaschinMark 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 theoryProof assistantsLanguages Rocq, Lean4, Agda, IdrisProving theorems in Lean4How to get started with dependent types and proof assistantsLinksTheorems for free Propositions as typesElisabeth’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 yearsREPL-driven development (and why you might not always want a REPL attached!)What makes Common Lisp specialHow Coalton brings a powerful, Haskell-like type system to Common LispWriting efficient code without turning your beautiful Common Lisp code into pulpHad I given my podcasts titles, this one could be called "Much Ado About Macros"Episode links:Toward safe, flexible, and efficient software in Common LispDebugging Lisp in spaceA Road to Common LispCoaltonHackettstylewarning.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 systemsEffectfulInput validation using validation-selectiveArcheryHow to get started with HaskellLinks:FloraHow to write a Haskell programEffectfulHaskell Programming From First PrinciplesFinding Success (and Failure) in HaskellEffect Systems in PracticeHaskell 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 systemsHow types can be used to represent meaningSet-theoretic typesThe limitations of RustHow fully embracing linear logic opens up new types of program safetyDependent typesLinks:CUEAram's post about Curry-style type systemsRich Hickey's "Maybe Not" talkChurch VS Curry TypesThe Verse Calculus