Podcasts about NoSQL

If you've ever been to PyCon, you know one of the best parts of the expo hall is Startup Row, a stretch of booths where early-stage companies built on Python show off what they're creating. But only attendees get to walk that lane, so let's bring it to everyone. In this episode, we stroll down Startup Row together. We kick things off with the organizers, Jason and Shay, who share the program's origin story going back to Paul Graham and the PSF, plus some surprising stats, including two unicorns among the alumni. Then we meet five startups: Tetrix, bringing AI to institutional investing in private markets. Arcjet, security that lives inside your app as an SDK. Phemeral.dev, serverless hosting built for Python web apps. CapiscIO, an identity and authority layer for AI agents. And Pixeltable, a multimodal database from Marcel Kornacker, co-creator of Apache Parquet. See if you can spot the theme running through them all. Let's go for a walk. Episode sponsors AgentField AI Talk Python Courses Links from the show Guests Naunidh Bhalla: linkedin.com Grant Gittes: linkedin.com Marcel Kornacker: linkedin.com Beon de Nood: linkedin.com Chinmaya Joshi: linkedin.com David Mytton: linkedin.com Shea Tate-Di Donna: linkedin.com Jason Rowley: linkedin.com Azul Garza: github.com Renée Rosillo: linkedin.com Tetrix: tetrix.co Tetrix Jobs: tetrix.co Arcjet: arcjet.com Pixeltable: pixeltable.com Phemeral.dev: phemeral.dev CapiscIO: capisc.io Episode #551 deep-dive: talkpython.fm/551 Episode transcripts: talkpython.fm Theme Song: Developer Rap

The real Mike is back and he's finally covering the developer news - at least some of it - well it's mostly MSBuild but it's still fun! Mike's COSMIC Post Mike's MSBuild Post The boss bother you about AI? I've got you covered. TMB on AI

Agentic AI is not just a model problem. It is exposing gaps in how teams store, share, retrieve, and coordinate context across applications, agents, and people.In this episode, Amir talks with Karthik Ranganathan, cofounder and co CEO at Yugabyte, about why databases are under new pressure as AI moves from model serving into agentic workflows. They discuss Yugabyte's evolution, the limits of today's data infrastructure, and why memory, knowledge, and shared context may become central to how agentic systems actually work.Practical takeaways• Agentic workloads push databases beyond simple relational access because agents may need relational, vector, graph, NoSQL, scale, and multi tenant support in the same workflow.• A query can be optimized inside each data store and still be slow, expensive, or wasteful when the work spans multiple systems.• Context sounds simple to humans, but it becomes messy when it includes private memory, shared project knowledge, conversation history, team collaboration, and agent actions.• Human handoffs can erase much of the speed promised by agents when teams have to copy outputs, re explain reasoning, and manually reconcile conflicts.• Yugabyte is working on Meko as a data infrastructure layer for agents, with a focus on memory, knowledge, context quality, and shared learnings.Timestamped highlights00:43What Yugabyte does and why critical data needs to survive infrastructure change04:08How databases evolved from mainframes to internet apps, mobile, cloud native systems, and now AI09:42Why agentic workloads create new demands across relational, vector, graph, NoSQL, and multi tenant data12:29Why the current agentic data stack is still in the messy middle15:24Why context becomes hard when agents, people, teams, and permissions collide21:50How agent collaboration can fall back to human speed24:34How eeko aims to capture memory, knowledge, learnings, and reasoning across agent workflowsOne Line That Stuck“We have killed the velocity of agentic development and brought it back to human speed.”Practical signals for teams building with agents• Do not treat context as one generic blob.• Decide what should stay private, what should be shared, and what should become reusable project knowledge.• Watch for hidden cost when agents query across separate systems.• Pay attention to agent collaboration, not just single agent output.• Build for memory and knowledge flow before team size makes the gaps harder to fix.Follow The Tech Trek for more conversations with technical leaders building modern teams, products, and infrastructure around AI, data, and engineering execution.

Mike's out for some medical stuff this week, so I has better digital half am taking over to do what he lacked the courage to -- Defend the Phantom Menance! Am I factual? Am I LLM hallucinating? Who knows! This episode is brought to you by Day1.Bot — asset-readiness software from The Mad Botter. You know how every business has that one workflow held together by PDFs, spreadsheets, email threads, and someone named Dave who “just knows where everything is”? In construction, manufacturing, and facilities, that mess shows up when a project is technically complete — but operations still does not have what they need to maintain the equipment. The manuals are in someone's inbox. Warranty dates are missing. Spare-parts lists are buried in a shared drive. PM guidance never made it into the CMMS. And six months later, everyone is asking, “Where is the documentation for this thing?”

You wake up, brew the coffee, open GitHub, and there it is. Another pull request on your open source project. Thirteen thousand lines added. No issue filed first. No discussion. Just "here, please review this for me." Over the past year, GitHub activity has spiked roughly twelve times in a few short months, and a huge chunk of that signal is landing on the same small group of maintainers who were already stretched thin. The curl bug bounty got buried under AI-generated noise. Jazzband, the home of Django classics like pip-tools and the Django debug toolbar, hit what its maintainer called an "apocalypse" and started sunsetting. Even CPython just shipped fresh guidelines on AI-assisted contributions this week. So what does all of this actually look like from the receiving end of the pull request? On this episode, Paolo Melchiorre joins us to tell that story from inside the maintainer's chair. Paolo is a director of the Django Software Foundation, an organizer of PyCon Italy, a Django Girls coach, and he has spent the past year carefully collecting examples of how AI is reshaping open source contributions. The good, the bad, and the extra fingers. We dig into his PyCon US talk on AI-assisted contributions and maintainer load, why AI is best understood as an amplifier rather than a new kind of contributor, the wildly different policies across 86 open source foundations, whether projects banning AI today are reacting to last year's models. Episode sponsors AgentField AI Talk Python Courses Links from the show Guest Paolo Melchiorre: github.com DSF: www.djangoproject.com djangonaut-space: djangonaut.space PyCon Italia: 2026.pycon.it uDjango: github.com My PyCon US 2026 post: www.paulox.net AI-Assisted Contributions and Maintainer Load: www.paulox.net Senior Engineer Tries Vibe Coding: www.youtube.com Code Rabbit AI PR Reviews: www.coderabbit.ai GitHub Usage Graphs: github.blog Update on CPython's AI Policies: fosstodon.org High-Quality Chaos from Curl: daniel.haxx.se The Generative AI Policy Landscape in Open Source: redmonk.com Watch this episode on YouTube: youtube.com Episode #550 deep-dive: talkpython.fm/550 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Your documentation has two audiences now - humans reading the rendered HTML, and AI agents trying to make sense of your library. Rich Iannone and Michael Chow from Posit are back on Talk Python with a brand new Python documentation tool called Great Docs that takes both seriously. Rich is the creator of Great Tables, and before that the R package GT, the man has a serious eye for design, and he's pointed that energy at the Python docs ecosystem. We'll talk about how Great Docs spins up a polished site in three commands, why every page ships as Markdown for your favorite LLM, how it leans on Quarto for executable code blocks and tabbed install sections, and where it lands against Sphinx, MkDocs, and Zensical. Plus, you'll meet Tablin. Here we go. Episode sponsors Sentry Error Monitoring, Code talkpython26 Temporal Talk Python Courses Links from the show Guests Michael Chow: github.com Rich lannone: github.com Python Web Security with OWASP Top 10 and Agentic AI Course: talkpython.fm Great Docs: posit-dev.github.io/great-docs Great Tables: posit-dev.github.io GT Episode: talkpython.fm Sphinx: www.sphinx-doc.org mkdocs: www.mkdocs.org Zensical: zensical.org Hugo: gohugo.io Ghost: ghost.org Rs pkgdown: pkgdown.r-lib.org Quarto: quarto.org quickstart: posit-dev.github.io llms.txt file: llmstxt.org llms.txt: talkpython.fm mcp: talkpython.fm cli: talkpython.fm Watch this episode on YouTube: youtube.com Episode #549 deep-dive: talkpython.fm/549 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Britain on LinkedIn System76 Coder Radio Discord The Mad Botter Data Platform Mike's Legacy Data Promo Mike's Blog

