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

In this episode I chat with Eric Torreborre about all things Unison! Topics covered include:

What makes Unison different from other programming languages

Why putting your source code in a database instead of files might be a good idea

How Unison lets you avoid serialization boilerplate

Why Unison doesn't have monads

Links:

Get tickets for Func Prog Conf!

Scala Stockhom August Meetup

Shoehorning dependency injection into a FP language

Turning Actors Inside-Out

Do We Need Effects To Get Abstraction?

Eric's GitHub Page

Scrap Your Type Classes

In this episode I chat with Fernando Borretti, creator of the Austral programming language. We cover a bunch of different topics, such as:

What makes Austral different from other systems programming languages

Linear types and how they can be used for efficient resource management

How to create your own programming language

Rust for programming language development

The importance of tooling and ecosystem for technology adoption

Rust VS OCaml

Links:

Borretti.me

@zetalyrae

Lessons From Writing A Compiler

Design of the Austral Compiler

Leaving Rust gamedev after 3 years

Game Scripting Mastery

Crafting Interpreters

PLT Redex

How should I read type system notation?

forall X: Calgary

Sashan Govender is a senior developer with more than 20 years in the industry; in this episode we talk about F#, a language that combines functional programming with productivity, power and pragmatism.

Topics covered:

What really matters when it comes to delivering software

The advantages of typed functional programming

Pros and cons of F#

Why some companies might be reluctant to adopt functional programming

Episode links:

What color is your function?

Tony Hoare's CSP paper

Techempower Benchmarks

Expert F# book

Gabriela Moreira is the lead developer of Quint, a modern and executable specification language. We talk about formal methods, model checkers and how learning functional programming is not so much difficult as it is different

Topics covered:

Quint

Formal Methods

TLA+

Leslie Lamport

Model checking

Episode links:

Quint

TLA+

Philip Wadler - Propositions as Types

Gabriela's website

Logic for Programmers

Learn TLA+

Who Builds a House Without Drawing Blueprints?

Peter Alvaro - I see what you mean