Rock the Code

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