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:
You come to me at runtime, to tell me the code you are executing does not compile
Synthesis and Repair for Functional Programming: A Type- and Test-Driven Approach
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.
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” (talk)
Domain Modeling Made Functional — Scott Wlaschin (book)
Scott Wlaschin — Dependency Injection post
Essential F# — Ian Russell (book)
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
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
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:
How to write a Haskell program
Haskell Programming From First Principles
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:
Aram's post about Curry-style type systems
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!
Shoehorning dependency injection into a FP language
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:
Lessons From Writing A Compiler
Design of the Austral Compiler
Leaving Rust gamedev after 3 years
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:
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:
Philip Wadler - Propositions as Types
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:
Structure and Interpretation of Computer Programs
GOAL - Game-oriented Assembly Lisp
Purely Functional Data Structures
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:
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
Alan Kay - Is it really "Complex"? Or did we just make it "Complicated"?
The Dhall Configuration Language
Scall - A Dhall implementation in Scala
Intro Music: Lofi Rnb Music by SigmaMusicArt