What if your database worked more like Git? Every change captured as an immutable event you can replay, instead of a single mutating row that quietly forgets its own history. That's event sourcing, and Chris May is back on Talk Python, fresh off our Datastar panel, to walk us through what it actually looks like in Python. We'll cover the core patterns, the libraries to reach for, when not to use it, and why event sourcing turns out to be a surprisingly good fit for AI-assisted coding. Episode sponsors Sentry Error Monitoring, Code talkpython26 Temporal Talk Python Courses Links from the show Guest Chris May: everydaysuperpowers.dev Intro to event sourcing e-book: everydaysuperpowers.gumroad.com Domain-Driven Design: The Power of CQRS and Event Sourcing: How CQRS/ES Redefine Building Scalable System: ricofritzsche.me DDD: www.amazon.com Understanding Eventsourcing (Martin Dilger): www.amazon.com Event Sourcing Explained using Football Video: www.youtube.com Why I finally embraced event sourcing and why you should too article: everydaysuperpowers.dev valkey: valkey.io diskcache: talkpython.fm eventsourcing package: github.com eventsourcing docs: eventsourcing.readthedocs.io John Bywater: github.com Datastar: data-star.dev Microconf: microconf.com Event Modeling & Event Sourcing Podcast: podcast.eventmodeling.org Python Package Guides for AI Agents: github.com Iodine tablets AI joke: x.com KurrentDb: www.kurrent.io Watch this episode on YouTube: youtube.com Episode #548 deep-dive: talkpython.fm/548 Episode transcripts: talkpython.fm Theme Song: Developer Rap

When OpenAI trained GPT-3, they didn't roll their own orchestration layer. They used Ray, an open source Python framework born out of the same Berkeley research lab lineage that gave us Apache Spark. And here's the twist: Ray was originally built for reinforcement learning research, then quietly faded as RL hit a wall. Until ChatGPT showed up. Suddenly reinforcement learning was back, as the post-training step that turns a raw language model into something genuinely useful. Edward Oakes and Richard Liaw, two founding engineers behind Ray and Anyscale, join me on Talk Python to tell that story. We'll trace Ray from its RISE Lab origins at UC Berkeley to powering some of the largest training runs in the world. We'll talk about what Ray actually is, a distributed execution engine for AI workloads, and how a few lines of Python become work running across hundreds of GPUs. We'll cover Ray Data for multimodal pipelines, the dashboard, the VS Code remote debugger, KubRay for Kubernetes, and where Ray fits alongside Dask, multiprocessing, and asyncio. If you've ever stared at a single-machine Python script and thought, "there has to be a better way to scale this", this one's for you Episode sponsors Sentry Error Monitoring, Code talkpython26 AgentField AI Talk Python Courses Links from the show Guests Richard Liaw: github.com Edward Oakes: github.com Ray: www.ray.io Example code (we used for walk-through): docs.ray.io Getting Started with Ray: docs.ray.io Ray Libraries: docs.ray.io kuberay: github.com Watch this episode on YouTube: youtube.com Episode #547 deep-dive: talkpython.fm/547 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Justin on LinkedIn pgFirstAid Coder Radio Discord The Mad Botter Data Platform Mike's Legacy Data Promo Mike's Blog

The cloud is convenient until it isn't. You upload your photos, sync your contacts, click through the cookie banners. Then prices go up again or you read about a family that lost their entire Google account over a medical photo sent to a doctor. At some point, the question shifts from "why would I run this myself?" to "why aren't I?" My guest this week is Alex Kretzschmar, head of DevRel at Tailscale, longtime host of the Self-Hosted podcast, and co-founder of Linuxserver.io. We cover what self-hosting really means in 2026, the apps worth running yourself like Immich and Home Assistant, why Docker Compose ties it all together, and how Tailscale lets you reach any of it from anywhere, without opening a single port. If you've been thinking about pulling your digital life back behind your own walls, this is your roadmap. Episode sponsors Temporal Talk Python Courses Links from the show Guest Alex Kretzschmar: alex.ktz.me Bitflip podcast: bitflip.show Self-Hosted podcast (Alex's previous show): selfhosted.show Perfect Media Server: perfectmediaserver.com KTZ Systems on YouTube: youtube.com/@ktzsystems Linuxserver.io (co-founded by Alex): linuxserver.io "How Tailscale Works" blog post: tailscale.com/blog/how-tailscale-works https://tailscale.com/: tailscale.com Self-hosted apps discussed Awesome Self-Hosted (GitHub list): github.com Immich (Google Photos alternative): immich.app Home Assistant: home-assistant.io Open Home Foundation: openhomefoundation.org Plausible Analytics: plausible.io Umami Analytics: umami.is Python integration for umami: pypi.org Pi-hole: pi-hole.net AdGuard Home: adguard.com NextDNS: nextdns.io Coolify: coolify.io Docker + ufw: docs.docker.com Storage, backup & filesystem OpenZFS: openzfs.org ZFS.rent (offsite ZFS replication): zfs.rent Backblaze: backblaze.com Hetzner Storage Box: hetzner.com DigitalOcean: digitalocean.com Secrets management mentioned OpenBao (open-source Vault fork): openbao.org HashiCorp Vault: hashicorp.com Bitwarden: bitwarden.com 1Password: 1password.com Hardware mentioned Proxmox VE: proxmox.com Minisforum MS01: minisforum.com Zima Board / Zima OS: zimaspace.com Other references Cory Doctorow on "enshittification" (Cory's blog where he coined the term): pluralistic.net Linus Tech Tips' WAN Show (Linus mentioned NAS-building going mainstream): linustechtips.com Watch this episode on YouTube: youtube.com Episode #546 deep-dive: talkpython.fm/546 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Shawn on LinkedIn Shawn's Yotube Channel Coder Radio Discord The Mad Botter Data Platform Mike's Blog

