Happy Path Programming
No-frills discussions between Bruce Eckel and James Ward about programming, what it is, and what it should be.
Episodes
#120 Aver AI-Native Programming Language with Szymon Teżewski
We dive into the new Aver programming language with its creator, Szymon Teżewski: The AI-native language where code explains itself.Aver is a language where every function carries its intent, side effects are visible in the type system, and tests are executable specs next to the code. The optimization target is the reviewer, not the generator.Resources:- Aver: https://averlang.dev/- Agent Language
#119 FP Reaches the Masses with Paul Snively
We chat with Paul Snively (https://x.com/JustDeezGuy) about how Functional Programming has gone mainstream.Resources- Winter Tech Forum - https://www.wintertechforum.com- Paul Snively's LambdaConf Talk on Verse - https://www.youtube.com/watch?v=VBT0j14rn5c- Paul Snively's Blog Post on the Verse Calculus - https://paul-snively.github.io/posts/2022-12-15-verse-calculus.html- Eugenio Moggi, &
#118 Effects of 2025
Bruce & James recap the technology shifts of 2025 and look ahead to what may be ahead in 2026.Resources:Register for the Winter Tech Forum (March 2-6 2026 in Crested Butte, Colorado)The Eternal Return of Abstraction: Why Programming Was Never About CodeThinking in Typesjavadocs.devWhat's New in EmbabelDiscuss this episode: discord.gg/XVKD2uPKyF
#117 Special Episode: Entering Computer Science as a New Graduate
At Western State Colorado University in Gunnison on Sept 11, 2025, Bruce Eckel, Bill Venners and Dianne Marsh each give their own 10-minute perspectives on finding fulfillment in the field, especially considering the impact of AI and other recent changes in computing. The remainder of the session answers questions from the student audience.Discuss this episode: discord.gg/XVKD
#116 Infrastructure as Effects with Sam Goodwin
Infrastructure as Code (IaC) is "code" but without most of the benefits of being code. Sam Goodwin is reinventing IaC with Alchemy and an upcoming Alchemy Effect project which aims to manage infrastructure dependencies & provisioning in the same way we manage requirements in Effect Oriented Programming.Discuss this episode: discord.gg/XVKD2uPKyF
#115 More Python Type Checking! Pyrefly with Aaron Pollack & Steven Troxler
Excitement around Python type checking continues to grow and the tools continue to evolve. We chat with Aaron Pollack and Steven Troxler about Pyrefly - a Rust-based Python type checker and IDE extension. We also touch on the adoption and sentiment around types in Python's ecosystem.Resources:Pyrefly DiscordPackage Type Coverage ReportPackages being tracked for moving types from typeshed to t
#114 ty: Fast Python Type Checking with Carl Meyer
Carl Meyer works on the ty Python type checker, built in Rust by Astral the creators of Ruff and uv. We chat about type systems, the evolution of static typing in Python, and the focus on performance.Resources:Richard Feldman: Roc compiler moving from Rust to ZigDiscuss this episode: discord.gg/XVKD2uPKyF
#113 Graph & RAG with Jennifer Reif
We chat with Jennifer Reif about integrating LLMs with data using RAG, vectorized data, and Graph databases.Discuss this episode: discord.gg/XVKD2uPKyF
#112 AI Agents Get More 9's with Rod Johnson
Rod Johnson, creator of the Spring Framework, has created a JVM-based AI Agent framework called Embabel. We dive in and learn how enterprises can build more reliable Agents using deterministic planning and domain-driven orchestration.Discuss this episode: discord.gg/XVKD2uPKyF
#111 Wasm & MCP with Steve Manuel
We chat with Steve Manuel (of dylibso.com and mcp.run) about LLM "plugins" with Wasm & MCP (Model Context Protocol).Discuss this episode: discord.gg/XVKD2uPKyF
#110 Unlocking Developer Productivity with Justin Reock
Justin Reock has spent a lot of his career thinking about how to help developers be more productive. In this episode we learn about the methodologies that can help developers spend more time in "flow state" - happily coding the fun stuff. Further reading: Measuring developer productivity with the DX Core 4 Discuss this episode: discord.gg/XVKD2uPKyF
#109 AI, LLMs, and MCP with Lize Raes
Lize Raes teaches us about AI models, LLMs, Tools, Agents, and MCP.Article from Anthropic on Agent architectures: Building effective agentsDiscuss this episode: discord.gg/XVKD2uPKyF
#108 Winter Tech Forum and Current Projects
Join us at the 2025 Winter Tech Forum! www.wintertechforum.com
Projects Mentioned:
uv for Python
TypeScript Effect
Pkl CloudFormation Extras
Pkl GitHub Actions
Other Episodes Mentioned:
#81 TypeScript & Effects with Michael Arnaldi
#97 The Pkl Configuration Language with Philip Hölzenspies
#107 The Joy of Programming with Dave Thomas
We chat with Dave Thomas, co-author of The Pragmatic Programmer, about the joy of programming and the tensions between our and others needs.
Discuss this episode: discord.gg/XVKD2uPKyF
#106 Agile Organizations with Jutta Eckstein
Jutta Eckstein is expanding the concepts of Agile to be a company-wide model, instead of a niche process for software developers. We chat with her about the book "Company-wide Agility with Beyond Budgeting, Open Space & Sociocracy" which she co-authored on this subject. For more details on the book and many free resources, see: www.agilebossanova.com
Discuss this episode: discord.
#105 Nathan Sobo's Pursuit of the Ultimate Code Editor
Nathan Sobo is co-founder of Zed, a super-fast, collaborative, AI-powered, code editor. We chat about his journey to build the ultimate code editor: lessons learned from building Atom, Electron and its challenges, CRDTs, Rust native GPU GUIs, AI Code Assistants, and more CRDTs.
See also:
Nathan on the Software Unscripted podcast
Discuss this episode: discord.gg/XVKD2uPKyF
#104 Effect Oriented Programming: The Book
After 4 years in development, our book is out! Along with our friend and lead-author, Bill Frasure, we we discuss the book, its motivation and the process we used to create it. Now available in digital and print forms at: effectorientedprogramming.com
At the end of the episode we step into the "twilight zone" with a 7 minute NotebookLM AI-generated podcast based on the book.
Discuss this episode:
#103 AI Augmented Programming with Stephan Janssen
Stephan Janssen is always on the bleeding edge of both helping developers grow and with how he uses technology to accomplish amazing things. He led the creation of Devoxx but is a coder at heart. Stephan shares his journey with AI, both as a "library" in his applications and also as an "assistant" that helps him iterate and program more quickly.
Resources:
DevoxxGenie Intel
#102 Gathering Nerds and Java Gatherers with Venkat Subramaniam
We chat with Venkat about his upcoming dev2next conference and the new Stream Gatherers API (preview in JDK 22).
Discuss this episode: discord.gg/XVKD2uPKyF
#101 Effects and Local-First with Johannes Schickling
Johannes Schickling (@schickling | schickling.dev) gets us up-to-speed on Effect, the ZIO-inspired Effect System for TypeScript, and the Local-First movement. Resources:
Local-First Podcast: www.localfirst.fm
Ink & Switch's Local-First Essay: www.inkandswitch.com/local-first
Effect (TypeScript Library): effect.website
Riffle research project: riffle.systems
LiveStore: github.com/
#100 Thinking about Thinking with Diana Montalion
Diana Montalion teaches us about Systems Thinking and why it matters for those of us building software. Diana is founder of Mentrix, which teaches "systems architecture skills for an increasingly complex world."
Pre-Order Diana's book: Learning Systems Thinking: Essential Nonlinear Skills and Practices for Software Professionals
Discuss this episode: discord.gg/XVKD2uPKyF
#99 The Agile Illusion with Trond Hjorteland
We chat with Trond Hjorteland about Agile and why it hasn't led to successful outcomes in many traditional organizations.
Mentioned and related resources:
Trond & João Rosa's training on Agile + DP2
Open Systems Theory
LinkedIn Group for Open Systems Theory
More material on Open Systems Theory
Resource List from Trond
Some of Trond's recorded talks
#98 Continuous Deployment with Valentina Servile
We chat with Valentina Servile about her upcoming book on Continuous Deployment and reducing the risks to keeping HEAD not just always deployable, but automatically deployed to production.
Book for preorder on Amazon: Continuous Deployment: Enable Faster Feedback, Safer Releases, and More Reliable Software
Discuss this episode: discord.gg/XVKD2uPKyF
#97 The Pkl Configuration Language with Philip Hölzenspies
We chat with Philip Hölzenspies, one of the maintainers of the new Pkl configuration language (pkl-lang.org).
Resources:
James' Pkl for GitHub Actions: github.com/jamesward/pklgha
Discuss this episode: discord.gg/XVKD2uPKyF
#96 Compassionate Coding with April Wensel
We chat with April Wensel, founder of Compassionate Coding, about helping programmers bring more compassion to themselves and others.
Resources:
Confessions of a Recovering Jerk Programmer
Marshall Rosenberg - Nonviolent Communication
Kristin Neff - Self-Compassion
Karen Armstrong - Twelve Steps to a Compassionate Life
UC Berkeley Greater Good Science Center definition of compassion
Ore
#95 21st Century Databases with Gwen Shapira
We chat with Gwen Shapira, co-founder of Nile, about her journey to creating a virtualized, serverless Postgres database service. We also dive into the challenges with traditional data architectures and approaches like ORMs.
Discuss this episode: discord.gg/XVKD2uPKyF
#94 Build Ops & Developer Productivity With Trisha Gee
We chat with Trisha Gee about Test Driven Development (TDD), flaky tests, ops & observability for builds, and developer productivity.
Mentioned TDD Article:
The beautiful theory of TDD and the reality check of practice
Discuss this episode: discord.gg/XVKD2uPKyF
#93 Nerd Sniping via the 1B Row Challenge with Gunnar Morling
When Gunnar Morling announced the 1 Billion Row Challenge a few weeks ago, he had no idea it'd go crazy viral.
Resources:
Challenge details: www.morling.dev/blog/one-billion-row-challenge
Rust 1BRC Blog: aminediro.com/posts/billion_row/
Cliff Click's implementation walkthrough: www.youtube.com/watch?v=NJNIbgV6j-Y
James' very slow Scala ZIO implementation: github.com/jamesward/1b
#92 Virtual Threads Looming with Adam Warski
We chat with Adam Warski about Loom, Virtual Threads, and his Loom-based Scala library, Ox, for structured concurrency & Go-Like Channels.
Referenced articles & code:
Ox EasyRacer Client
Go statement considered harmful
Go-like selects using jox channels in Java
Limits of Loom's performance
Fast and Scalable Channels in Kotlin Coroutines
Discuss this episode: https://discord
#91 'Tis The Season For Reducing Gradle Friction
Announcing Graboo, a collection of experiments to reduce friction with Gradle. Repo:
https://github.com/jamesward/graboo
Buy your Happy Path Programming Shirt:
https://happy-path.printify.me/products
Discuss this episode: https://discord.gg/nPa76qF
#90 The Best Manager with Sushila Sahay
Most of us have managers but they aren't always great. We chat with James' best manager, Sushila Sahay, about what makes her such a great manager. We also dive a bit into open source business models since Sushila has deep experience in that realm.
Discuss this episode: https://discord.gg/nPa76qF
#89 Algebraic Effects with Kyo (Flavio Brasil)
We learn about Algebraic Effects with the Scala library Kyo ( getkyo.io) from the creator, Flavio Brasil.
Discuss this episode: https://discord.gg/nPa76qF
#88 Developers Thriving In the Flow with Arty Starr
Arty Starr is a PhD student and entrepreneur focused on helping developers thrive. We chat about her research on developer momentum and ways that developers can find joy through more time in the flow state.
Referenced resources:
SpringOne Talk
Arty's Idea Flow Book
FlowInsight
Discuss this episode: https://discord.gg/nPa76qF
#87 Diving Deeper into Wasm with Zalim Bashorov
Zalim Bashorov (@bashorov) works on Kotlin/Wasm at JetBrains and answers our many questions about Wasm, GC, the Component Model, and other future proposals.
Discuss this episode: https://discord.gg/nPa76qF
#86 The Journey to OCaml with Sabine
Sabine went from acedemia and a PhD in formal methods, to Python, Elm, Haskell, and now OCaml. We chat about this journey and some of the reasons why OCaml is an awesome modern language.
Discuss this episode: https://discord.gg/nPa76qF
#85 Scala, Rust, and Durable Computing with John De Goes
Our chat with John De Goes starts with his Scala & Rust journeys, then goes into Golem Cloud, a serverless durable computing platform underpinned by Wasm, and ends with a discussion about whether business applications really need parallelism.
Discuss this episode: https://discord.gg/nPa76qF
#84 Inevitable Failure with Dormain Drewitz
We chat with Dormain Drewitz about failure and reliability. Ironically our recording software crashed near the end of the episode but we recovered and wrapped things up.
Referenced Article: 10 Years of Failure Friday at PagerDuty: Fostering Resilience, Learning and Reliability
Discuss this episode: https://discord.gg/nPa76qF
#83 Rust Developer Retreat & Structured Concurrency
At the Rust Developer Retreat we explored Structured Concurrency with Tokio. With the attendees we chat about our projects and things learned, liked, and disliked about Rust. Then dive into Structured Concurrency generally and specific implementations.
Discuss this episode: https://discord.gg/nPa76qF
#82 The Future of Programming
Bruce and James chat about the future of programming.
Discuss this episode: https://discord.gg/nPa76qF
#81 TypeScript & Effects with Michael Arnaldi
Michael created Effect, a functional effect system inspired by Scala ZIO, for TypeScript. We chat about Functional Programming, the TypeScript language, and Effects.
Discuss this episode: https://discord.gg/nPa76qF
#80 Investing in Developer Tools with Renee Shah
Renee Shah is a partner at Amplify Partners, an early stage venture capital firm. We discuss some broad industry trends: Edge, Wasm, Distributed Systems, Functional Programming, and much more!
Discuss this episode: https://discord.gg/nPa76qF
#79 Domain-Driven Design and Moduliths with Oliver Drotbohm
We chat with Oliver Drotbohm about what Domain-Driven Design is and how it might intersect with Microservices, Monoliths, or Moduliths. Mentioned resources:
Parnas on modularity
Chris Richardson – Introducing Assemblage - a microservice architecture definition process
Spring Modulith Project
Introducing Spring Modulith
Discuss this episode: https://discord.gg/nPa76qF
#78 Immutability & IDLs for Declarative Services with Jakub Kozłowski
First a short rant about mutability followed by learning about Smithy, an Interface Description Language (IDL), with Jakub Kozłowski.
Discuss this episode: https://discord.gg/nPa76qF
#77 Quarkus and Microservices with Holly Cummins
Holly Cummins, a Senior Principal Software Engineer on Quarkus at Redhat, joins us to chat about Microservices and Quarkus.
Discuss this episode: https://discord.gg/nPa76qF
#76 WebAssembly (Wasm) "The Web Finds a Way" with Vivek Sekhar
WebAssembly (Wasm) finds a way for the web to move forward to near-native performance while avoiding the limitations of JavaScript. In this episode we chat with Vivek Sekhar, a product manager on the Chrome team, about all the Wasm things and how they relate to a better foundation for cross-platform, high performance apps, in the browser, on the cloud, and maybe just everywhere.
Discuss this
#75 Haskell "Not as Scary as You Think" with Kris Jenkins
We learn the motivations behind Haskell and why it is the pinnacle of Functional Programming from Kris Jenkins, a Developer Advocate at Confluent.
Discuss this episode: https://discord.gg/nPa76qF
#74 Developer Joy = Developer Productivity with Justin Reock
Developer Productivity Engineering (DPE) is a set of tools & practices that help engineers be more productive. We chat with Justin Reock, field CTO at Gradle, about why more organizations need DPE and what that really means. Learn more at: https://gradle.com/developer-productivity-engineering/
Discuss this episode: https://discord.gg/nPa76qF
#73 Nix - Functional Programming for Software Packaging with Domen Kožar
After being told many times that Nix is all we dream for when it comes to software packaging, we finally chat with Domen Kožar and learn all about Nix.
Discuss this episode: https://discord.gg/nPa76qF
#72 Pants Makes Developers Happier & More Productive with Benjy Weinberger
The Pants build tool is polyglot (Python, Java, Kotlin, Scala, Go, etc) and focused on helping developers be more productive and happier. We chat with a co-creator of Pants, Benjy Weinberger, about the history, motivations, and future of the build tool.
Discuss this episode: https://discord.gg/nPa76qF
#71 Functional Programming in Kotlin with Simon Vergauwen (Sorry about the terrible audio)
Simon Vergauwen shares about Arrow, a collection of Functional Programming libraries for Kotlin. Sincere apologies for Bruce & James' bad audio. We forgot to change our input device but figured we'd still publish this as it is tolerable and Simon has so much good stuff to say. (His audio is great)
Discuss this episode: https://discord.gg/nPa76qF
#70 Understanding Software Through Bees & Biology With Grace Jansen
Grace Jansen joins us to chat about how bees and biology can help us better understand software development tools & paradigms like Reactive, Kubernetes, and maybe parts of the 15 Factor App methodology (a modernized version of the Twelve-Factor App methodology).
Discuss this episode: https://discord.gg/nPa76qF
#69 Polymorphism Unbound
Bruce continues his archaeological dig into the foundations of mainstream programming.
Referenced blog: Why Are There Functions?
Discuss this episode: https://discord.gg/nPa76qF
#68 The End of Ivory Tower Architecture with Andrew Harmel-Law
Andrew Harmel-Law shares a better way to make decisions in software teams using the "Advice Process" which he has used in a number of teams resulting in happier, more productive programmers.
Discuss this episode: https://discord.gg/nPa76qF
#67 Swallowed by a Python with Luciano Ramalho
Finally Bruce gets a whole episode about Python with our friend Luciano Ramalho, author of Fluent Python. In the words of Luciano:
"Thanks James and Bruce for the most enjoyable podcast panel I ever had!"
Discuss this episode: https://discord.gg/nPa76qF
#66 The Journey to Rust with Christopher Hunt
No doubt that Rust is hot right now. We chat with Christopher Hunt about his journey through Java, Scala, and many other languages and learn why he is now using Rust.
Discuss this episode: https://discord.gg/nPa76qF
#65 Rod's Gambit - Spring, Scala, TypeScript, and Chess with Rod Johnson
Rod Johnson (creator of Spring Framework) reflects on his programming and chess journeys.
References:
ScalaDays 2013 Talk
Stockfish Chess Engine
Discuss this episode: https://discord.gg/nPa76qF
#64 Building Build Tools is Hard with Josh Suereth
Bruce and James often rant about build tools but it turns out they are hard to get right. We dive into the reasons with Josh Suereth who maintained sbt (a Scala build tool) for a number of years.
Discuss this episode: https://discord.gg/nPa76qF
#63 ZIO 2 dot Ohhhhh! with Bill Frasure
Our co-author on Effect Oriented Programming, Bill Frasure, joins us to chat about his programming journey and his involvement in last week's ZIO 2.0 release.
Book repo: https://github.com/EffectOrientedProgramming/book
Discuss this episode: https://discord.gg/nPa76qF
#62 Musing About Local-First Sync & CRDTs with Mark McGranaghan
Mark McGranaghan joins us to talk about how the Muse app uses Conflict-free Replicated Data Types (CRDTs) for local-first data synchronization.
More details on Local-first: https://www.inkandswitch.com/local-first/
Referenced article about hybrid logical clocks: https://archive.jlongster.com/using-crdts-in-the-wild
Discuss this episode: https://discord.gg/nPa76qF
#61 Compassionate Communities with Tonya Moore
Tonya Moore has been helping build developer communities for years. We discuss how to deal with jerks and the importance of building on a foundation of compassion.
Referenced blog from Bill Venners: https://www.artima.com/articles/compassion-in-our-community
Discuss this episode: https://discord.gg/nPa76qF
#60 Kotlin Language Design with Roman Elizarov
Kotlin Language designer Roman Elizarov, joins us to talk about finding the right balances when designing Kotlin.
Discuss this episode: https://discord.gg/nPa76qF
#59 Goetz's Law, Dhall, and Nix (With Gabriella Gonzalez)
Gabriella Gonzalez joins to teach us about the Dhall configuration language they created and Nix.
References:
The Dhall configuration language
Henk: a typed intermediate language
Pants Build Tool
The Purely Functional Software Deployment Model
Haskell for all: How to use NixOS for lightweight integration tests
How to market Haskell to a mainstream programmer
Discuss this episode: https://discord.g
#58 Scala 3: Significant indentation and other things we love (With Martin Odersky)
Martin Odersky, creator of Scala, joins us to chat about Scala, Effects, Exceptions, Experiments, and other Exciting stuff.
Discuss this episode: https://discord.gg/nPa76qF
#57 Technology Trade Offs: Python & Kotlin (With Matt Anger)
We explore with Matt Anger a blog he wrote about migrating from Python to Kotlin and the trade offs engineering teams make when deciding which technologies to use.
Discuss this episode: https://discord.gg/nPa76qF
#56 Feedback Loops & Software is Like Surgery (With Daniel Terhorst-North)
We explore with Daniel Terhorst-North how social and technical feedback loops can help us build the right thing faster.
Discuss this episode: https://discord.gg/nPa76qF
#55 Apache Kafka - Like Functional Programming but for Data (With Anna McDonald)
We chat with the Kafka Duchess, Anna McDonald, about Apache Kafka, CQRS, Event Sourcing, and of-course Functional Programming.
Note: There was a bit of echo for a few minutes but we did resolve it around 8 minutes in.
Discuss this episode: https://discord.gg/nPa76qF
#54 Flix: Designing a principled programming language with Magnus Madsen
Magnus Madsen, language designer for the Flix programming language, joins us to talk about the driving principles and innovative features of the language.
Discuss this episode: https://discord.gg/nPa76qF
#53 Open Source: Free as in Hot Dogs (With Donald Fischer)
Open Source is an essential foundation for pretty much everything. How do we fund it appropriately? What do we do about Log4Shell-types of issues? Donald Fischer of Tidelift joins us to discuss these economic and human issues.
Discuss this episode: https://discord.gg/nPa76qF
#52 Reveling in Nonsense With Josh Long
A stroll through 20 years of Spring with Josh Long. Also: Bruce, James, and Josh announce their new Ska band.
Discuss this episode: https://discord.gg/nPa76qF
#51 James' New Kotlin PM Job
Hope you all have a happy & healthy holiday!
Discuss this episode: https://discord.gg/nPa76qF
#50 Testcontainers (Like Uber but for Integration Tests) with Sergei Egorov
Testcontainers are one of James' favorite modern technologies and in this episode we chat with Sergei Egorov, one of the project creators. We learn about what Testcontainers are and the new Testcontainers Cloud service created by Sergei's new company, AtomicJar.
Discuss this episode: https://discord.gg/nPa76qF
#49 Smart Types (Like Regular Types, Only Smarter) with Jorge Vasquez
Jorge Vasquez has been working on a way to have more precise data modeling while not sacrificing performance or ergonomics. Smart Types in ZIO Prelude are the answer, and they are amazing!
Discuss this episode: https://discord.gg/nPa76qF
#48 Composability in Distributed Systems - Because Math! With Heather Miller
Heather Miller, Computer Science professor at Carnegie Mellon, joins us to talk about her research into composability in distributed systems, the challenges with serialization, and a better approach to Chaos Engineering.
Discuss this episode: https://discord.gg/nPa76qF
#47 The Future of Programming Rocs! With Richard Feldman
The creator of the new Roc programming language, Richard Feldman, joins us to talk about rocking developers worlds' with better tools & paradigms.
Discuss this episode: https://discord.gg/nPa76qF
#46 What Problem Does GraalVM Solve? All of them. Featuring Alina Yurenko
We dive deep on GraalVM and learn from Alina Yurenko about all the problems it solves.
Discuss this episode: https://discord.gg/nPa76qF
#45 ZIO 2 - Better, Faster, Friendlier with Adam Fraser
Adam Fraser is a core contributor to Scala ZIO. He joins us to chat about improvements in ZIO 2 and how we can grow adoption.
Discuss this episode: https://discord.gg/nPa76qF
#44 Tired of Getting N+1'd by Your ORM? A Chat With Alexander Ioffe.
We chat with Alexander Ioffe, maintainer of the Quill library, about database access approaches and Scala metaprogramming.
Discuss this episode: https://discord.gg/nPa76qF
#43 Rúnar Bjarnason is Jackhammering the Foundations of Programming
We've mentioned the futuristic Unision programming language many times but now we dive deep with one of the co-founders.
Discuss this episode: https://discord.gg/nPa76qF
#42 The answer to life, the universe, and everything is an abstraction with Viktor Klang
The legendary Viktor Klang chats with Bruce & James about information loss, reactive, emergence, and many other mind expanding topics.
Discuss this episode: https://discord.gg/nPa76qF
#41 "Never gonna give you up" (FP that is) with Wiem Zine Elabidine
Bruce and James hear about Wiem's journey in Functional Programming, her contributions to Scala ZIO, and how she never gave up despite the challenges she faced.
Discuss this episode: https://discord.gg/nPa76qF
Recommended
11 O'Clock Comics Podcast
123 GO! Food
1-2-3 Learn Spanish with Me!
128 Civics Questions for U.S. Citizenship Test
12 Hour Sound Machines for Sleep (no loops or fades)
#12minconvos
12 Minute Meditation
12 Rules for Life: An Antidote to Chaos by Jordan B. Peterson, Book Summary, Podcast, English
1440 Explores
1490 Doom - Lore Series Podcast
15 MINS OF FAME
15 Minute Mysteries: The Deep Dive
