Rock the Code

Simon Peyton Jones is a computer scientist in the true sense of the word, and the lead designer of the Haskell programming language and the GHC. He's a fellow of the Royal Society and the ACM and has won many awards (including the SIGPLAN award) for his contributions to programming language design. Simon is currently working for Epic Games with the CEO Tim Sweeney on Verse, a programming language that brings functional programming to video games. You can find Simon at https://simon.peytonjones.org/ --- 0:00 Intro 1:42 Origins of type classes in Haskell 7:01 Higher-kinded type variables and the monad surprise 12:31 Tasteful abstractions: when complexity is worth it 18:46 GADTs, higher-rank polymorphism, and OOP connections 23:24 Static vs. dynamic typing: the real case for types 27:18 Laziness, purity, and the IO monad 32:46 What mainstream languages should steal from Haskell 39:41 Subtyping vs. parametric polymorphism 44:31 Verse: types as functions and expressions as patterns 52:32 Verse's mathematical ambitions and Tim Sweeney 57:30 LLM-generated code and the limits of verification 1:04:01 Property-based testing as practical verification 1:08:20 Teaching CS fundamentals to children 1:14:39 Juniors, seniors, and AI in the workforce 1:23:07 Immutability changes everything

Jon Gjengset is a long-time Rust programmer and educator and the author of Rust for Rustaceans, a book on idiomatic Rust programming for experienced developers. You can find Jon and his work at https://thesquareplanet.com/ --- 0:00 Intro 1:00 Vibe coding in Rust: safer or more dangerous? 3:54 Jon's two-week LLM immersion experiment 6:55 When LLMs save time vs. waste it 10:10 Avro IDL transpiler: a perfect LLM task 14:30 Building a Touch Portal plugin with LLM help 16:10 Developing an intuition for LLM delegation 17:18 Unlearning OOP habits in Rust 22:20 Rust's opinionated design and error messages 26:02 Common anti-patterns from newcomers to Rust 28:40 Traits, type classes, and why not OOP 32:47 Unsafe Rust: hygiene, MIRI, and Loom 39:43 Polonius: the next borrow checker 46:31 Rust's narrow standard library — intentional restraint 52:46 Origin of Rust for Rustaceans 57:58 Writing dense, timeless technical prose 1:02:23 Teaching Rust in 10 hours 1:07:32 Rust as a first programming language 1:10:48 Comments as the most important code 1:18:57 Writing comments before the code 1:23:31 Getting unstuck live on stream 1:28:46 Impl Rust vs. Crust of Rust vs. Decrusted 1:30:45 Languages Jon would explore if not Rust 1:32:15 Advice for Scala developers on trying Rust 1:34:10 Recommended books for programmers

José Valim is the creator of the Elixir programming language and cofounder of Dashbit, where he focuses on growing the Elixir ecosystem, the Tidewave web AI agent, and Livebook, a Jupyter-style notebook for Elixir. Before creating Elixir, he cofounded Plataformatec (acquired by Nubank) and was a core Ruby contributor. Elixir language: https://elixir-lang.org/ Dashbit: https://dashbit.co/ Tidewave AI: https://tidewave.ai Livebook: https://livebook.dev --- 0:00 Intro 1:32 Elixir 1.20 type inference: what's new 9:15 Gradual typing vs TypeScript's approach 15:03 Typing existing Elixir code without breaking it 19:35 Set-theoretic types vs Hindley-Milner 25:06 Developer happiness: tooling and documentation 34:48 Elixir adoption: growth and decentralization 39:21 Origins: falling in love with the BEAM 45:09 Dashbit: small team, big ecosystem impact 49:18 Enabling open-source contributors 57:11 José's planning and productivity habits 1:00:20 Open source sustainability and burnout 1:08:04 NX and Elixir for machine learning 1:17:16 Elixir vs Python in the age of AI agents 1:23:28 Marketing Elixir to developers 1:29:29 Teaching as a core skill 1:34:05 BEAM vs JVM: concurrency and fault tolerance 1:43:33 Akka, virtual threads, and the BEAM scheduler 1:50:54 Where to start with Elixir

Richard Feldman, software engineer and language creator behind Roc and contributor to Zed, shares his design philosophy and teaching approach. He discusses why he built Roc, trade-offs vs Rust, Zig, and Go, and Roc’s platform and sandboxing ideas. He talks about avoiding fancy FP jargon, teaching practical FP without starting with types, and how AI and agents fit into tooling and workflows.

