Compiled Conversations

Shannon Wirtz, product analyst at Angi, joins us to explore the foundations of machine learning - breaking down the terminology, concepts, and approaches that form the bedrock of modern ML systems. We start by understanding what machine learning actually means in practice, how it differs from traditional rules-based programming, and where it fits within the broader landscape of AI and deep learning. Shannon shares insights from his experience working with ML models in his professional work, from predicting customer behavior to classification tasks. The conversation covers everything from the fundamental building blocks (models, features, training sets) to the different paradigms of learning - supervised, unsupervised, semi-supervised, self-supervised, and reinforcement learning. We explore why generalization is critical, how bias and variance affect model performance, and why the “garbage in, garbage out” principle is so important in ML. Topics include: What machine learning means and how it differs from traditional programming The relationship between AI, machine learning, and deep learning Core ML concepts: models, training sets, samples, instances, datasets Classification vs regression problems Parameters vs hyperparameters in model training Generalization: why models must work on unseen data Bias and variance: understanding overfitting and underfitting Learning paradigms: supervised, unsupervised, semi-supervised, self-supervised, reinforcement Online vs batch learning approaches Instance-based vs model-based learning Anomaly detection and change point detection Features and the “garbage in garbage out” principle The curse of dimensionality: why more features isn’t always better Dimension reduction techniques including PCA Model families: linear/logistic regression, decision trees, k-means, SVMs Shannon also shares practical examples from his work, including predicting tradesperson behavior, handling missing data, and the importance of understanding your data’s context and history before training models. Whether you’re new to machine learning or looking to solidify your understanding of the fundamentals, this episode provides a comprehensive foundation for understanding how ML systems work and why certain approaches are chosen for different problems. This is Part 1 of a 2-part series. In Part 2, we’ll explore ensemble learning, neural networks, model training and evaluation, interpretation techniques, and practical learning resources. Show Links Shannon Wirtz on LinkedIn Overfitting and Underfitting Bias-Variance Tradeoff Semi-supervised Learning Reinforcement Learning Linear Regression Logistic Regression k-means Clustering Decision Trees Support Vector Machines Principal Component Analysis (PCA) Robust Principal Component Analysis Curse of Dimensionality Spurious Correlations Kaggle

We continue our exploration of Erlang and Elixir with Shawn McCool, diving deep into the Elixir ecosystem and its powerful tools and frameworks. From Phoenix’s revolutionary LiveView approach to Ecto’s composable database queries, we examine how Elixir’s design enables building sophisticated systems with less complexity. Shawn shares practical examples from his experience, including building home automation systems with Nerves for monitoring energy usage. We explore LiveBook’s potential for executable documentation and collaborative development, and dive into how Tidewave enables AI agents to interact with running Elixir applications. The conversation also covers when to leverage built-in BEAM capabilities versus external services, and how this gradual scaling approach simplifies early development while maintaining flexibility for growth. Topics include: Phoenix Framework and its real-time capabilities through LiveView Ecto’s approach to database access and why it’s not a traditional ORM When to use built-in capabilities vs external services (ETS vs Redis, Phoenix PubSub vs RabbitMQ) Nerves for embedded development and IoT applications Numerical Elixir (Nx) for ML and numerical computing LiveBook for collaborative development and executable documentation Tidewave and AI integration with Elixir applications Domain modeling with functional programming principles Learning strategies: Erlang first vs jumping into Elixir We wrap up by exploring the paradigm shift from object-oriented to functional programming, with Shawn sharing his recommended learning path including books from the Pragmatic Bookshelf. This is Part 2 of a 2-part series. In Part 1 , we explored the BEAM virtual machine, the actor model, and how Erlang’s unique approach to concurrency enables building more resilient systems. Show Links Shawn McCool’s Website Shawn McCool on X/Twitter Shawn McCool on Bluesky Shawn McCool’s Elixir/Erlang Learning Resources Erlang Elixir Phoenix Framework Phoenix LiveView Laravel Livewire Hotwire Ecto Documentation Ecto Changesets Erlang Term Storage (ETS) Phoenix PubSub Oban - Background Jobs Nerves Project Numerical Elixir (Nx) Elixir LiveBook Tidewave Elixir in Action Programming Erlang Pragmatic Bookshelf - Elixir EventSourcery