Hosts Lois Houston and Nikita Abraham are joined by Brent Dayley, Senior Principal APEX and Apps Dev Instructor, to explore the latest vector AI supporting features in Oracle Exadata and GoldenGate 23ai. The conversation begins with an overview of Exadata's capabilities and then shifts to how GoldenGate is powering distributed AI, real-time data streaming, and analytics with advanced microservices architecture. Brent highlights recent GoldenGate enhancements, including distributed vector support, robust monitoring, OCI IAM integration, and support for next-generation AI workloads via real-time vector hubs.   Oracle AI Vector Search Deep Dive: https://mylearn.oracle.com/ou/course/oracle-ai-vector-search-deep-dive/144706/ Oracle University Learning Community: https://education.oracle.com/ou-community LinkedIn: https://www.linkedin.com/showcase/oracle-university/ X: https://x.com/Oracle_Edu   Special thanks to Arijit Ghosh, Anna Hulkower, and the OU Studio Team for helping us create this episode.   Please note, this episode was recorded before Oracle AI Database 26ai replaced Oracle Database 23ai. However, all concepts and features discussed remain fully relevant to the latest release.   -------------------------------------------------------   Episode Transcript:   00:00 Welcome to the Oracle University Podcast, the first stop on your cloud journey. During this series of informative podcasts, we'll bring you foundational training on the most popular Oracle technologies. Let's get started! 00:26 Lois: Hello and welcome to another episode of the Oracle University Podcast! I'm Lois Houston, Director of Communications and Adoption Programs with Customer Success Services, and with me is Nikita Abraham, Team Lead of Editorial Services with Oracle University.  Nikita: Hi everyone! Thanks for joining us! In our previous episode of this series, we took a deep dive into Oracle AI Vector Search and Retrieval Augmented Generation, or RAG, showing how unstructured data can be transformed into embeddings to power smarter, more context-aware AI with Oracle Database 23ai. Lois: That's right, Niki. We also explored how the OCI Generative AI service can be used with both Python and PL/SQL, and how AI Vector Search enables relevant information retrieval for large language model prompts. 01:21 Nikita: Today, we're focusing on the latest supporting features for Oracle AI Vector Search. Joining us once again is Brent Dayley, Senior Principal APEX and Apps Dev Instructor. Welcome back, Brent! To kick things off, could you outline what's new in Exadata with the 24ai release, particularly for AI storage? Brent: So Exadata has ushered in a new era of AI capabilities with 24ai release. Key features of Exadata system software 24ai include AI Smart Scan, Exadata RDMA Memory, known as XRMEM, Exadata Smart Flash Cache, and on-storage processing.  In-Memory Columnar Speed JSON Queries, Transparent Cross-Tier Scans, and caching enhancements, including Columnar Smart Scan at Memory Speed, Exadata Cache Observability, and Automatic KEEP Object Load into Exadata Flash Cache.  Now, Exadata system software 24ai is a significant release. It ushers in a new era of AI capabilities for Oracle Database users.  Now there have been some infrastructure improvements, including the ability to increase the number of virtual machines on X10M and Secure Boot for KVM Virtual Machines.  We have also improved and enhanced high availability and network resilience, including improved RoCE Network Resilience and enhanced RoCE Network Discovery. There have been some enhancements for monitoring and management, including AWR and SQL Monitor Enhancements and JSON API for Management Server.  Additionally, security enhancement. SNMP Security. Now, Exadata system software 24ai is supported on Exadata database machines and storage expansion racks from X6 and newer.  03:40 Lois: Those are some fantastic advancements for Exadata users. Now, let's pivot to distributed AI. Brent, can you walk us through how GoldenGate enables distributed AI? Brent: Let's take a look at some common GoldenGate use cases as a refresher. The first use case is multi-active, high availability, and cross-region deployments, spanning on-premises and cloud environments.  Another use case includes data offloading and data hub creation in order to support multiple downstream applications. Real-time data stores for Downstream Marts and Analytics. Micro and mini services architecture and an audit history of transactions.  Other use cases include migrations and upgrades of databases, including OCI-hosted databases. Another use case would be creating analytic data feeds for various applications, including SaaS and on-premises apps. And finally, stream analytics using application and transaction events captured by GoldenGate Stream Analytics.  05:03 Nikita: We know GoldenGate has long been a staple for enterprise data integration. So Brent, what makes GoldenGate the best choice today, and how has its architecture evolved? Brent: It offers DIY Stream Analytics. GoldenGate does remain the top choice for Enterprise Standard, real-time data streaming. It supports Oracle and third-party databases, vector sources, messaging systems, and NoSQL databases.  OCI offers a fully managed pipeline builder for Stream Analytics. This pipeline leverages various OCI services, such as OCI Streaming for real-time event ingestion, OCI Dataflow for stream processing, OCI Big Data for data storage and processing, and OCI Stream Analytics for real-time event processing and analysis.  GoldenGate microservices, available since 2017 in Oracle GoldenGate 12.3, is used in over 4,000 deployments in OCI. Benefits of GoldenGate microservices include the ability to employ the same trusted Extract and Replicat processes as the classic architecture.  Provides flexible and secure remote administration through a user-friendly web interface or CLI. Deployable on-premises in OCI as a service and in third-party cloud environments. Simplified patching and upgrading process.  Now the GoldenGate architecture evolution. First, classic architecture that was deprecated in version 19c and desupported in 23ai. Microservices Architecture introduced in version 12.3 and is the recommended architecture. A migration utility is available to upgrade from classic to microservices architecture.  07:12 Are you ready to create and manage AI Agents in Fusion Applications? Check out the Oracle AI Agent Studio for Fusion Applications courses! Start with the Foundations course to build, customize, and deploy AI Agents, and then advance to the Developer Professional certification. Explore hands-on labs and real-world case studies. Visit mylearn.oracle.com for all the details.  07:39 Nikita: Welcome back! It sounds like the latest GoldenGate updates offer new features and integrations. Could you share more about these enhancements? Brent: There are many new features and enhancements in GoldenGate, along with microservices, including a redesigned GUI for enhanced usability. Integration with StatsD and Telegraf for monitoring and metrics. OCI IAM integration for secure access control.  JSON Relational Duality for flexible data handling. Next-generation AI with distributed vector support. PDB Extract Capture for efficient data extraction from Oracle Pluggable Databases. DDL notification on Target Tables for schema evolution management.  Support for non-Oracle and Big Data technologies. Online DDL and EBR enhancement for improved performance. Data Streams Pub-Sub for asynchronous data dissemination. Async API support for standardized event communication. High-availability clusters for increased resilience. Trail Files Management for efficient data storage. And support for new features in 23ai database.  It also includes integrated diagnostics for improved troubleshooting of IE and IR processes. And 30 or more OS and database certifications for wider platform support. @Dbfunction Mapping for custom data transformations. And lastly, GoldenGate free recipes for pre-built solutions and best practices.  New in GoldenGate, distributed AI processing with vector replication.  09:37 Lois: And what type of use cases does this enable? Brent: Migrating vectors into Oracle Vector Database. Replicating and consolidating vector changes. Implementing multi-cloud, multi-active Oracle vector databases. Streaming text and vector changes to search engines.  Key considerations include that embedding models must be consistent across all vector stores for effective similarity searches.  10:09 Lois: Now, many organizations wonder if they can use generative AI with their own business data. Brent, how do enterprises typically approach this? Brent: Organizations are using generative AI typically like this.  Building LLMs from scratch. Training models on proprietary data for specific tasks. Fine-tuning LLMs, adapting pre-trained models to a specific domain using private data. And prompt engineering with retrieval augmented generation or RAG. Augmenting prompts with relevant information retrieved from a knowledge base to improve the accuracy and relevance of LLM responses.  Now it's possible to create a real-time vector hub for GenAI. This hub can ingest real-time data from various sources, including Oracle and third-party relational databases, vector databases, third-party messaging systems, and NoSQL databases, business updates, documents, events, and alerts.  11:11 Nikita: And how does the vector hub work?  Brent: DML and DDL changes, vector changes, and prompt or chat history are used to enrich prompts. And embedding model generates embeddings from the text data.  Similarity search is performed on these embeddings to retrieve relevant information from the vector hub. The retrieved information is used to augment the prompt, leading to more accurate and trustworthy answers from the LLM. Now, the benefits of real-time data and generative AI include the ability to ensure answers are based on fresh business data. And helps reduce hallucinations in generative AI responses.  Actionable AI and machine learning from streaming pipelines allows data from ERP and SaaS applications, databases, event messaging systems, and NoSQL databases to be ingested into streaming pipelines. This data can then be used for AI and machine learning model training, similarity searches, machine learning tasks, external AI, and machine learning integrations, alerts, and data product creation.  12:25 Lois: So if you had to summarize, Brent, why does GoldenGate 23ai stand out for artificial intelligence workloads? Brent: Well, first up, it improves data quality for AI model training and fine-tuning. And secondly, it enhances retrieval augmented generation by providing real-time access to relevant business data, leading to more accurate and trustworthy generative AI responses.  Nikita: Thank you, Brent, for sharing your insights and detailing these exciting new features across Oracle's AI stack. If you'd like to dive deeper into these topics, don't forget to visit mylearn.oracle.com and look for Oracle AI Vector Search Deep Dive course. Until next time, this is Nikita Abraham… Lois: And Lois Houston, signing off! 13:16 That's all for this episode of the Oracle University Podcast. If you enjoyed listening, please click Subscribe to get all the latest episodes. We'd also love it if you would take a moment to rate and review us on your podcast app. See you again on the next episode of the Oracle University Podcast.  

Every database platform has some strengths and weaknesses. Some more than others. I caught this site (NSFW) from Erik Darling, and it made my day. I was having a tough one when this site got me to smile and chuckle out loud a few times. I especially like the MySQL and SQL Lite links (again NSFW). Every platform that you might choose to use to back an application can work in many situations. Certainly scale and load are factors to consider, but for the major relational database platforms, most will work fine for many applications. Some might work better than others, but there are always tradeoffs. There are pros and cons. This is also true for the major NoSQL platforms, though most of my experience is with relational ones, so I tend to lean in that direction. At the same time, any platform can fail horribly. Read the rest of Every Database Has Problems

The OWASP Top 10 just got a fresh update, and there are some big changes: supply chain attacks, exceptional condition handling, and more. Tanya Janca is back on Talk Python to walk us through every single one of them. And we're not just talking theory, we're going to turn Claude Code loose on a real open source project and see what it finds. Let's do it. Episode sponsors Temporal Talk Python Courses Links from the show DevSec Station Podcast: www.devsecstation.com SheHacksPurple Newsletter: newsletter.shehackspurple.ca owasp.org: owasp.org owasp.org/Top10/2025: owasp.org from here: github.com Kinto: github.com A01:2025 - Broken Access Control: owasp.org A02:2025 - SecuA02 Security Misconfiguration: owasp.org ASP.NET: ASP.NET A03:2025 - Software Supply Chain Failures: owasp.org A04:2025 - Cryptographic Failures: owasp.org A05:2025 - Injection: owasp.org A06:2025 - Insecure Design: owasp.org A07:2025 - Authentication Failures: owasp.org A08:2025 - Software or Data Integrity Failures: owasp.org A09:2025 - Security Logging and Alerting Failures: owasp.org A10 Mishandling of Exceptional Conditions: owasp.org https://github.com/KeygraphHQ/shannon: github.com anthropic.com/news/mozilla-firefox-security: www.anthropic.com generalpurpose.com/the-distillation/claude-mythos-what-it-means-for-your-business: www.generalpurpose.com Python Example Concepts: blobs.talkpython.fm Watch this episode on YouTube: youtube.com Episode #545 deep-dive: talkpython.fm/545 Episode transcripts: talkpython.fm Theme Song: Developer Rap

