Compiled Conversations

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 Chris Brousseau on LinkedIn Chris Brousseau on YouTube (IMJONEZZ) Chris Brousseau on GitHub (IMJONEZZ) Chris Brousseau on Hugging Face (IMJONEZZ) LLMs in Production (Manning) Veox AI Attention is All You Need (2017) Training Compute-Optimal Large Language Models (Chinchilla Paper) Word2Vec GPT-2 (OpenAI) DeepSeek DeepSeekMath: GRPO Paper GSM8K: Grade School Math Dataset LLM Sampling Visualisation DSPy Kimi K2 by Moonshot AI GLM by Zhipu AI vLLM LM Studio llama.cpp Hugging Face smolagents Code Execution with MCP (Anthropic) MCP (Model Context Protocol) Framework Desktop NVIDIA DGX Spark I spent $17k on AI hardware so you don’t have to (YouTube) Forge Utah Community

Nick Tune, staff engineer and author focused on architecture modernization and domain-driven design. He reframes legacy systems as successful products outgrowing their design. He outlines a four-pillar modernization framework and warns of the perilous hybrid state called Death Valley. He explores semantic drift, Conway’s Law, enabling teams, and how AI tools like Claude Code aid analysis, refactoring, and living documentation.

In this session, Shawn McCool, an experienced software engineer and domain modeling advocate, dives into the transformative world of event sourcing. He shares his journey from discovering domain events while working on Laravel.io to creating the Event Sourcery course. Shawn explains the key differences between event sourcing and CRUD, while discussing the nuances of CQRS and eventual consistency. He emphasizes the importance of modeling intent and context with events and advocates for short-lived aggregates to simplify versioning and retention challenges.

David Boyne, an open-source founder and event-driven architecture advocate, shares his journey from AWS serverless advocate to solo bootstrapper of Event Catalog. He discusses the struggles teams face with event-driven systems, especially around governance and discoverability. David reveals how his visualization tools emerged from his note-taking system and underscores the need for better event documentation. He also talks about his decision to go solo, building in public, and how he uses AI in his daily tasks as a founder.

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 Shannon Wirtz on LinkedIn Ensemble Learning Random Forest XGBoost Neural Networks Convolutional Neural Networks DeepSeek-OCR ImageNet AlexNet Transformers Attention Is All You Need Gradient Descent Cross-Validation Precision and Recall F1 Score AUC (Area Under Curve) Confusion Matrix SHAP Values Partial Dependence Plots Andrew Ng’s Machine Learning Course DeepLearning.AI Kaggle DataCamp R Programming Language Why Machines Learn Hands-On Machine Learning Neural Networks and Deep Learning

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