Robert Martin aka "Uncle Bob" is a software engineer for more than 50 years, and the author of many influential programming books, including Clean Code and Clean Architecture, and one of the founders of the Agile methodology.

He teaches principles of software craftsmanship at https://cleancoders.com/

0:00 Intro
1:04 Uncle Bob's journey into Clojure
5:05 Why Uncle Bob prefers Clojure over Java
8:30 Dynamic vs. static typing
13:08 How TDD replaces type checkers
20:10 Dijkstra's failed dream of provable software
30:20 AI as a co-pilot: the danger of blind trust
43:00 Will AI replace programmers?
56:00 Clean Code principles in the age of AI
1:04:00 Clean Code 2nd edition: what changed
1:13:20 Osterhout's critique of Clean Code
1:17:51 The only way to go fast: craftsmanship
1:21:16 Filtering the churn: spotting old news
1:28:08 Essential books every programmer should read
1:35:54 Don't fear the future
1:37:11 How Uncle Bob developed as a teacher

Jonas Bonér is the founder and CTO of Akka Inc. and creator of the Akka project and the Reactive Manifesto. He's also a Java Champion.

You can find Jonas at http://jonasboner.com

0:00 Intro
2:30 Akka's origin story: 2009 consultancy to open source
9:30 The actor model: message passing, isolation, and fault tolerance
24:10 Supervision hierarchies and location transparency
37:00 Akka modules: Streams, Clustering, and Sharding
51:00 CRDTs, Alpakka, gRPC, and brokerless PubSub
1:03:00 Akka Edge: extending actors to Rust and devices
1:09:30 The Akka platform SDK: from months to days
1:20:30 Event sourcing and CQRS in the Akka SDK
1:27:00 Serverless, bring-your-own-cloud, and self-hosted deploys
1:38:00 BSL license change: survival over ideology
1:46:00 Open-source sustainability and the tragedy of the commons
1:53:00 Agentic AI and the actor model as its backbone
1:58:00 Distributed systems: what engineers still get wrong

Rúnar Bjarnason is a cofounder of Unison Computing, a programming language and environment for distributed systems and applications on the cloud. He's also a coauthor of the famous "red book", aka Functional Programming in Scala (and more recently in Kotlin as well).

0:00 Intro
1:26 Unison's origin and the content-addressed code idea
5:03 Why a new language instead of a Scala framework
8:28 Unison vs. Spark: deployment without infra
13:54 Scaling and remote.fork in Unison Cloud
18:54 Real-world Unison use cases
22:39 Why Haskell for the runtime (and ditching the JVM)
39:19 Dependency management without the hell
49:02 Runar's path: Java refugee to functional programming
59:59 Renaming types without breaking code
1:05:51 Concepts that transfer from Scala to Unison
1:12:21 Why Haskell isn't mainstream
1:21:24 LLMs and Unison: vibe coding vs. intelligent autocomplete
1:25:01 Books, taste, and advice for aspiring programmers

Paul Snively is a software architect and engineer with 40 years of programming experience. He's worked professionally with a variety of languages, tools and mental models, including Lisp, C, Java, Scala and Haskell, and has held various positions at Apple, Intel, VMWare, Verizon and others. He is also a frequent conference speaker, talking about type systems, functional programming, formal logic and reliable software.

You can find Paul at https://paul-snively.github.io/

0:00 Intro
6:30 Language proliferation: Go, Rust, Scala, and corporate bets
10:00 Scala in production: Twitter, Spark, and Databricks
12:10 Go's appeal: consistency over abstraction ceiling
16:10 Runar Bjarnason, Funnel, and the Verizon Labs team
21:50 Kleisli arrows and HTTP4S explained
30:25 Why purely functional programming: expressions all the way down
36:05 Where correctness matters most: finance, avionics, smart contracts
47:45 TypeScript's success: syntax, ecosystem fit, and .d.ts files
58:55 Scala's adoption problem and the abstraction ceiling
1:03:40 Direct style, Ox, Kyo, and lowering the FP on-ramp
1:11:50 How to develop taste and intuition in software
1:20:00 Apprenticeship, stupid questions, and the monad epiphany
1:33:00 Shipping System 7.0 with 1,500 known bugs: Apple and business tradeoffs
1:41:30 OCaml: governance, stability, and Jane Street
1:53:50 ReasonML and language recommendations for beginners
1:57:00 Paradigms over languages: Smalltalk, Prolog, Haskell, C

James Ward is a professional software developer since 1997, with much of that time spent helping developers build software that doesn't suck. He describes himself as a typed pure functional programming zealot who often compromises on his ideals to just get stuff done. He is the author of several programming books, the latest being Effect Oriented Programming. James hosts the Happy Path Programming podcast and is a frequent conference speaker around the world, and he's been recognized as a Java Champion in 2021. He is currently a Developer Advocate for AWS.

0:00 Intro
1:38 Why James wrote Effect Oriented Programming
5:30 From Scala 3 book to Zio book to effects
14:08 What effects actually are
27:02 Typed errors, dependencies, and retry superpowers
40:56 Refactorability, testability, and concurrency with effects
42:56 Zio streams as a quick win
43:56 Career mindset shifts: types and functional programming
52:49 Scala vs Kotlin vs Java type systems
1:01:21 Fringe languages: Unison, Rock, WASM
1:02:04 Algebraic data types + exhaustive pattern matching in Scala 3
1:07:11 EasyRacer: learning concurrency through experiments
1:12:48 Using AI and LLMs for learning unfamiliar languages
1:16:45 The FFT benchmark story: agent vs. profiler
1:23:57 LLMs as copy-paste at scale: the abstractions problem
1:31:17 MCP: what it is and what it could become
1:45:21 Are we at peak AI hype?
1:51:42 Agentic loops, interaction models, and type inference gaps
1:55:57 Skills that still matter: understanding code you didn't write
1:57:31 Formal verification and deriving code from specs
2:02:44 How James finds time to explore so many technologies
2:05:41 CFP submissions as a forcing function for learning

A long-form conversation with Martin Odersky about everything Scala: the evolution of the language, the future, learning, teaching, good library and code design, and more.

0:00 Intro
2:30 Teaching Scala to kids and beginners
6:55 Why recursion trips up new programmers
11:51 Scala as a first language: the evidence from Lund University
13:38 How Martin's students at EPFL learn debugging via the scientific method
16:36 Inside the Scala compiler: phases, tests, and community builds
24:03 The SIP process: from Discord proposal to stable feature
29:03 Scala 3 vs Scala 2: implicits, givens, and extension methods
48:03 Scala's strengths: safety, convenience, and low ceremony
54:30 The complexity trap: effect systems, HTTP4S, and simple Scala
1:03:00 Capabilities: Scala's answer to Rust's borrow checker
1:32:27 Gears: direct-style concurrency with capabilities
1:34:58 Scala's path to mainstream: network effects and the next Spark
1:43:03 Learning Lean and what Martin would steal for Scala