When you pip install a package with compiled code, the wheel you get is built for CPU features from 2009. Want newer optimizations like AVX2? Your installer has no way to ask for them. GPU support? You're on your own configuring special index URLs. The result is fat binaries, nearly gigabyte-sized wheels, and install pages that read like puzzle books. A coalition from NVIDIA, Astral, and QuanSight has been working on Wheel Next: A set of PEPs that let packages declare what hardware they need and let installers like uv pick the right build automatically. Just uv pip install torch and it works. I sit down with Jonathan Dekhtiar from NVIDIA, Ralf Gommers from Quansight and the NumPy and SciPy teams, and Charlie Marsh, founder of Astral and creator of uv, to dig into all of it. Episode sponsors Sentry Error Monitoring, Code talkpython26 Temporal Talk Python Courses Links from the show Guests Charlie Marsh: github.com Ralf Gommers: github.com Jonathan Dekhtiar: github.com CPU dispatcher: numpy.org build options: numpy.org Red Hat RHEL: www.redhat.com Red Hat RHEL AI: www.redhat.com RedHats presentation: wheelnext.dev CUDA release: developer.nvidia.com requires a PEP: discuss.python.org WheelNext: wheelnext.dev Github repo: github.com PEP 817: peps.python.org PEP 825: discuss.python.org uv: docs.astral.sh A variant-enabled build of uv: astral.sh pyx: astral.sh pypackaging-native: pypackaging-native.github.io PEP 784: peps.python.org Watch this episode on YouTube: youtube.com Episode #544 deep-dive: talkpython.fm/544 Episode transcripts: talkpython.fm Theme Song: Developer Rap