Shawn McCool joins us to explore the unique and powerful world of Erlang and Elixir. With 27 years of industry experience spanning system administration, web development, payment processing systems, and conference organisation (including DDD Europe) - Shawn shares how discovering Erlang changed his perspective on building distributed systems. We dive deep into what makes Erlang and the BEAM virtual machine special, exploring how its process-based concurrency model and “let it crash” philosophy enable building highly reliable systems. Shawn explains how Erlang’s origins in telecom shaped its design for handling millions of concurrent connections with near real-time guarantees. Topics include: The BEAM virtual machine as an operating system for concurrent processes Process isolation, lightweight concurrency, and the actor model Message passing between processes and how it differs from shared state Supervision trees and the “let it crash” philosophy of error handling How process-level garbage collection enables consistent performance Hot code upgrades and zero-downtime deployments The difference between concurrency and parallelism Gradual typing in Elixir and type specs in Erlang Protocols for polymorphism without class inheritance Value objects and immutability in functional programming Testing approaches for concurrent systems and processes Throughout the episode, Shawn demonstrates how Erlang and Elixir’s unique approach fundamentally changes how we think about building systems, from state management to error handling, making certain patterns natural and elegant that would be impractical or complex in traditional object-oriented languages. This is Part 1 of a 2-part series. In Part 2 , we’ll explore the Elixir ecosystem, including Phoenix, Ecto, Nx, Nerves, and AI development tools. Show Links Shawn McCool’s Website Shawn McCool on X/Twitter Shawn McCool on Bluesky Shawn McCool’s Elixir/Erlang Learning Resources Erlang Elixir Erlang: The Movie Learn You Some Erlang Making Reliable Distributed Systems in the Presence of Software Errors Erlang Documentation - Processes Erlang Documentation - Distributed Programming Actor Model (Wikipedia) Waterpark: Transforming Healthcare with Distributed Actors Gleam Programming Language Elixir’s Gradual Type System Dialyzer - Type Checker for Erlang Elixir Typespecs Elixir School - Protocols Domain-Driven Design Europe Conference Active Record: How We Got Persistence Perfectly Wrong EventSourcery Elixir Language Tour

Bruce Momjian, a PostgreSQL expert, dives deep into the lifecycle of a PostgreSQL table. He explains Multi-Version Concurrency Control (MVCC) and how it handles concurrent updates. Learn about the differences between lightweight and heavyweight table alterations, and the impact of type changes. Bruce shares insights on the vacuuming process, the Write-Ahead Log's role in durability, and the necessity of indexing for performance. He also discusses how Postgres manages deletions and the intricacies of transaction isolation levels, promoting a robust understanding of PostgreSQL internals.

Bruce Momjian returns to explore the internals of PostgreSQL by way of a table’s lifecycle. From creation through insertion to querying, we dive deep into how Postgres actually implements tables, indexes, and queries under the hood, revealing why understanding these internals helps you make better decisions as a database user. We examine how Postgres handles everything from physical storage to transaction visibility. Bruce explains why constraints are critical for data integrity, how MVCC enables consistent reads without blocking writes, and how the query planner makes decisions about accessing your data. Topics include: Table creation: physical storage, constraints, and why data types matter Storage internals: 8KB pages, TOAST, fill factors, and how data is physically laid out Data insertion: write-ahead logging, transaction visibility, and durability guarantees Index types and their use cases: B-tree, BRIN, GiST, GIN, SP-GiST and when to use each Multi-Version Concurrency Control (MVCC): how Postgres handles concurrent reads and writes Query planning: statistics, costs, and how Postgres chooses access methods Join strategies: nested loops, hash joins, merge joins and when each is optimal The importance of constraints and how they protect data integrity Sequences, transaction visibility, and dealing with concurrent operations Bruce also shares insights into why certain design decisions were made, how they compare to other databases, and practical tips for working with Postgres effectively. This is Part 1 of a 2-part series. In Part 2, we’ll explore the remaining lifecycle of a PostgreSQL table - including updating rows, altering table structure, row deletion, and finally dropping tables. Show Links Bruce generously shared links to all the presentations (with direct references to the discussed slides) and blog articles mentioned in the episode. You’ll find them below: Bruce Momjian’s Website Presentation: Postgres Scaling Opportunities (Horizontal Database Scaling) Presentation: Making Postgres Central in Your Data Center (How Is this Accomplished?) Presentation: Making Postgres Central in Your Data Center (Why Extensibility Matters Today) Presentation: PostgreSQL Internals Through Pictures Bruce’s Blog: Toast-y Goodness Presentation: Flexible Indexing with Postgres (Partial Indexes) Presentation: Flexible Indexing with Postgres (Index Type Summary) Presentation: Flexible Indexing with Postgres (When To Create Indexes) Presentation: Non-Relational Postgres (JSONB) Presentation: Database Hardware Selection Guideline (Magnetic Disk I/O Stack) Bruce’s Blog: When Does a Commit Happen? Presentation: MVCC Unmasked (Aborted IDs Remain) Presentation: MVCC Unmasked (Snapshots Determine Row Visibility) Presentation: MVCC Unmasked (Traditional Cleanup Requirements) Presentation: Unlocking the Postgres Lock Manager (Two Concurrent Updates Show Locking) Presentation: Explaining the Postgres Query Optimizer (Running ANALYZE) Presentation: Explaining the Postgres Query Optimizer (Which Join Method?) Bruce’s Blog: The Externality of Index Creation Bruce’s Blog: Optimizer Hints Three Devs and a Maybe - Postgres Performance Tuning and Query Planner Three Devs and a Maybe - Managing Concurrency in Postgres

