Compiled Conversations

From Linguistics to Large Language Models with Chris Brousseau

Edd Mann — Tue, 10 Feb 2026 07:00:00 +0000

Chris Brousseau, co-author of LLMs in Production and VP of AI at Veox AI, joins us to peek under the hood of large language models and explore why getting them into production remains one of the hardest challenges in the field.

We start with Chris’s journey from linguistics and translation into machine learning, tracing how a graduate seminar on Python and machine translation in 2017 led him into the world of NLP. His background in semiotics and how meaning is created in language provides a grounding for understanding what LLMs can and can’t do - and why they produce useful results despite having no understanding of semantics.

From there, we dive into the fundamentals - transformers, tokenization, word embeddings, context windows, and the training pipeline from self-supervised learning through reinforcement learning (PPO and GRPO) to supervised fine-tuning. Chris shares lessons from deploying billion-parameter models at MasterCard and JP Morgan Chase, including the gap between demos and production systems and the operational challenges that come with deploying models at scale.

We also explore hallucinations, the evolution from prompt engineering to context engineering, how logic manipulation and context-free grammars can make a 2023-era 7B model outperform frontier models at math, and where agents and code-based tool calling are heading in 2026.

Topics include:

Chris’s journey from linguistics and translation into machine learning
The gap between demos and production: why deploying LLMs is uniquely hard
What LLMs actually are: autoregressive transformers, tokenization, embeddings, and context windows
Stochastic parrots and semiotics: why LLMs have syntax but no semantics
Emergent behavior and the key insights of the Attention is All You Need paper
The training pipeline: self-supervised learning, RLHF (PPO vs GRPO), and supervised fine-tuning
Hallucinations and the fundamental challenge of evaluating language model outputs
From prompt engineering to context engineering
Logic manipulation and context-free grammars: making small models outperform frontier ones
LoRA, distillation, and quantization: running and adapting your own models
Agents, Code Mode versus MCP, and practical techniques for running your own models

Throughout the conversation, Chris demonstrates how a linguistics background provides a unique lens for understanding both the strengths and fundamental limitations of large language models - and why bridging the gap between language research and computer science could unlock the next wave of progress.

Show Links

Architecture Modernization with Nick Tune

Edd Mann — Wed, 28 Jan 2026 07:00:00 +0000

Nick Tune, author of Architecture Modernization and Staff Engineer at PayFit, joins us to explore the complex world of modernising legacy systems.

We start by reframing legacy systems as successful products asked to solve problems they weren’t designed for. Nick introduces his four-pillar modernisation framework and the concept of “Death Valley” - the dangerous hybrid state during migration. We explore socio-technical alignment, how domain models drift from business language over time, and how team structure shapes architecture through Conway’s Law. The conversation also covers how AI tools like Claude Code are transforming architecture work through code analysis, refactoring, and living documentation.

Topics include:

Reframing legacy as successful systems outgrowing their design
Four pillars: business/strategy, design/discovery, architecture, execution
Month three milestone: balancing analysis with demonstrable progress
Death Valley: dangerous hybrid state during migration
Semantic drift: business terminology vs code terminology
Conway’s Law: team structure mirroring software architecture
Architecture Modernization Enabling Teams (AMET)
Platform as product: standardisation vs developer experience
Using Claude Code for analysis, refactoring, living documentation
Guardrails: linting, test coverage, complexity limits for AI agents
Multi-agent workflows running in parallel

Throughout the conversation, Nick demonstrates how architecture modernisation is fundamentally about aligning business needs, team structures, and technical systems - and how AI tools are becoming essential for understanding, documenting, and evolving complex codebases.

Show Links

Event Sourcing with Shawn McCool

Edd Mann — Fri, 16 Jan 2026 06:00:00 +0000

Shawn McCool returns to the podcast to explore event sourcing - a pattern that fundamentally changed how he thinks about modeling software systems.

We start by tracing Shawn’s journey into event sourcing, beginning with his work on Laravel.io around 2012 when a friend introduced him to domain events. This discovery led him deeper into the DDD community and eventually to creating Event Sourcery, a free video course on domain modeling and event sourcing. Shawn shares how working with event sourcing broke him out of the “way we’ve always done it” mindset.