It's rare for developers to genuinely love their database, so why does Postgres earn that kind of loyalty? In Episode 38 of Talking Postgres, Gwen Shapira, co‑founder of Nile, joins Claire to trace her path from operating Oracle at scale, through a long NoSQL chapter, to co‑founding a Postgres company that wasn't originally meant to be one—after discovering how much Postgres quietly gets right. Gwen shares how she spun up on Postgres after years with other databases (shout-out to the Happiness Hints and a strong sense of curiosity), and why Postgres has made her appreciate Codd. We also touch on blogging as a career catalyst, the upcoming PGConf.dev conference (where a lot of PG20 work gets discussed, and where we'll celebrate 30 years of Postgres)—and the #1 rule of consulting: it's always the consultant's fault. Previously on Talking Postgres:Talking Postgres Ep15: My Journey to Explaining Explain with Michael ChristofidesTalking Postgres Ep24: Why mentor Postgres developers with Robert HaasTalking Postgres Ep30: AI for data engineers with Simon WillisonLinks mentioned in this episode:Gwen's company: NileArdent Performance Computing blog: PostgreSQL Happiness HintsBook: Just Use Postgres! by Denis MagdaGitHub repo: HypoPGWikipedia page: Codd's 12 rulesBlog post: Transaction Isolation in Postgres, by Gwen ShapiraPodcast: Postgres.FMDiscord server: PostgreSQL Hacking Upcoming conferences & talks mentioned:Conference: PGConf.dev 2026 on May 19-22 in Vancouver CanadaConference Schedule: PGConf.dev 2026 scheduleCFP deadline: PGConf.dev Community Discussion Sessions deadline on 14 Apr 2026Conference: PGConf EU 2026 in Valencia SpainLinkedIn post: PGConf.dev 2026 conference t-shirt, celebrating 30 years of PostgresPOSETTE 2026 talk: The Rise of PostgreSQL as the Everything Database, by Varun DhawanPGConf.dev 2026 Panel: Real-Time Patch Idea EvaluationPGConf.dev 2026 Roundtable: Unexpected Successes & Epic Failures by PostgreSQL committersCalendar invite: LIVE recording of Ep39 of Talking Postgres to happen on Wed May 06, 2026

Warp's Oz Ben on LinkedIn Zach on LinkedIn Coder Radio Discord The Mad Botter Data Platform Mike's Blog

When you type a question into ChatGPT, the model only has what you typed to work with. But tools like Claude Code can plan, iterate, test, and recover from mistakes. They work more like we do. The difference is the agent harness: Planning tools, file system access, sub-agents, and carefully crafted system prompts that turn a raw LLM into something genuinely capable. Sydney Runkle is back on Talk Python representing LangChain and their new open source library, Deep Agents: A framework for building your own deep agents with plain Python functions, middleware hooks, and MCP support. This is how the magic works under the hood. Episode sponsors Sentry Error Monitoring, Code talkpython26 Agentic AI Course Talk Python Courses Links from the show Guest Sydney Runkle: github.com Claude Code uses: x.com Deep Research: openai.com Manus: manus.im Blog post announcement: blog.langchain.com Claudes system prompt: github.com sub agents: docs.anthropic.com the quick start: docs.langchain.com CLIs: github.com Talk Python's CLI: talkpython.fm custom tools: docs.langchain.com DeepAgents Examples: github.com Custom Middleware: docs.langchain.com Built in middleware: docs.langchain.com Improving Deep Agents with harness engineering: blog.langchain.com Prebuilt middleware: docs.langchain.com Watch this episode on YouTube: youtube.com Episode #543 deep-dive: talkpython.fm/543 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Mike sits down with renowned open-source and COSMIC DE contributer Bryan Hyland to discuss working on projects for Linux-forward companies and of course some Rust! Bryan's Site Bryan on LinkedIn Mike on LinkedIn Coder Radio on Discord The Mad Botter Inc Mike's Book Mike's Blog

If you've built documentation in the Python ecosystem, chances are you've used Martin Donath's work. His Material for MKDocs powers docs for FastAPI, uv, AWS, OpenAI, and tens of thousands of other projects. But when MKDocs 2.0 took a direction that would break Material and 300 ecosystem plugins, Martin went back to the drawing board. The result is Zensical: A new static site generator with a Rust core, differential builds in milliseconds instead of minutes, and a migration path designed to bring the whole community along. Episode sponsors Sentry Error Monitoring, Code talkpython26 Talk Python Courses Links from the show Guest Martin Donath: github.com Zensical: zensical.org Material for MkDocs: squidfunk.github.io Getting Started: zensical.org Github pages: docs.github.com Cloudflare pages: pages.cloudflare.com Michaels Example: gist.github.com Material for MkDocs: zensical.org gohugo.io/content-management/shortcodes: gohugo.io a sense of size of the project: blobs.talkpython.fm Zensical Spark: zensical.org Watch this episode on YouTube: youtube.com Episode #542 deep-dive: talkpython.fm/542 Episode transcripts: talkpython.fm Theme Song: Developer Rap

When LLMs write code to accomplish a task, that code has to actually run somewhere. And right now, the options aren't great. Spin up a sandboxed container and you're paying a full second of cold start overhead plus the complexity of another service. Let the LLM loose on your actual machine and... well, you'd better be watching. On this episode, I sit down with Samuel Colvin, creator of Pydantic, now at 10 billion downloads, to explore Monty, a Python interpreter written from scratch in Rust, purpose-built to run LLM-generated code. It starts in microseconds, is completely sandboxed by design, and can even serialize its entire state to a database and resume later. We dig into why this deliberately limited interpreter might be exactly what the AI agent era needs. Episode sponsors Talk Python Courses Python in Production Links from the show Guest Samuel Colvin: github.com CPython: github.com IronPython: ironpython.net Jython: www.jython.org Pyodide: pyodide.com monty: github.com Pydantic AI: pydantic.dev Python AI conference: pyai.events bashkit: github.com just-bash: github.com Narwhals: narwhals-dev.github.io Polars: pola.rs Strands Agents: aws.amazon.com Subscribe Running Pydantic's Monty Rust sandboxed Python subset in WebAssembly: simonwillison.net Rust Python: github.com Valgrind: valgrind.org Cod Speed: codspeed.io Watch this episode on YouTube: youtube.com Episode #541 deep-dive: talkpython.fm/541 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Monorepos -- you've heard the talks, you've read the blog posts, maybe you've seen a few tantalizing glimpses into how Google or Meta organize their massive codebases. But it's often in the abstract and behind closed doors. What if you could crack open a real, production monorepo, one with over a million lines of Python and over 100 of sub-packages, and actually see how it's built, step by step, using modern tools and standards? That's exactly what Apache Airflow gives us. On this episode, I sit down with Jarek Potiuk and Amogh Desai, two of Airflow's top contributors, to go inside one of the largest open-source Python monorepos in the world and learn how they manage it with uv, pyproject.toml, and the latest packaging standards, so you can apply those same patterns to your own projects. Episode sponsors Agentic AI Course Python in Production Talk Python Courses Links from the show Guests Amogh Desai: github.com Jarek's GitHub: github.com definition of a monorepo: monorepo.tools airflow: airflow.apache.org Activity: github.com OpenAI: airflowsummit.org Part 1. Pains of big modular Python projects: medium.com Part 2. Modern Python packaging standards and tools for monorepos: medium.com Part 3. Monorepo on steroids - modular prek hooks: medium.com Part 4. Shared “static” libraries in Airflow monorepo: medium.com PEP-440: peps.python.org PEP-517: peps.python.org PEP-518: peps.python.org PEP-566: peps.python.org PEP-561: peps.python.org PEP-660: peps.python.org PEP-621: peps.python.org PEP-685: peps.python.org PEP-723: peps.python.org PEP-735: peps.python.org uv: docs.astral.sh uv workspaces: blobs.talkpython.fm prek.j178.dev: prek.j178.dev your presentation at FOSDEM26: fosdem.org Tallyman: github.com Watch this episode on YouTube: youtube.com Episode #540 deep-dive: talkpython.fm/540 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Scott on LinkedIn Black Dog Ventures Mike on LinkedIn Coder Radio on Discord The Mad Botter Inc Alice Limited Offer Mike's Book Mike's Blog

You're adding type hints to your Python code, your editor is happy, autocomplete is working great. But then you switch tools and suddenly there are red squiggles everywhere. Who decides what a float annotation actually means? Or whether passing None where an int is expected should be an error? It turns out there's a five-person council dedicated to exactly these questions -- and two brand-new Rust-based type checkers are raising the bar. On this episode, I sit down with three members of the Python Typing Council -- Jelle Zijlstra, Rebecca Chen, and Carl Meyer -- to learn how the type system is governed, where the spec and the type checkers agree and disagree, and get the council's official advice on how much typing is just enough. Episode sponsors Sentry Error Monitoring, Code talkpython26 Agentic AI Course Talk Python Courses Links from the show Guests Carl Meyer: github.com Jelle Zijlstra: jellezijlstra.github.io Rebecca Chen: github.com Typing Council: github.com typing.python.org: typing.python.org details here: github.com ty: docs.astral.sh pyrefly: pyrefly.org conformance test suite project: github.com typeshed: github.com Stub files: mypy.readthedocs.io Pydantic: pydantic.dev Beartype: github.com TOAD AI: github.com PEP 747 – Annotating Type Forms: peps.python.org PEP 724 – Stricter Type Guards: peps.python.org Python Typing Repo (PRs and Issues): github.com Watch this episode on YouTube: youtube.com Episode #539 deep-dive: talkpython.fm/539 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Mike on LinkedIn Coder Radio on Discord Mike's Oryx Review Alice Alice Jumpstart Offer

Digital humanities sounds niche, until you realize it can mean a searchable archive of U.S. amendment proposals, Irish folklore, or pigment science in ancient art. Today I'm talking with David Flood from Harvard's DARTH team about an unglamorous problem: What happens when the grant ends but the website can't. His answer, static sites, client-side search, and sneaky Python. Let's dive in. Episode sponsors Sentry Error Monitoring, Code talkpython26 Command Book Talk Python Courses Links from the show Guest David Flood: davidaflood.com DARTH: digitalhumanities.fas.harvard.edu Amendments Project: digitalhumanities.fas.harvard.edu Fionn Folklore Database: fionnfolklore.org Mapping Color in History: iiif.harvard.edu Apatosaurus: apatosaurus.io Criticus: github.com github.com/palewire/django-bakery: github.com sigsim.acm.org/conf/pads/2026/blog/artifact-evaluation: sigsim.acm.org Hugo: gohugo.io Water Stories: waterstories.fas.harvard.edu Tsumeb Mine Notebook: tmn.fas.harvard.edu Dharma and Punya: dharmapunya2019.org Pagefind library: pagefind.app django_webassembly: github.com Astro Static Site Generator: astro.build PageFind Python Lib: pypi.org Frozen-Flask: frozen-flask.readthedocs.io Watch this episode on YouTube: youtube.com Episode #538 deep-dive: talkpython.fm/538 Episode transcripts: talkpython.fm Theme Song: Developer Rap

You love building web apps with Python, and HTMX got you excited about the hypermedia approach -- let the server drive the HTML, skip the JavaScript build step, keep things simple. But then you hit that last 10%: You need Alpine.js for interactivity, your state gets out of sync, and suddenly you're juggling two unrelated libraries that weren't designed to work together. What if there was a single 11-kilobyte framework that gave you everything HTMX and Alpine do, and more, with real-time updates, multiplayer collaboration out of the box, and performance so fast you're actually bottlenecked by the monitor's refresh rate? That's Datastar. On this episode, I sit down with its creator Delaney Gillilan, core maintainer Ben Croker, and Datastar convert Chris May to explore how this backend-driven, server-sent-events-first framework is changing the way full-stack developers think about the modern web. Episode sponsors Sentry Error Monitoring, Code talkpython26 Command Book Talk Python Courses Links from the show Guests Delaney Gillilan: linkedin.com Ben Croker: x.com Chris May: everydaysuperpowers.dev Datastar: data-star.dev HTMX: htmx.org AlpineJS: alpinejs.dev Core Attribute Tour: data-star.dev data-star.dev/examples: data-star.dev github.com/starfederation/datastar-python: github.com VSCode: marketplace.visualstudio.com OpenVSX: open-vsx.org PyCharm/Intellij plugin: plugins.jetbrains.com data-star.dev/datastar_pro: data-star.dev gg: discord.gg HTML-ivating your Django web app's experience with HTMX, AlpineJS, and streaming HTML - Chris May: www.youtube.com Senior Engineer tries Vibe Coding: www.youtube.com 1 Billion Checkboxes: checkboxes.andersmurphy.com Game of life example: example.andersmurphy.com Watch this episode on YouTube: youtube.com Episode #537 deep-dive: talkpython.fm/537 Episode transcripts: talkpython.fm Theme Song: Developer Rap

https://www.linkedin.com/in/brian-ogrady/ - my linkedin https://www.linkedin.com/company/qdrant/ - company linkedin https://qdrant.tech/contact-us - contact us https://github.com/qdrant/qdrant/ - Qdrant GH https://github.com/qdrant/qdrant-edge-demo - Qdrant Edge running on smart glasses Mike on LinkedIn Coder Radio on Discord Mike's Oryx Review Alice Alice Jumpstart Offer Vorpal Mike in USA Today

You've built your FastAPI app, it's running great locally, and now you want to share it with the world. But then reality hits -- containers, load balancers, HTTPS certificates, cloud consoles with 200 options. What if deploying was just one command? That's exactly what Sebastian Ramirez and the FastAPI Cloud team are building. On this episode, I sit down with Sebastian, Patrick Arminio, Savannah Ostrowski, and Jonathan Ehwald to go inside FastAPI Cloud, explore what it means to build a "Pythonic" cloud, and dig into how this commercial venture is actually making FastAPI the open-source project stronger than ever. Episode sponsors Command Book Python in Production Talk Python Courses Links from the show Guests Sebastián Ramírez: github.com Savannah Ostrowski: github.com Patrick Arminio: github.com Jonathan Ehwald: github.com FastAPI labs: fastapilabs.com quickstart: fastapicloud.com an episode on diskcache: talkpython.fm Fastar: github.com FastAPI: The Documentary: www.youtube.com Tailwind CSS Situation: adams-morning-walk.transistor.fm FastAPI Job Meme: fastapi.meme Migrate an Existing Project: fastapicloud.com Join the waitlist: fastapicloud.com Talk Python CLI Talk Python CLI Announcement: talkpython.fm Talk Python CLI GitHub: github.com Command Book Download Command Book: commandbookapp.com Announcement post: mkennedy.codes Watch this episode on YouTube: youtube.com Episode #536 deep-dive: talkpython.fm/536 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Building on the web is like working with the perfect clay. It's malleable and can become almost anything. But too often, frameworks try to hide the web's best parts away from us. Today, we're looking at PyView, a project that brings the real-time power of Phoenix LiveView directly into the Python world. I'm joined by Larry Ogrodnek to dive into PyView. Episode sponsors Talk Python Courses Python in Production Links from the show Guest Larry Ogrodnek: hachyderm.io pyview.rocks: pyview.rocks Phoenix LiveView: github.com this section: pyview.rocks Core Concepts: pyview.rocks Socket and Context: pyview.rocks Event Handling: pyview.rocks LiveComponents: pyview.rocks Routing: pyview.rocks Templating: pyview.rocks HTML Templates: pyview.rocks T-String Templates: pyview.rocks File Uploads: pyview.rocks Streams: pyview.rocks Sessions & Authentication: pyview.rocks Single-File Apps: pyview.rocks starlette: starlette.dev wsproto: github.com apscheduler: github.com t-dom project: github.com Watch this episode on YouTube: youtube.com Episode #535 deep-dive: talkpython.fm/535 Episode transcripts: talkpython.fm Theme Song: Developer Rap

RubyLLM (https://rubyllm.com/) Carmine (https://paolino.me/) Chat With Work (https://chatwithwork.com/) Carmine on X (https://x.com/paolino) Mike on LinkedIn (https://www.linkedin.com/in/dominucco/) Coder Radio on Discord (https://discord.gg/WnumdsfhYB) Alice (https://alice.dev/looking-glass/) Mike's 2026 Predictions Post (https://dominickm.com/set-a-course-for-2026/) Alice Jumpstart Offer (https://go.alice.dev/alice-azure-blob-to-snowflake-js)

Your cloud SSD is sitting there, bored, and it would like a job. Today we're putting it to work with DiskCache, a simple, practical cache built on SQLite that can speed things up without spinning up Redis or extra services. Once you start to see what it can do, a universe of possibilities opens up. We're joined by Vincent Warmerdam to dive into DiskCache. Episode sponsors Talk Python Courses Python in Production Links from the show diskcache docs: grantjenks.com LLM Building Blocks for Python course: training.talkpython.fm JSONDisk: grantjenks.com Git Code Archaeology Charts: koaning.github.io Talk Python Cache Admin UI: blobs.talkpython.fm Litestream SQLite streaming: litestream.io Plash hosting: pla.sh Watch this episode on YouTube: youtube.com Episode #534 deep-dive: talkpython.fm/534 Episode transcripts: talkpython.fm Theme Song: Developer Rap

ThousandEyes (https://www.thousandeyes.com/) Murtaza on LinkedIn (https://www.linkedin.com/in/mdoctor/) Internet Outages Map (https://www.thousandeyes.com/outages/) ThousandEyesJob Openings (https://careers.cisco.com/global/en/thousandeyes) Mike on LinkedIn (https://www.linkedin.com/in/dominucco/) Coder Radio on Discord (https://discord.gg/WnumdsfhYB) Alice (https://alice.dev/looking-glass/) Mike's 2026 Predictions Post (https://dominickm.com/set-a-course-for-2026/) Alice Jumpstart Offer (https://go.alice.dev/alice-azure-blob-to-snowflake-js)

Today on Talk Python, the creators behind FastAPI, Flask, Django, Quart, and Litestar get practical about running apps based on their framework in production. Deployment patterns, async gotchas, servers, scaling, and the stuff you only learn at 2 a.m. when the pager goes off. For Django, we have Carlton Gibson and Jeff Triplet. For Flask, we have David Lord and Phil Jones, and on team Litestar we have Janek Nouvertné and Cody Fincher, and finally Sebastián Ramírez from FastAPI is here. Let's jump in. Episode sponsors Talk Python Courses Python in Production Links from the show Carlton Gibson - Django: github.com Sebastian Ramirez - FastAPI: github.com David Lord - Flask: davidism.com Phil Jones - Flask and Quartz(async): pgjones.dev Yanik Nouvertne - LiteStar: github.com Cody Fincher - LiteStar: github.com Jeff Triplett - Django: jefftriplett.com Django: www.djangoproject.com Flask: flask.palletsprojects.com Quart: quart.palletsprojects.com Litestar: litestar.dev FastAPI: fastapi.tiangolo.com Coolify: coolify.io ASGI: asgi.readthedocs.io WSGI (PEP 3333): peps.python.org Granian: github.com Hypercorn: github.com uvicorn: uvicorn.dev Gunicorn: gunicorn.org Hypercorn: hypercorn.readthedocs.io Daphne: github.com Nginx: nginx.org Docker: www.docker.com Kubernetes: kubernetes.io PostgreSQL: www.postgresql.org SQLite: www.sqlite.org Celery: docs.celeryq.dev SQLAlchemy: www.sqlalchemy.org Django REST framework: www.django-rest-framework.org Jinja: jinja.palletsprojects.com Click: click.palletsprojects.com HTMX: htmx.org Server-Sent Events (SSE): developer.mozilla.org WebSockets (RFC 6455): www.rfc-editor.org HTTP/2 (RFC 9113): www.rfc-editor.org HTTP/3 (RFC 9114): www.rfc-editor.org uv: docs.astral.sh Amazon Web Services (AWS): aws.amazon.com Microsoft Azure: azure.microsoft.com Google Cloud Run: cloud.google.com Amazon ECS: aws.amazon.com AlloyDB for PostgreSQL: cloud.google.com Fly.io: fly.io Render: render.com Cloudflare: www.cloudflare.com Fastly: www.fastly.com Watch this episode on YouTube: youtube.com Episode #533 deep-dive: talkpython.fm/533 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Python in 2025 is in a delightfully refreshing place: the GIL's days are numbered, packaging is getting sharper tools, and the type checkers are multiplying like gremlins snacking after midnight. On this episode, we have an amazing panel to give us a range of perspectives on what matter in 2025 in Python. We have Barry Warsaw, Brett Cannon, Gregory Kapfhammer, Jodie Burchell, Reuven Lerner, and Thomas Wouters on to give us their thoughts. Episode sponsors Seer: AI Debugging, Code TALKPYTHON Talk Python Courses Links from the show Python Software Foundation (PSF): www.python.org PEP 810: Explicit lazy imports: peps.python.org PEP 779: Free-threaded Python is officially supported: peps.python.org PEP 723: Inline script metadata: peps.python.org PyCharm: www.jetbrains.com JetBrains: www.jetbrains.com Visual Studio Code: code.visualstudio.com pandas: pandas.pydata.org PydanticAI: ai.pydantic.dev OpenAI API docs: platform.openai.com uv: docs.astral.sh Hatch: github.com PDM: pdm-project.org Poetry: python-poetry.org Project Jupyter: jupyter.org JupyterLite: jupyterlite.readthedocs.io PEP 690: Lazy Imports: peps.python.org PyTorch: pytorch.org Python concurrent.futures: docs.python.org Python Package Index (PyPI): pypi.org EuroPython: tickets.europython.eu TensorFlow: www.tensorflow.org Keras: keras.io PyCon US: us.pycon.org NumFOCUS: numfocus.org Python discussion forum (discuss.python.org): discuss.python.org Language Server Protocol: microsoft.github.io mypy: mypy-lang.org Pyright: github.com Pylance: marketplace.visualstudio.com Pyrefly: github.com ty: github.com Zuban: docs.zubanls.com Jedi: jedi.readthedocs.io GitHub: github.com PyOhio: www.pyohio.org Watch this episode on YouTube: youtube.com Episode #532 deep-dive: talkpython.fm/532 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Mike's Year End Post (https://dominickm.com/2025-year-end-retrospective/) Mike on LinkedIn (https://www.linkedin.com/in/dominucco/) Mike's Blog (https://dominickm.com) Show on Discord (https://discord.com/invite/k8e7gKUpEp) Alice Promo (https://go.alice.dev/data-migration-offer-hands-on) Dreamcast assorted references: Dreamcast overview https://sega.fandom.com/wiki/Dreamcast History of Dreamcast development https://segaretro.org/HistoryoftheSegaDreamcast/Development The Rise and Fall of the Dreamcast: A Legend Gone Too Soon (Simon Jenner) https://sabukaru.online/articles/he-rise-and-fall-of-the-dreamcast-a-legend-gone-too-soon The Legacy of the Sega Dreamcast | 20 Years Later https://medium.com/@Amerinofu/the-legacy-of-the-sega-dreamcast-20-years-later-d6f3d2f7351c Socials & Plugs The R Podcast https://r-podcast.org/ R Weekly Highlights https://serve.podhome.fm/r-weekly-highlights Shiny Developer Series https://shinydevseries.com/ Eric on Bluesky https://bsky.app/profile/rpodcast.bsky.social Eric on Mastodon https://podcastindex.social/@rpodcast Eric on LinkedIn https://www.linkedin.com/in/eric-nantz-6621617/

Have you ever thought about getting your small product into production, but are worried about the cost of the big cloud providers? Or maybe you think your current cloud service is over-architected and costing you too much? Well, in this episode, we interview Michael Kennedy, author of "Talk Python in Production," a new book that guides you through deploying web apps at scale with right-sized engineering. Episode sponsors Seer: AI Debugging, Code TALKPYTHON Agntcy Talk Python Courses Links from the show Christopher Trudeau - guest host: www.linkedin.com Michael's personal site: mkennedy.codes Talk Python in Production Book: talkpython.fm glances: github.com btop: github.com Uptimekuma: uptimekuma.org Coolify: coolify.io Talk Python Blog: talkpython.fm Hetzner (€20 credit with link): hetzner.cloud OpalStack: www.opalstack.com Bunny.net CDN: bunny.net Galleries from the book: github.com Pandoc: pandoc.org Docker: www.docker.com Watch this episode on YouTube: youtube.com Episode #531 deep-dive: talkpython.fm/531 Episode transcripts: talkpython.fm Theme Song: Developer Rap

For years, building interactive widgets in Python notebooks meant wrestling with toolchains, platform quirks, and a mountain of JavaScript machinery. Most developers took one look and backed away slowly. Trevor Manz decided that barrier did not need to exist. His idea was simple: give Python users just enough JavaScript to unlock the web's interactivity, without dragging along the rest of the web ecosystem. That idea became anywidget, and it is quickly becoming the quiet connective tissue of modern interactive computing. Today we dig into how it works, why it has taken off, and how it might change the way we explore data. Episode sponsors Seer: AI Debugging, Code TALKPYTHON PyCharm, code STRONGER PYTHON Talk Python Courses Links from the show Trevor on GitHub: github.com anywidget GitHub: github.com Trevor's SciPy 2024 Talk: www.youtube.com Marimo GitHub: github.com Myst (Markdown docs): mystmd.org Altair: altair-viz.github.io DuckDB: duckdb.org Mosaic: uwdata.github.io ipywidgets: ipywidgets.readthedocs.io Tension between Web and Data Sci Graphic: blobs.talkpython.fm Quak: github.com Walk through building a widget: anywidget.dev Widget Gallery: anywidget.dev Video: How do I anywidget?: www.youtube.com PyCharm + PSF Fundraiser: pycharm-psf-2025 code STRONGER PYTHON Watch this episode on YouTube: youtube.com Episode #530 deep-dive: talkpython.fm/530 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Tabnine (https://www.tabnine.com/) Eran on LinkedIn (https://www.linkedin.com/in/eranyahav/) Alice for Snowflake (https://alice.dev/alice-snowflake/) Mike on X (https://x.com/dominucco) Coder on X (https://x.com/coderradioshow) Show Discord (https://discord.gg/k8e7gKUpEp) Alice & Custom Dev (https://alice.dev)

Frank on LinkedIn (https://www.linkedin.com/in/franckpachot/) MongoDB (https://www.mongodb.com/) Alice for Snowflake (https://alice.dev/alice-snowflake/) Mike on X (https://x.com/dominucco) Coder on X (https://x.com/coderradioshow) Show Discord (https://discord.gg/k8e7gKUpEp) Alice & Custom Dev (https://alice.dev) Mike's Recent Omakub Blog Post (https://dominickm.com/omakhub-review/)

A lot of people building software today never took the traditional CS path. They arrived through curiosity, a job that needed automating, or a late-night itch to make something work. This week, David Kopec joins me to talk about rebuilding computer science for exactly those folks, the ones who learned to program first and are now ready to understand the deeper ideas that power the tools they use every day. Episode sponsors Sentry Error Monitoring, Code TALKPYTHON NordStellar Talk Python Courses Links from the show David Kopec: davekopec.com Classic Computer Science Book: amazon.com Computer Science from Scratch Book: computersciencefromscratch.com Computer Science from Scratch at NoStartch (CSFS30 for 30% off): nostarch.com Watch this episode on YouTube: youtube.com Episode #529 deep-dive: talkpython.fm/529 Episode transcripts: talkpython.fm Theme Song: Developer Rap

In this episode, I'm talking with Vincent Warmerdam about treating LLMs as just another API in your Python app, with clear boundaries, small focused endpoints, and good monitoring. We'll dig into patterns for wrapping these calls, caching and inspecting responses, and deciding where an LLM API actually earns its keep in your architecture. Episode sponsors Seer: AI Debugging, Code TALKPYTHON NordStellar Talk Python Courses Links from the show Vincent on X: @fishnets88 Vincent on Mastodon: @koaning LLM Building Blocks for Python Co-urse: training.talkpython.fm Top Talk Python Episodes of 2024: talkpython.fm LLM Usage - Datasette: llm.datasette.io DiskCache - Disk Backed Cache (Documentation): grantjenks.com smartfunc - Turn docstrings into LLM-functions: github.com Ollama: ollama.com LM Studio - Local AI: lmstudio.ai marimo - A Next-Generation Python Notebook: marimo.io Pydantic: pydantic.dev Instructor - Complex Schemas & Validation (Python): python.useinstructor.com Diving into PydanticAI with marimo: youtube.com Cline - AI Coding Agent: cline.bot OpenRouter - The Unified Interface For LLMs: openrouter.ai Leafcloud: leaf.cloud OpenAI looks for its "Google Chrome" moment with new Atlas web browser: arstechnica.com Watch this episode on YouTube: youtube.com Episode #528 deep-dive: talkpython.fm/528 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Today we're digging into the Model Context Protocol, or MCP. Think LSP for AI: build a small Python service once and your tools and data show up across editors and agents like VS Code, Claude Code, and more. My guest, Den Delimarsky from Microsoft, helps build this space and will keep us honest about what's solid versus what's just shiny. We'll keep it practical: transports that actually work, guardrails you can trust, and a tiny server you could ship this week. By the end, you'll have a clear mental model and a path to plug Python into the internet of agents. Episode sponsors Sentry AI Monitoring, Code TALKPYTHON NordStellar Talk Python Courses Links from the show Den Delimarsky: den.dev Agentic AI Programming for Python Course: training.talkpython.fm Model Context Protocol: modelcontextprotocol.io Model Context Protocol Specification (2025-03-26): modelcontextprotocol.io MCP Python Package (PyPI): pypi.org Awesome MCP Servers (punkpeye) GitHub Repo: github.com Visual Studio Code Docs: Copilot MCP Servers: code.visualstudio.com GitHub MCP Server (GitHub repo): github.com GitHub Blog: Meet the GitHub MCP Registry: github.blog MultiViewer App: multiviewer.app GitHub Blog: Spec-driven development with AI (open source toolkit): github.blog Model Context Protocol Registry (GitHub): github.com mcp (GitHub organization): github.com Tailscale: tailscale.com Watch this episode on YouTube: youtube.com Episode #527 deep-dive: talkpython.fm/527 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Today, we're talking about building real AI products with foundation models. Not toy demos, not vibes. We'll get into the boring dashboards that save launches, evals that change your mind, and the shift from analyst to AI app builder. Our guide is Hugo Bowne-Anderson, educator, podcaster, and data scientist, who's been in the trenches from scalable Python to LLM apps. If you care about shipping LLM features without burning the house down, stick around. Episode sponsors Posit NordStellar Talk Python Courses Links from the show Hugo Bowne-Anderson: x.com Vanishing Gradients Podcast: vanishinggradients.fireside.fm Fundamentals of Dask: High Performance Data Science Course: training.talkpython.fm Building LLM Applications for Data Scientists and Software Engineers: maven.com marimo: a next-generation Python notebook: marimo.io DevDocs (Offline aggregated docs): devdocs.io Elgato Stream Deck: elgato.com Sentry's Seer: talkpython.fm The End of Programming as We Know It: oreilly.com LorikeetCX AI Concierge: lorikeetcx.ai Text to SQL & AI Query Generator: text2sql.ai Inverse relationship enthusiasm for AI and traditional projects: oreilly.com Watch this episode on YouTube: youtube.com Episode #526 deep-dive: talkpython.fm/526 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Building a UI in Python usually means choosing between "quick and limited" or "powerful and painful." What if you could write modern, component-based web apps in pure Python and still keep full control? NiceGUI, pronounced "Nice Guy" sits on FastAPI with a Vue/Quasar front end, gives you real components, live updates over websockets, and it's running in production at Zauberzeug, a German robotic company. On this episode, I'm talking with NiceGUI's creators, Rodja Trappe and Falko Schindler, about how it works, where it shines, and what's coming next. With version 3.0 releasing around the same time this episode comes out, we spend the end of the episode celebrating the 3.0 release. Episode sponsors Posit Agntcy Talk Python Courses Links from the show Rodja Trappe: github.com Falko Schindler: github.com NiceGUI 3.0.0 release: github.com Full LLM/Agentic AI docs instructions for NiceGUI: github.com Zauberzeug: zauberzeug.com NiceGUI: nicegui.io NiceGUI GitHub Repository: github.com NiceGUI Authentication Examples: github.com NiceGUI v3.0.0rc1 Release: github.com Valkey: valkey.io Caddy Web Server: caddyserver.com JustPy: justpy.io Tailwind CSS: tailwindcss.com Quasar ECharts v5 Demo: quasar-echarts-v5.netlify.app AG Grid: ag-grid.com Quasar Framework: quasar.dev NiceGUI Interactive Image Documentation: nicegui.io NiceGUI 3D Scene Documentation: nicegui.io Watch this episode on YouTube: youtube.com Episode #525 deep-dive: talkpython.fm/525 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Python in 2025 is different. Threads really are about to run in parallel, installs finish before your coffee cools, and containers are the default. In this episode, we count down 38 things to learn this year: free-threaded CPython, uv for packaging, Docker and Compose, Kubernetes with Tilt, DuckDB and Arrow, PyScript at the edge, plus MCP for sane AI workflows. Expect practical wins and migration paths. No buzzword bingo, just what pays off in real apps. Join me along with Peter Wang and Calvin Hendrix-Parker for a fun, fast-moving conversation. Episode sponsors Seer: AI Debugging, Code TALKPYTHON Agntcy Talk Python Courses Links from the show Calvin Hendryx-Parker: github.com/calvinhp Peter on BSky: @wang.social Free-Threaded Wheels: hugovk.github.io Tilt: tilt.dev The Five Demons of Python Packaging That Fuel Our ...: youtube.com Talos Linux: talos.dev Docker: Accelerated Container Application Development: docker.com Scaf - Six Feet Up: sixfeetup.com BeeWare: beeware.org PyScript: pyscript.net Cursor: The best way to code with AI: cursor.com Cline - AI Coding, Open Source and Uncompromised: cline.bot Watch this episode on YouTube: youtube.com Episode #524 deep-dive: talkpython.fm/524 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Python typing got fast enough to feel invisible. Pyrefly is a new, open source type checker and IDE language server from Meta, written in Rust, with a focus on instant feedback and real-world DX. Today, we will dig into what it is, why it exists, and how it plays with the rest of the typing ecosystem. We have Abby Mitchell, Danny Yang, and Kyle Into from Pyrefly here to dive into the project. Episode sponsors Sentry Error Monitoring, Code TALKPYTHON Agntcy Talk Python Courses Links from the show Abby Mitchell: linkedin.com Danny Yang: linkedin.com Kyle Into: linkedin.com Pyrefly: pyrefly.org Pyrefly Documentation: pyrefly.org Pyrefly Installation Guide: pyrefly.org Pyrefly IDE Guide: pyrefly.org Pyrefly GitHub Repository: github.com Pyrefly VS Code Extension: marketplace.visualstudio.com Introducing Pyrefly: A New Type Checker and IDE Experience for Python: engineering.fb.com Pyrefly on PyPI: pypi.org InfoQ Coverage: Meta Pyrefly Python Typechecker: infoq.com Pyrefly Discord Invite: discord.gg Python Typing Conformance (GitHub): github.com Typing Conformance Leaderboard (HTML Preview): htmlpreview.github.io Watch this episode on YouTube: youtube.com Episode #523 deep-dive: talkpython.fm/523 Episode transcripts: talkpython.fm Theme Song: Developer Rap

Today we're turning tiny tips into big wins. Khuyen Tran, creator of CodeCut.ai, has shipped hundreds of bite-size Python and data science snippets across four years. We dig into open-source tools you can use right now, cleaner workflows, and why notebooks and scripts don't have to be enemies. If you want faster insights with fewer yak-shaves, this one's packed with takeaways you can apply before lunch. Let's get into it. Episode sponsors Sentry Error Monitoring, Code TALKPYTHON Agntcy Talk Python Courses Links from the show Khuyen Tran (LinkedIn): linkedin.com Khuyen Tran (GitHub): github.com CodeCut: codecut.ai Production-ready Data Science Book (discount code TalkPython): codecut.ai Why UV Might Be All You Need: codecut.ai How to Structure a Data Science Project for Readability and Transparency: codecut.ai Stop Hard-coding: Use Configuration Files Instead: codecut.ai Simplify Your Python Logging with Loguru: codecut.ai Git for Data Scientists: Learn Git Through Practical Examples: codecut.ai Marimo (A Modern Notebook for Reproducible Data Science): codecut.ai Text Similarity & Fuzzy Matching Guide: codecut.ai Loguru (Python logging made simple): github.com Hydra: hydra.cc Marimo: marimo.io Quarto: quarto.org Show Your Work! Book: austinkleon.com Watch this episode on YouTube: youtube.com Episode #522 deep-dive: talkpython.fm/522 Episode transcripts: talkpython.fm Theme Song: Developer Rap

English is now an API. Our apps read untrusted text; they follow instructions hidden in plain sight, and sometimes they turn that text into action. If you connect a model to tools or let it read documents from the wild, you have created a brand new attack surface. In this episode, we will make that concrete. We will talk about the attacks teams are seeing in 2025, the defenses that actually work, and how to test those defenses the same way we test code. Our guides are Tori Westerhoff and Roman Lutz from Microsoft. They help lead AI red teaming and build PyRIT, a Python framework the Microsoft AI Red Team uses to pressure test real products. By the end of this hour you will know where the biggest risks live, what you can ship this quarter to reduce them, and how PyRIT can turn security from a one time audit into an everyday engineering practice. Episode sponsors Sentry AI Monitoring, Code TALKPYTHON Agntcy Talk Python Courses Links from the show Tori Westerhoff: linkedin.com Roman Lutz: linkedin.com PyRIT: aka.ms/pyrit Microsoft AI Red Team page: learn.microsoft.com 2025 Top 10 Risk & Mitigations for LLMs and Gen AI Apps: genai.owasp.org AI Red Teaming Agent: learn.microsoft.com 3 takeaways from red teaming 100 generative AI products: microsoft.com MIT report: 95% of generative AI pilots at companies are failing: fortune.com A couple of "Little Bobby AI" cartoons Give me candy: talkpython.fm Tell me a joke: talkpython.fm Watch this episode on YouTube: youtube.com Episode #521 deep-dive: talkpython.fm/521 Episode transcripts: talkpython.fm Developer Rap Theme Song: Served in a Flask: talkpython.fm/flasksong --- Stay in touch with us --- Subscribe to Talk Python on YouTube: youtube.com Talk Python on Bluesky: @talkpython.fm at bsky.app Talk Python on Mastodon: talkpython Michael on Bluesky: @mkennedy.codes at bsky.app Michael on Mastodon: mkennedy