We continue our conversation with Scott Wlaschin, author of “Domain Modeling Made Functional” and creator of the popular F# for Fun and Profit blog, as we dive into functional programming concepts and how they naturally complement domain-driven design. In this episode, we explore the practical aspects of functional programming - from understanding what makes a language functional to implementing robust error handling patterns and modeling domain concepts functionally. Topics include: What functional programming really means The difference between the FP paradigm and FP languages Why functional languages make certain patterns natural (immutability, currying, partial application) Railway-oriented programming and functional error handling patterns How functional programming approaches dependency injection differently Three types of errors: panics, domain exceptions, and infrastructure errors How functional programming helps with domain modeling through composable data types Pipeline-oriented programming and workflow modeling Modeling DDD concepts functionally: entities, value objects, and aggregates Why functional programming language usage is still less common than OO languages AI’s impact on programming and the importance of domain expertise Learning strategies and the value of multi-paradigm programming Scott also shares insights on why he prefers using languages “with the grain” rather than forcing paradigms where they don’t fit naturally. He demonstrates practical examples of how functional programming makes domain modeling more explicit and testable, while discussing the trade-offs between different programming paradigms and when each is most appropriate. We conclude with Scott’s thoughts on AI in software development - why it’s a tool for augmentation rather than replacement, the importance of understanding fundamentals, and how the subscription model might impact the industry. This is Part 2 of a 2-part series. In Part 1 , we explored the fundamentals of domain-driven design - including strategic vs. tactical DDD, (sub)domains, bounded contexts, ubiquitous language, and the critical importance of communication in software design. Show Links Scott Wlaschin’s Website Scott Wlaschin on X/Twitter Scott Wlaschin on Bluesky Scott Wlaschin on GitHub F# for Fun and Profit Domain Modeling Made Functional Railway-Oriented Programming Starbucks Does Not Use Two-Phase Commit Understanding F# types Thinking Functionally Commit Strip - A very comprehensive and precise spec Moving IO to the edges of your app: Functional Core, Imperative Shell Path dependence

