Compiled Conversations

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 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 Domain-Driven Design Europe Conference Active Record: How We Got Persistence Perfectly Wrong EventSourcery

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.

In this enlightening discussion, Vlad Khononov, a seasoned software engineer and author, unravels the complexities of Domain-Driven Design (DDD). He emphasizes the importance of aligning software with business strategies rather than just focusing on code. Vlad explains the roles of subdomains and bounded contexts, helping teams navigate the intricacies of architecture. He also debunks common myths, shares insights on effective communication with domain experts, and discusses prioritizing core business challenges—all while encouraging flexibility in design.

Matthieu Napoli, creator of Bref, joins us to explore the journey of bringing PHP to AWS Lambda - and making serverless a reality for everyday PHP developers. From hacking runtimes to building a mature ecosystem, Matthieu unpacks what “serverless” really means in practice - beyond the hype. We dig into Bref’s architecture, its integration with Laravel and Symfony, why PHP fits so naturally into Lambda’s execution model, and what it takes to run scalable, queue-driven applications without managing infrastructure. Matthieu also shares the story behind Bref Cloud - a new deployment and monitoring platform built to simplify the AWS experience for teams of all sizes, while staying open, secure, and extensible. Along the way, we dive into the trade-offs between serverless and Kubernetes, the importance of developer experience in platform design, and how Bref stays flexible - whether you’re shipping a side project or scaling production workloads. This conversation is packed with practical insight into the past, present, and future of serverless PHP - from cold starts and containers to deployment patterns, open source sustainability, and what it takes to keep PHP evolving in the cloud era. Show Links Bref (Official Site) Bref Cloud Matthieu Napoli’s Website Matthieu Napoli on X/Twitter Matthieu Napoli on Bluesky Bref GitHub Repo Serverless PHP: how does it really work? Bref Cloud Security & IAM Docs Laravel Vapor (for comparison) AWS Lambda Symfony Laravel Serverless Framework Lift Plugin for Serverless Framework