Happy Path Programming

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!

First a short rant about mutability followed by learning about Smithy, an Interface Description Language (IDL), with Jakub Kozłowski.

Holly Cummins, a Senior Principal Software Engineer on Quarkus at Redhat, joins us to chat about Microservices and Quarkus.

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.

We learn the motivations behind Haskell and why it is the pinnacle of Functional Programming from Kris Jenkins, a Developer Advocate at Confluent.

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.

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.

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)

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).

Bruce continues his archaeological dig into the foundations of mainstream programming.

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.

Rod Johnson (creator of Spring Framework) reflects on his programming and chess journeys.

References:

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.

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.

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.

Kotlin Language designer Roman Elizarov, joins us to talk about finding the right balances when designing Kotlin.

Martin Odersky, creator of Scala, joins us to chat about Scala, Effects, Exceptions, Experiments, and other Exciting stuff.

We explore with Daniel Terhorst-North how social and technical feedback loops can help us build the right thing faster.

Magnus Madsen, language designer for the Flix programming language, joins us to talk about the driving principles and innovative features of the language.

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.

A stroll through 20 years of Spring with Josh Long. Also: Bruce, James, and Josh announce their new Ska band.

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.

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!

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.

The creator of the new Roc programming language, Richard Feldman, joins us to talk about rocking developers worlds' with better tools & paradigms.

We dive deep on GraalVM and learn from Alina Yurenko about all the problems it solves.

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.

We chat with Alexander Ioffe, maintainer of the Quill library, about database access approaches and Scala metaprogramming.

We've mentioned the futuristic Unision programming language many times but now we dive deep with one of the co-founders.

The legendary Viktor Klang chats with Bruce & James about information loss, reactive, emergence, and many other mind expanding topics.

Bruce and James chat with Barry Hawkins about software methodologies, their triumphs and abuses.

According to James, Heroku had the best company culture / vibe of anywhere he has worked. Bruce & James talk with Sharon Schmidt who is in large part responsible for creating that magical experience.

Paul Snively helps us see the future of programming. Spoiler: It's Typed & Functional.

Referenced talks:

Bruce describes his multi-decade journey running conferences and how letting go of control, while still having a structure, has led to conferences where attendees connect in meaningful ways.

As usual, Bruce & James try to figure out monads & type classes. Then something new, as they go meta on design patterns.

FEE, FOO, FUD, and FUM (Fear, Uncertainty, and Monads) - Scala Giant, Dick Wall, joins Bruce and James to talk about life, work, and Functional Programming.

Object Oriented Programming might just be a series of solutions to self-created problems.

Bruce and James' coauthor Bill Frasure, joins to talk with Kit Langton, creator of ZIO Magic and many other magical ZIO tools & libraries.

Bruce and James chat with their long time friend Bill Venners about Scala 3 and the updates to his "Programming in Scala" book.

Bruce and James chat with their friend Julie Amundson about AI, Machine Learning, and many related complexities.  They explore what the journey is like for Data Scientists at medium / large companies where everything from data access to productionizing models, has challenges.  Also we learn about the Metaflow system Julie's team built to make this journey smoother at Netflix.

Bruce, James, and their friend Bill are working on a new book about systems that are Performant, Reliable, Expressive, and Productive. This episode explores those themes with some significant detours along the way.

With the eminent release of Scala 3, we chat about the language changes, effect systems (ZIO), and reliability.

All about Dependency Injection, why we do it, and why James thinks it is terrible.

Once again we lament build tools. Then we get blocked talking about Reactive, async, non-blocking, actors, and concurrency.

Bruce & James have a delightful chat with long-time friend Dianne Marsh about changing tech culture to be more vulnerable and diverse.

Note: The Non-Violent Communication trainer mentioned in the episode is Karl Steyaert.

James shares about a blog he posted this week titled: "The Modern Java Platform - 2021 Edition"

Special guest Oli joins us to chat about Recursion Schemes, tech conferences, podcasts, and kindness.

James is a Dynamic Programming Language Denier but realizes only a part of his code is actually statically typed. And programming languages so full of quirks that you have to hold the quick reference book in your teeth.

Culture - the hidden force that sometimes reveals itself through code reviews. What is it & how does it form / change?

Also, Developer Marketing and how most companies do it wrong.

Change happens, but slowwwwly. How can we accelerate the adoption of new & better programming language features? Should we?

Software architectures, organizational management, hiring practices, and many other normal part of life give us an illusion of control.  But is there another way?

James, as a Scala "True Believer," talks about his experiences with Kotlin and how they compare to Scala. Then he switches gears to rant about runtime reflection which leads to a deeper conversation about meta-programming and alternatives to runtime reflection.

Bruce shares exciting news about completing the Atomic Kotlin book. The rest is a mishmash of topics related to newsworthy announcements including Spring Boot Cloud Event support, Serverless + TestContainer + Kubernetes Cassandra support, and Scala ZIO CLI.

Most developers have been exposed to inheritance based polymorphism but there are other ways to deal with overlapping functionality. In this episode we talk about ad-hoc polymorphism, parametric polymorphism, and type classes.

Python usage surpasses Java to second place on the Tiobe Index (behind C). Is developer productivity the primary driver? We then switch gears to talk about the concept of "Making Illegal States Unrepresentable" where James continues his crusade against the Builder Pattern.

We start off discussing what the future of programming might be... Can developers stop thinking about resource limitations?  Can we make the "right path" easy?  Then we dive into Inner Source and the organizational & cultural challenges with adopting it.

We start off talking about Cloud Native Buildpacks and Containers which of-course leads to James trying to explain Kubernetes.  Then we dive into what "Happy Path Programming" means and how, while the term is somewhat derogatory, it is what we ultimately want.  We end with a discussion about Bruce's recent explorations into Rust and gRPC.

Long-time Java author & expert, Cedric Beust, joins us to revisit some of the topics from our Kotlin episodes.  We talk more deeply about checked exceptions, null safety, the builder pattern, build systems, and of-course Monads.

What are the reasons to adopt or migrate to a new technology?  What prevents you from doing so?  We explore that question and the differences between green-field and brown-field.  Then we finally dive deep into Monads trying to conquer the Curse of the Monad.

James officially launches his crusade against custom declarative languages and then we bike-shed about bike-shedding; exploring ways to make decisions for trivial problems.

We begin by talking about personal developer productivity but then expand the scope to "collective" / team productivity.  This leads us to grapple with some challenging ideas around Agile, non-violent communication, organization structures, diversity, and inclusion.

In this episode we discuss things that are often overlooked in developer experience and what underlying values make developer experience an afterthought.

A bike-shedless discussion about nulls, algebraic data types, and code formatting.

In episode 2 we continue the conversation about Kotlin, things we enjoy and things that could be better.

In our first episode we discuss features of the Kotlin programming language that we like.