We’re joined by Scott Wlaschin, author of “Domain Modeling Made Functional” and creator of the popular F# for Fun and Profit blog, to explore the powerful pairing of domain-driven design (DDD) and functional programming. In Part 1 we explore the fundamentals of DDD - not as a rigid methodology, but as a communication-first approach to building software that actually solves real problems. Scott shares his journey from Smalltalk developer to functional programming advocate, and how he discovered that DDD and functional programming are natural companions. We dive deep into why most software projects fail not because of technical issues, but because developers don’t listen to what users actually want. Topics include: Strategic vs. tactical DDD - and why most people focus on the wrong part What domains and subdomains really are (hint: they already exist in your business) Core, supporting, and generic subdomains - and where to focus your effort Bounded contexts and why boundaries matter for both code and project management Ubiquitous language - the ’everywhere’ language or common language The “garbage in, garbage out” principle and why good inputs matter more than perfect code Shared mental models Event storming and domain storytelling as discovery techniques Fighting the impulse toward database-driven or class-driven design Conway’s Law and the reverse Conway manoeuvre for team organisation Scott also shares practical examples from his experience, including his work at a skincare company where he became a domain expert on cosmetic formulations and built one of his most successful products through constant communication with experts. Whether you’re new to DDD or have been burned by overly complex implementations, this episode offers a refreshing perspective on what domain-driven design really means - and why it’s fundamentally about empathy, communication, and solving the right problems. This is Part 1 of a 2-part series. In Part 2 , we’ll explore functional programming concepts, how they complement DDD, and practical techniques for modeling domains functionally. Show Links Scott Wlaschin’s Website Scott Wlaschin on X/Twitter Scott Wlaschin on Bluesky Scott Wlaschin on GitHub F# for Fun and Profit Domain Modeling Made Functional Three Devs and a Maybe - Domain Modeling Made Functional EventStorming Domain Storytelling Conway’s Law Dan North - Accelerating Agile Chesterton’s Fence

Ashley Hindle, creator of Laravel Boost, joins us to explore the practical side of AI-assisted development - from understanding core concepts to implementing real-world solutions. We start by breaking down the AI landscape, explaining how artificial intelligence, machine learning, generative AI, and large language models connect. Ashley shares his journey from building AI-driven features since OpenAI’s first API release to creating Laravel Boost, a comprehensive package that accelerates AI-assisted development in Laravel projects. The conversation covers everything from prompting techniques and context management to the Model Context Protocol (MCP) and how it enables AI agents to interact with external tools and services. We dive deep into Laravel Boost’s architecture, including its 16 MCP tools for database querying, browser log monitoring, and version-specific documentation search. Topics include: AI fundamentals: understanding AI, ML, GenAI, and LLMs Prompting techniques: zero-shot, few-shot, chain of thought, and context engineering Retrieval Augmented Generation (RAG) and vector embeddings LLM agents: the “fancy while loop” that powers autonomous AI systems Model Context Protocol (MCP): enabling AI agents to access external tools Laravel Boost: structured guidelines, MCP tools, and version-specific documentation Development workflows: refactoring, bug fixes, new features, and project scaffolding Testing strategies in the AI era and why tests are more important than ever Practical advice for developers starting their AI journey Ashley also shares insights on the evolution from simple autocomplete to full task completion, the importance of maintaining responsibility for production code, and how to balance AI assistance with human oversight. We discuss the challenges of context management, the role of guidelines and rules in steering AI behavior, and the future of AI benchmarking in development. Whether you’re new to AI or looking to optimise your development workflow, this episode provides practical guidance on integrating AI tools effectively while maintaining code quality and developer responsibility. Show Links Ashley Hindle’s Website Ashley Hindle on X/Twitter Ashley Hindle on Bluesky Ashley Hindle on LinkedIn Laravel Boost Laravel Boost on GitHub Model Context Protocol (MCP) How to Build an Agent opencode Claude Desktop Claude Code Cursor IDE ChatGPT Codex OpenAI API Kiro Anthropic’s YouTube Channel Andrej Karpathy’s YouTube Channel The future of agentic coding with Claude Code Interpretability: Understanding how AI models think Conductor Trello board for my local projects Vibe Coding Book (Gene Kim & Steve Yegg) Whisper (Speech Recognition) Tiktokenizer

Bruce Momjian, a pivotal figure in the PostgreSQL community since 1996, delves into the rich 39-year history of Postgres, highlighting its origins and extensibility. He discusses how notable features like JSONB and PostGIS emerged thanks to its open-source community. Bruce tackles the complexities of implementing transparent data encryption, the nuances of sharding, and the balance between performance and storage options. He emphasizes the importance of staying engaged within the community and explores the evolution of PostgreSQL amidst cloud computing and modern data demands.

Vlad Khononov, a software architect and author of 'Learning Domain-Driven Design', dives into advanced DDD concepts. He discusses real-world implementations like CQRS and context mapping patterns. Vlad emphasizes the importance of collaborative modeling techniques, drawing lessons from Formula One racing about accuracy in software models. He also explores the intersection of DDD and team dynamics, and how AI can enhance software architecture. Listeners will gain valuable insights into managing team ownership and practical strategies for adopting DDD without overwhelm.