Haoyi Li is a software engineer and a core contributor to the Scala ecosystem. He's built a whole suite of Scala libraries under the com.lihaoyi banner, focusing on simplicity and productivity, as well as the Mill build tool, which he has since expanded beyond Scala to support other JVM tools like Java and Kotlin and experimental support for other things like TypeScript and Android, and promises better performance and user friendliness than Gradle and Maven can ever match. He's also the author of the book Hands-on Scala Programming, which focuses on getting things done with Scala. You can find Mill at https://mill-build.org/ My own course, Scala Projects, uses Haoyi's book examples as starting points for full-fledged, shippable projects that you can use for yourself or turn into products: https://rockthejvm.com/courses/scala-projects --- 0:00 Intro 1:14 The 45-conference sabbatical tour 4:55 In-person feedback vs. shouting into the void 8:38 Mill's current development process 11:00 Mill beyond Scala: targeting Java and Kotlin 14:05 Why build tools terrify developers 17:07 Mill's YAML config format 22:24 Scala at Databricks: using one language everywhere 26:17 Fast Scala onboarding: no Akka, no CATS, no ZIO 29:04 Scala vs Kotlin, TypeScript, and Go today 30:12 What Scala actually needs: IDE support and a simpler stack 35:56 The async obsession Scala needs to drop 43:10 IC to manager and back: the cost of remote leadership 50:26 From EverQuest XML mods to Scala 1:02:24 Maintaining a library ecosystem without burning out 1:03:30 Open-sourcing Hands-on Scala Programming 1:07:45 Self-publishing the book: pipeline, printing, and margins 1:13:09 Rewriting the book: dropping Quill, evolving Ammonite 1:15:33 Vibe-coding contributions to the Scala compiler 1:22:17 Moving up the stack: engineers in the AI era 1:27:12 The fun of wrangling half-baked code 1:31:38 Haoyi's message to Scala developers

Grady Booch is one of the pioneers of modern software architecture as a distinct discipline of software engineering. He has 50+ years of experience and has developed software for every conceivable domain, has authored 7 books and is the co-creator of the UML design language. His latest ongoing work is a documentary called Computing - The Human Experience: https://computingthehumanexperience.com/ --- 0:00 Intro 1:25 Computing: The Human Experience documentary 4:58 Why computing history matters today 10:00 AI fear-mongering: then vs. now 15:00 Computing as a tool for subjugation 17:12 Grady's influences: Sagan, Feynman, Campbell 20:39 Debate class to keynote stage: Amarillo origins 24:30 Grady's writing and lecture process 34:54 Gang of Four patterns: warranted criticism 39:40 Developing good architectural taste 43:00 Reading great code: MacPaint, Photoshop, Linux 48:00 Idioms, patterns, and architectural styles 53:00 Where formal methods actually matter 57:00 Python and JavaScript in production systems 59:37 LLM-generated code: security holes and fragility 1:05:00 AI overhype and the FOMO trap 1:16:27 LLMs as statistical systems, not truth machines 1:18:12 Human truth vs. LLM statistics 1:24:46 Optimism for software engineers in the AI era 1:25:40 Clear and present dangers: bias automation

John De Goes is a software engineer recognized in the Scala ecosystem for the ZIO effect system. He's the founder of multiple companies, including Ziverge and Golem Cloud, and the producer of the show The Ultimate Coder. He's also a frequent conference speaker, writer and mentor. --- 0:00 Intro 1:45 The Ultimate Coder: humans vs AI in API design 6:26 Judging criteria: expressiveness, type safety, developer joy 12:04 Why TypeScript over Scala 15:00 Making programming entertaining 19:00 AI killing developer education 25:20 Uncle Bob's abstraction argument vs AI 30:15 AI as a new programming abstraction layer 42:09 How John uses AI: test generation and boilerplate 49:00 Adapting education and MCP servers for AI-first devs 57:04 Skills worth doubling down on in the AI era 1:06:18 Vibe coders vs senior engineers: the kill order 1:16:18 Retaining top engineers as a founder 1:25:43 Leverage and synergy across open source, companies, and talks 1:34:30 Zio's origin: eating the pain of async, concurrency, and errors 1:41:53 Internal complexity and rewrites in Zio Streams 1:46:25 Effect system proliferation: Zio, Cats Effect, Kyo, Effect TS 1:50:30 The three legs of Zio: async, concurrency, error management 1:58:53 Will effect systems ever go mainstream? 2:06:34 AI favoring typed, structured code 2:13:00 John's process for crafting conference talks 2:15:14 Education, inspiration, and entertainment in talks 2:17:54 How to become a more fluent speaker

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