Episódios
-
Richard Eisenberg is a language designer and compiler engineer for OCaml at Jane Street and a core contributor to the Haskell language. He focuses on static type systems and functional programming to make software more reliable, while maintaining ease of use and runtime efficiency. Richard has also taught various computer science topics to both university and high school students, and he holds a PhD from the University of Pennsylvania.
You can find Richard's work at https://richarde.dev/
---
0:00 Intro
0:56 Teaching CS to high school students
3:20 Turning down Microsoft for a teaching career
8:26 PhD, faculty life, and joining Jane Street
12:32 Algorithms and FP for high schoolers in the age of AI
17:08 How Richard uses LLMs day-to-day
22:29 Jane Street's internal AI experimentation
23:08 OCaml in the age of AI: open sourcing and error messages
29:31 Making illegal states unrepresentable: how far is too far
38:11 Formal verification and LLMs
42:08 Effect handlers in OCaml
44:03 Rust-style ownership and data race freedom in OxCaml
51:06 Why Jane Street chose OCaml
57:54 OCaml vs Haskell: purity, mutability, and physical equality
58:47 Onboarding engineers to OCaml at Jane Street
1:00:01 Hiring for fundamentals, not OCaml experience
1:07:07 Screening for good programming taste
1:10:47 Training vs hiring: the chicken-and-egg problem
1:15:31 Why OCaml hasn't gone mainstream
1:25:08 Dynamic languages: Python, JavaScript, and their place
1:28:15 Rust, C++, Scala: languages Richard finds interesting
1:33:08 Research at Jane Street: papers, peer review, and process
1:36:17 Contributing back to open source ecosystems
1:37:46 Dependent types in Haskell: motivation and the long road -
Sam Newman is an engineer and consultant, specialized in service architecture. He's the author of the books Building Microservices and Monolith to Microservices, and has helped many companies make informed choices about their service architecture. His forthcoming book is Building Resilient Distributed Systems.
You can find Sam on his website https://samnewman.io/.
---
0:00 Intro
0:57 The distributed monolith trap
6:30 Structured programming fundamentals most devs skip
10:00 Why long-lived teams make better architecture decisions
13:33 Building Resilient Distributed Systems: the book
22:00 Three golden rules of distributed systems
22:11 The human side of resilience engineering
35:56 AI's impact on PR workflows and code verification
43:13 Why QAs are making a comeback
47:33 End-to-end testing in microservices architectures
58:21 Containerization, public cloud, and DevOps as microservices enablers
1:03:53 When Sam advises against microservices
1:09:38 Idempotency: retrofitting vs. designing upfront
1:15:21 Trunk-based development vs. the PR process -
Estão a faltar episódios?
-
Daniel Spiewak is known for spearheading Cats Effect, one of the major effect systems in the Scala ecosystem, and for leading Typelevel, a mini-ecosystem of libraries and tools for functional programming in Scala. He's held various senior engineering roles and is currently working for NVidia as a distinguished engineer.
---
0:00 Intro
0:40 Cats Effect 3.7 and Scala Native multithreading
6:26 The integrated runtime: replacing Java NIO on the JVM
12:00 Scala Native vs the JVM for cloud-native workloads
14:00 Scala Native vs Rust: can it compete?
17:58 Popularizing Scala Native with minimal resources
21:04 Agentic coding and Scala's type system advantage
27:59 Where Scala's tooling falls short for AI agents
37:00 Resource lifecycle bugs that fool LLMs
37:44 Daniel's work at NVIDIA on autonomous vehicles
42:24 Capture checking and closing the linearity gap
44:43 What Distinguished Engineers actually do
49:35 How to reach IC7: breadth, communication, and humility
54:16 Holding abstraction and bare-metal performance together
58:00 Functional programming as a mental model for organizations
59:11 How open source shaped Daniel's engineering instincts
1:06:00 The steam engine lesson: technology needs context
1:12:00 Where Scala has room to grow: deployment and DevOps
1:19:57 Unison's big idea and what Scala can learn from it
1:27:06 Starting a foundational Scala project on a shoestring
1:32:42 Mill, Li Haoyi, and the build tool landscape -
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 is a software engineer with more than 20 years of experience, a frequent conference speaker, teacher and author of Elm in Action. He's the author of the Roc programming language and is currently working on Zed, the AI-enabled code editor.
Zed: https://zed.dev/
Roc: https://www.roc-lang.org/
---
0:00 Intro
1:38 Why Rust's borrow checker didn't help Roc's compiler
6:02 Zig vs Rust for Roc: trade-offs in practice
8:29 Why Richard built Roc
13:11 Roc vs Go for web servers
18:02 Roc's error handling: anonymous sum types
19:44 How Roc measures success
23:22 Roc adoption: the startup pathway
29:54 Platforms and applications: Roc's core design
40:33 Security by design: sandboxing dependencies
55:00 Avoiding monads: Richard's FP philosophy
1:02:36 Empathy as a design principle
1:05:04 Teaching FP: don't start with types
1:09:32 Writing Elm in Action: lessons and regrets
1:17:35 Career decisions: startups and red flags
1:30:08 Fundamentals: API design and OOP skepticism
1:40:14 Roc in the age of AI
1:47:24 Vibe coding and software quality
1:54:51 AI agents for bug reproduction in Roc
2:08:09 What drives Richard: people and products -
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 -
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