The conversation covers the core concepts - what event sourcing actually means (using events as the source of your model state), how it differs from event streaming and event-driven architectures, and when you might choose this approach. We explore the relationship between event sourcing and CQRS, discussing how separating read and write models enables independent evolution and scaling, while acknowledging the trade-offs around eventual consistency.

Topics include:

What event sourcing means: events as the core of your model state
The distinction between event sourcing, event streaming, and event-driven architectures
Domain events versus CRUD: capturing intent and context
CQRS: separating decision-making models from read models
Eventual consistency: trade-offs between reliability and immediate feedback
Synchronous versus asynchronous projections
Why DDD isn’t a specific methodology but a pursuit of understanding
Aggregates as lifecycles, not nouns - designing for short-lived event streams
The bank account anti-pattern: why long-running aggregates are problematic
Testing event sourced systems: given-when-then with events
Projections as pure, side-effect-free transformations
Versioning strategies and avoiding the pain of long-lived aggregates
GDPR and data retention: designing systems that don’t need to keep data forever
Implementation approaches: relational databases versus dedicated event stores
Rolling your own versus using frameworks like EventSauce or Marten

Shawn emphasizes how building systems around short-lived aggregates - where event streams naturally terminate - eliminates entire classes of versioning and data retention problems. He shares insights from his work at a payment processing company, where the system is designed so that event streams exhaust within 30 minutes, making evolution and versioning remarkably straightforward.

Throughout the conversation, Shawn demonstrates how stepping away from noun-centric thinking and embracing events as the core building block leads to systems that are easier to understand, test, and evolve.

Show Links

Building Event Catalog: From AWS to Solo Bootstrapping with David Boyne

Edd Mann — Fri, 12 Dec 2025 07:00:00 +0000

David Boyne joins us to share his journey from AWS serverless advocate to solo bootstrapper building Event Catalog, an open source tool bringing discoverability to event-driven architectures.

We start by exploring David’s background at AWS, where he spent over two years as a serverless advocate focusing on event architectures, EventBridge, and helping customers navigate the complexities of distributed systems. He shares insights into the problems he consistently saw teams struggling with as they scaled their event-driven systems, particularly around governance and discoverability - noting that event architectures are still 10-15 years behind API documentation, with most organizations lacking machine-readable specifications for their events.

Seeing these governance challenges repeatedly, David made the decision to leave AWS and pursue Event Catalog full-time as a solo bootstrapper. He shares candid insights into the realities of that journey and discusses how Event Catalog evolved from a Christmas side project to a tool used by developers, architects, business analysts, and product owners, each finding different value in the platform.

Topics include:

David’s journey from AWS serverless advocate to solo bootstrapper
Visual thinking: how EDA Visuals emerged from David’s Zettelkasten note-taking system
Event-driven architecture fundamentals and alignment with domain-driven design
The governance challenge: why EDA needs better discoverability and documentation
Transitioning from AWS: making the leap to full-time open source work
Solo developer journey: the highs, lows, and lessons learned from bootstrapping
Open core business model: balancing open source with sustainable revenue
Building in public: sharing the journey and making the pie bigger for everyone
Customer discovery: how to engage with users as a solo builder
Building for developers: the unique challenges of B2D (business-to-developer) markets
Pricing strategies: understanding value and avoiding the “too cheap” trap
Event Catalog: bringing discoverability to event architectures
Event Catalog Studio: visual design tools for event architectures
Tech stack decisions: choosing Astro, self-hosting, and GitOps workflows
AI integration: MCP tools, context-aware documentation, and the future of architecture docs
The importance of talking to customers and focusing on problems over features

Finally, we explore how AI is changing architecture documentation, with David sharing his experiments with MCP tools that provide context-aware assistance to developers working with event architectures; while recognizing that business context, domains, and ubiquitous language must come from human understanding.

Throughout the conversation, David emphasizes the importance of being human, focusing on problems over features, and advocating for the space rather than just the product. Whether you’re interested in event-driven architectures, considering a solo bootstrapping journey, or curious about building developer tools, this episode offers both practical insights and inspiration.

Show Links

