Rock the Code

Daniel Ciocirlan

A podcast about interesting programming topics for the curious software engineer. You will learn about programming languages, tools, libraries, and combinations thereof, from the best in the field.

  1. 5.6. ·  Video

    16 - Richard Eisenberg on OCaml, Effective AI, Teaching FP and Hiring for Fundamentals

    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

    1 t 40 min

  2. 27.5. ·  Video

    15 - Sam Newman on Microservices, Monoliths, and Building Resilient Distributed Systems

    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

    1 t 21 min

  3. 13.5. ·  Video

    14 - Daniel Spiewak on Cats Effect, Underrated Scala, and Becoming a Distinguished Engineer

    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

    1 t 37 min

  4. 16.4. ·  Video

    13 - Simon Peyton Jones on Haskell, Verse, Strong Type Systems and Tasteful Abstractions

    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

    1 t 25 min

  5. 31.3. ·  Video

    12 - Jon Gjengset on Rust Internals, Vibe Coding, and Teaching by Streaming

    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

    1 t 35 min

  6. 12.3. ·  Video

    11 - José Valim on Elixir, AI Tools, Gradual Type Systems, and Being a Prolific Open-Source Contributor

    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

    1 t 54 min

  7. 10.2. ·  Video

    10 - Richard Feldman on Roc, AI, Teaching, and Avoiding Fancy Functional Programming

    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

    2 t 11 min

  8. 14.11.2025 ·  Video

    9 - Haoyi Li on Mill, Scala at Scale, Conference Touring and Moving Up the Stack

    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

    1 t 32 min
Näytä kaikki (16)

Tietoja

A podcast about interesting programming topics for the curious software engineer. You will learn about programming languages, tools, libraries, and combinations thereof, from the best in the field.

Tiedot

  • Tekijä
    Daniel Ciocirlan
  • Julkaisuvuodet
    2 t.
  • Jaksot
    16
  • Luokitus
    Lapsille sopiva
  • Ohjelman sivusto
    Rock the Code

Saatat pitää myös näistä