Machine Learning Fundamentals, Part 2 with Shannon Wirtz

Edd Mann — Fri, 21 Nov 2025 07:30:00 +0000

We continue our exploration of machine learning fundamentals with Shannon Wirtz, diving deeper into advanced model architectures, training techniques, and evaluation methods.

We start with ensemble learning - why combining multiple models often outperforms single models, and how techniques like Random Forest and XGBoost prevent overfitting through clever sampling strategies. From there, we explore neural networks, understanding how they learn directly from raw data through sequences of linear and nonlinear transformations.

The conversation covers the evolution from convolutional neural networks (perfect for images) to recurrent neural networks (for sequences) to Transformers (the architecture behind modern LLMs). We dive into how Transformers revolutionized natural language processing through parallelization and attention mechanisms, enabling the large language models we see today.

We then shift to the critical topic of model evaluation - exploring loss functions, gradient descent, learning rates, and the importance of proper train/validation/test splits. Shannon explains why you need separate validation and test sets, how k-fold cross-validation works, and the various metrics used to assess model performance beyond simple accuracy.

Topics include:

Ensemble learning: why combining models works (Random Forest, XGBoost)
Neural networks: linear and nonlinear transformations, neurons, and layers
Convolutional Neural Networks (CNNs): recognizing visual patterns and edges
Transformers: the architecture behind modern LLMs, attention mechanisms, and why they’re so powerful
Training and evaluation: loss functions, gradient descent, and learning rates
Train/validation/test splits and why you need all three
K-fold cross-validation: a more robust evaluation approach
Performance metrics including precision, recall, F1 score, AUC, and the confusion matrix
Model interpretation: white box vs black box models
Interpretation techniques including partial dependence plots, SHAP values, and individual conditional expectations
Learning resources: Andrew Ng’s courses, Kaggle, DataCamp, and hands-on projects

Shannon also shares his personal learning journey, from rote learning to practical hands-on experience, and discusses how he learns most effectively through immediate feedback and engaging projects.

Whether you’re looking to understand how modern AI systems work or seeking practical guidance on getting started with machine learning, this episode provides both theoretical depth and practical strategies for building and evaluating ML models.

This is Part 2 of a 2-part series. In Part 1 , we explored the foundations of machine learning - including core concepts, terminology, different learning approaches, and fundamental model types.

Show Links

Machine Learning Fundamentals, Part 1 with Shannon Wirtz

Edd Mann — Thu, 13 Nov 2025 07:00:00 +0000

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

Building on the BEAM: Exploring Erlang and Elixir, Part 2 with Shawn McCool

Edd Mann — Sun, 02 Nov 2025 07:00:00 +0000

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

Building on the BEAM: Exploring Erlang and Elixir, Part 1 with Shawn McCool

Edd Mann — Fri, 24 Oct 2025 07:00:00 +0000

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

The Life of a PostgreSQL Table, Part 2 with Bruce Momjian

Edd Mann — Mon, 13 Oct 2025 15:00:00 +0000

Bruce Momjian returns to complete our exploration of PostgreSQL internals through a table’s lifecycle. From updates and alterations to deletions and drops, we dive deep into how Postgres manages data changes, maintains consistency, and handles clean-up operations, revealing the intricate mechanisms that make PostgreSQL both powerful and reliable.

We examine how Postgres manages everything from transaction isolation to reclaiming space. Bruce explains how MVCC enables concurrent updates, how table alterations affect performance, and how the Write-Ahead Log ensures durability whilst enabling features like point-in-time recovery and replication.

Topics include:

Updates: MVCC, heap-only tuples, and how Postgres handles concurrent modifications
Transaction isolation levels: read committed, repeatable read, and serializable
Table alterations: lightweight vs heavyweight changes, column additions, and type changes
Row deletion: transaction visibility, reclaiming space, and foreign key cascades
Vacuum operations: regular vacuum vs vacuum full, and auto-vacuum scheduling
Write-Ahead Log (WAL): crash recovery, point-in-time recovery, and replication
Table drops: dependency tracking and cleanup operations
Concurrency control: row-level locking, deadlock detection, and conflict resolution
The importance of indexing foreign key columns for performance
How Postgres maintains durability through careful write ordering

Bruce also shares insights into performance optimisation, operational considerations, and the evolution of PostgreSQL’s features over time.

This is Part 2 of a 2-part series. In Part 1, we explored table creation, data insertion, and query execution in PostgreSQL.

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:

The Life of a PostgreSQL Table, Part 1 with Bruce Momjian

Edd Mann — Wed, 01 Oct 2025 07:00:00 +0000

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:

Domain Modeling Made Functional, Part 2 with Scott Wlaschin

Edd Mann — Wed, 24 Sep 2025 09:00:00 +0000

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

Domain Modeling Made Functional, Part 1 with Scott Wlaschin

Edd Mann — Wed, 17 Sep 2025 07:00:00 +0000

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

Boosting Laravel Through AI with Ashley Hindle

Edd Mann — Thu, 11 Sep 2025 09:00:00 +0000

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

All Aboard the PostgreSQL Train with Bruce Momjian

Edd Mann — Wed, 03 Sep 2025 06:00:00 +0000

Bruce Momjian joins us to explore why PostgreSQL continues to outpace proprietary databases - not just in features, but also in its development model and architecture.

We trace Postgres’s 39-year lineage - from its Berkeley origins and Michael Stonebraker’s vision for extensibility, through early debates about removing that extensibility, to the decades in which that design proved pivotal. That architecture has paid off repeatedly, enabling JSON/JSONB, full-text search, PostGIS, and pgvector to land at the right moments without upheaval. Bruce explains why transparent data encryption (TDE) hasn’t landed in core, when sharding actually helps versus scaling up, and how storage choices (latency, power-loss protection) shape performance; we also look at async I/O in Postgres 18, extension-friendly interfaces like table access methods, and what it means to stay ‘on the train’ within the community.

Topics include:

39-year history: Berkeley origins, Stonebraker’s vision for extensibility, and community longevity
The four motivations for open source contributors: puzzles, giving back, career growth, and need
Postgres’s extensibility: from an early burden to a superpower (PostGIS, full-text search, JSON/JSONB, pgvector)
Why TDE is hard in core: technical value versus code complexity
Scaling and storage: latency, power-loss protection, and async I/O in Postgres 18
Aurora/Neon and decoupled storage/compute: niche wins versus staying on the community ’train’

Bruce also shares his approach to lifelong learning, why foundational skills compound, and how the Postgres community keeps engineers at the forefront - sustaining momentum across decades.

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:

Learning Domain-Driven Design, Part 2 with Vlad Khononov

Edd Mann — Wed, 27 Aug 2025 17:00:00 +0000

In Part 2 of our deep dive into Domain-Driven Design (DDD), Vlad Khononov returns to explore how to apply DDD in the real world.

We move beyond the foundations and into implementation - from context mapping and EventStorming to fit-for-purpose architecture, testing, team design, ownership, pragmatic adoption, and AI’s impact on modeling.

Topics include:

CQRS in practice
Bounded contexts and subdomains: boundaries, granularity, and trade-offs
Context mapping patterns: conformist, ACL, open-host, partnership, separate ways
EventStorming vs Domain Storytelling
Architecture patterns: Layered, Hexagonal (Ports & Adapters)
Implementation choices: Transaction Script, Active Record, Domain Model, Event-Sourced Domain Model
Tailoring testing strategies to fit your chosen implementation pattern
Teams and adoption: ownership, safe duplication, where to start, and AI’s role

We wrap with how to adopt DDD without overwhelming your team - focusing on shared understanding, clear ownership, and picking the simplest tools that fit your domain today while keeping tomorrow flexible.

This is Part 2 of a 2-part series. In Part 1 , we covered the foundations: what DDD is for, subdomains and their types, ubiquitous language, bounded contexts, and making flexible architecture decisions.

Show Links

Learning Domain-Driven Design, Part 1 with Vlad Khononov

Edd Mann — Wed, 20 Aug 2025 07:00:00 +0000

Vlad Khononov, author of Learning Domain-Driven Design, joins us to demystify DDD - focusing on the business first, and the code second.

We unpack what DDD is really trying to help you achieve, why strategic DDD matters most, and how concepts like subdomains, ubiquitous language, and bounded contexts can guide both architecture and team design. Along the way, Vlad shares pragmatic advice for avoiding common misconceptions and making choices that keep you flexible as both your product and understanding evolve.

Topics include:

What DDD is - and the real problem it solves for teams
Strategic vs. tactical DDD (why strategy comes first)
The developer’s role in uncovering business intent and future change
Subdomains: core vs. supporting vs. generic - and why granularity is hard
Ubiquitous language: speaking the business’s language (and making it stick)
Bounded contexts: protecting model integrity and when to widen the scope
One-to-one myths: why subdomains ≠ bounded contexts
Monoliths, modular monoliths, and microservices - choosing for flexibility
Ownership boundaries and deploying multiple artifacts atomically
Integrations and the anti-corruption layer (keeping external models out)
Using the Cynefin framework to reason about core/complicated/supporting work

Vlad also shares hard-won lessons on communicating with domain experts, dealing with uncertainty in core subdomains, and why wider bounded contexts can make early-stage change safer and cheaper.

This episode is packed with practical guidance for anyone trying to align architecture with real business needs - not just patterns.

This is Part 1 of 2. In Part 2 we cover: context mapping, modeling workshops, fit-for-purpose architecture and testing, team boundaries, pragmatic adoption, and AI’s impact on modeling.

Show Links

Serverless PHP with Matthieu Napoli

Edd Mann — Wed, 06 Aug 2025 14:00:00 +0000

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

Thinking in Events: Principles of Event-Driven Architecture, Part 2 with James Eastham

Edd Mann — Wed, 30 Jul 2025 07:00:00 +0000

In Part 2 of our deep dive into event-driven architecture (EDA), James Eastham returns to explore the practical realities of building and maintaining event-driven systems. We go beyond principles and into implementation - from failure handling and orchestration vs. choreography, to observability, testing, security, and real-world migration strategies.

Topics include:

Choreography vs. orchestration: coordination strategies and trade-offs
Failure recovery and the saga pattern
Handling sensitive data in events (PII, encryption, audit)
Observability and distributed tracing with OpenTelemetry
Event versioning, schema evolution, and contract testing
Simple async frontend integration: polling vs. WebSockets
Migrating from a monolith using internal events and change data capture (CDC)
Testing flow vs. structure in EDA systems
The realities of documentation and schema visibility
How to get started with EDA - and why you don’t need microservices to do it

We wrap up with a candid look at how James learns best - by doing and by teaching - and why that matters in the fast-evolving world of distributed systems.

This is Part 2 of a 2-part series. In Part 1 , we discussed the foundational principles of event-driven architecture - including types of coupling, asynchronous communication, event design, and the role of events in decoupling and scaling distributed systems.

Show Links

Thinking in Events: Principles of Event-Driven Architecture, Part 1 with James Eastham

Edd Mann — Wed, 23 Jul 2025 08:00:00 +0000

We’re joined by James Eastham, developer advocate at Datadog, to break down the fundamentals of event-driven architecture (EDA) - not just as a technical pattern, but as a communication-first mindset for building distributed systems.

We explore how communication lies at the heart of software design, why coupling and cohesion still matter in modern architectures, and what makes an event more than just a message. The discussion covers everything from monolith vs. microservices trade-offs to the practical realities of building asynchronous systems at scale.

Topics include:

The difference between runtime, temporal, semantic, and data format coupling
What separates event-driven from event-based systems
Why the language of the business should shape your events
How to design and structure thin vs. thick events
Managing idempotency, delivery guarantees, and event versioning
Using CloudEvents, AsyncAPI, and standards to avoid chaos
The pros and cons of buses, streams, and queues - and when to use which

James also shares insights from his time at AWS and Datadog, including a healthy dose of pizza metaphors to explain abstract concepts like consistency models and event flow.

Whether you’re starting fresh or untangling an existing architecture, this episode offers clarity on how to think - and build - in events.

This is Part 1 of a 2-part series. In Part 2 , we’ll dive deeper into choreography vs. orchestration, failure handling, testing, observability, and real-world delivery patterns.

Show Links