Vanishing Gradients - Episodes Tagged with “Ai”

Episode 63: Why Gemini 3 Will Change How You Build AI Agents with Ravin Kumar (Google DeepMind)

Hugo Bowne-Anderson — Sat, 22 Nov 2025 18:30:00 +1100

Gemini 3 is a few days old and the massive leap in performance and model reasoning has big implications for builders: as models begin to self-heal, builders are literally tearing out the functionality they built just months ago... ripping out the defensive coding and reshipping their agent harnesses entirely.

Ravin Kumar (Google DeepMind) joins Hugo to breaks down exactly why the rapid evolution of models like Gemini 3 is changing how we build software. They detail the shift from simple tool calling to building reliable "Agent Harnesses", explore the architectural tradeoffs between deterministic workflows and high-agency systems, the nuance of preventing context rot in massive windows, and why proper evaluation infrastructure is the only way to manage the chaos of autonomous loops.

They talk through:

The implications of models that can "self-heal" and fix their own code
The two cultures of agents: LLM workflows with a few tools versus when you should unleash high-agency, autonomous systems.
Inside NotebookLM: moving from prototypes to viral production features like Audio Overviews
Why Needle in a Haystack benchmarks often fail to predict real-world performance
How to build agent harnesses that turn model capabilities into product velocity
The shift from measuring latency to managing time-to-compute for reasoning tasks

LINKS

Join the final cohort of our Building AI Applications course starting March 10, 2026 (25% off for listeners): https://maven.com/hugo-stefan/building-ai-apps-ds-and-swe-from-first-principles?promoCode=vgfs

Episode 62: Practical AI at Work: How Execs and Developers Can Actually Use LLMs

Hugo Bowne-Anderson — Fri, 31 Oct 2025 18:00:00 +1100

Many leaders are trapped between chasing ambitious, ill-defined AI projects and the paralysis of not knowing where to start. Dr. Randall Olson argues that the real opportunity isn't in moonshots, but in the "trillions of dollars of business value" available right now. As co-founder of Wyrd Studios, he bridges the gap between data science, AI engineering, and executive strategy to deliver a practical framework for execution.

In this episode, Randy and Hugo lay out how to find and solve what might be considered "boring but valuable" problems, like an EdTech company automating 20% of its support tickets with a simple retrieval bot instead of a complex AI tutor. They discuss how to move incrementally along the "agentic spectrum" and why treating AI evaluation with the same rigor as software engineering is non-negotiable for building a disciplined, high-impact AI strategy.

They talk through:

How a non-technical leader can prototype a complex insurance claim classifier using just photos and a ChatGPT subscription.
The agentic spectrum: Why you should start by automating meeting summaries before attempting to build fully autonomous agents.
The practical first step for any executive: Building a personal knowledge base with meeting transcripts and strategy docs to get tailored AI advice.
Why treating AI evaluation with the same rigor as unit testing is essential for shipping reliable products.
The organizational shift required to unlock long-term AI gains, even if it means a short-term productivity dip.

LINKS

🎓 Learn more:

Next cohort starts November 3: come build with us!

Episode 61: The AI Agent Reliability Cliff: What Happens When Tools Fail in Production

Hugo Bowne-Anderson — Thu, 16 Oct 2025 14:00:00 +1100

Most AI teams find their multi-agent systems devolving into chaos, but ML Engineer Alex Strick van Linschoten argues they are ignoring the production reality. In this episode, he draws on insights from the LLM Ops Database (750+ real-world deployments then; now nearly 1,000!) to systematically measure and engineer constraint, turning unreliable prototypes into robust, enterprise-ready AI.

Drawing from his work at Zen ML, Alex details why success requires scaling down and enforcing MLOps discipline to navigate the unpredictable "Agent Reliability Cliff". He provides the essential architectural shifts, evaluation hygiene techniques, and practical steps needed to move beyond guesswork and build scalable, trustworthy AI products.

We talk through:

Why "shoving a thousand agents" into an app is the fastest route to unmanageable chaos
The essential MLOps hygiene (tracing and continuous evals) that most teams skip
The optimal (and very low) limit for the number of tools an agent can reliably use
How to use human-in-the-loop strategies to manage the risk of autonomous failure in high-sensitivity domains
The principle of using simple Python/RegEx before resorting to costly LLM judges

LINKS

🎓 Learn more:

Episode 60: 10 Things I Hate About AI Evals with Hamel Husain

Hugo Bowne-Anderson — Tue, 30 Sep 2025 17:30:00 +1000

Most AI teams find "evals" frustrating, but ML Engineer Hamel Husain argues they’re just using the wrong playbook. In this episode, he lays out a data-centric approach to systematically measure and improve AI, turning unreliable prototypes into robust, production-ready systems.

Drawing from his experience getting countless teams unstuck, Hamel explains why the solution requires a "revenge of the data scientists." He details the essential mindset shifts, error analysis techniques, and practical steps needed to move beyond guesswork and build AI products you can actually trust.

We talk through:

The 10(+1) critical mistakes that cause teams to waste time on evals
Why "hallucination scores" are a waste of time (and what to measure instead)
The manual review process that finds major issues in hours, not weeks
A step-by-step method for building LLM judges you can actually trust
How to use domain experts without getting stuck in endless review committees
Guest Bryan Bischof's "Failure as a Funnel" for debugging complex AI agents

If you're tired of ambiguous "vibe checks" and want a clear process that delivers real improvement, this episode provides the definitive roadmap.

LINKS

🎓 Learn more:

Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338

Episode 59: Patterns and Anti-Patterns For Building with AI

Hugo Bowne-Anderson — Wed, 24 Sep 2025 09:30:00 +1000

John Berryman (Arcturus Labs; early GitHub Copilot engineer; co-author of Relevant Search and Prompt Engineering for LLMs) has spent years figuring out what makes AI applications actually work in production. In this episode, he shares the “seven deadly sins” of LLM development — and the practical fixes that keep projects from stalling.

From context management to retrieval debugging, John explains the patterns he’s seen succeed, the mistakes to avoid, and why it helps to think of an LLM as an “AI intern” rather than an all-knowing oracle.

We talk through:

Why chasing perfect accuracy is a dead end
How to use agents without losing control
Context engineering: fitting the right information in the window
Starting simple instead of over-orchestrating
Separating retrieval from generation in RAG
Splitting complex extractions into smaller checks
Knowing when frameworks help — and when they slow you down

A practical guide to avoiding the common traps of LLM development and building systems that actually hold up in production.

LINKS:

🎓 Learn more:

Hugo's course (this episode was a guest Q&A from the course): Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338

Episode 54: Scaling AI: From Colab to Clusters — A Practitioner’s Guide to Distributed Training and Inference

Hugo Bowne-Anderson — Sat, 19 Jul 2025 02:00:00 +1000

Colab is cozy. But production won’t fit on a single GPU.
Zach Mueller leads Accelerate at Hugging Face and spends his days helping people go from solo scripts to scalable systems. In this episode, he joins me to demystify distributed training and inference — not just for research labs, but for any ML engineer trying to ship real software.

We talk through:
• From Colab to clusters: why scaling isn’t just about training massive models, but serving agents, handling load, and speeding up iteration
• Zero-to-two GPUs: how to get started without Kubernetes, Slurm, or a PhD in networking
• Scaling tradeoffs: when to care about interconnects, which infra bottlenecks actually matter, and how to avoid chasing performance ghosts
• The GPU middle class: strategies for training and serving on a shoestring, with just a few cards or modest credits
• Local experiments, global impact: why learning distributed systems—even just a little—can set you apart as an engineer

If you’ve ever stared at a Hugging Face training script and wondered how to run it on something more than your laptop: this one’s for you.

LINKS

🎓 Learn more:

Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338
Zach's course (45% off for VG listeners!): Scratch to Scale: Large-Scale Training in the Modern World -- https://maven.com/walk-with-code/scratch-to-scale?promoCode=hugo39

📺 Watch the video version on YouTube: YouTube link

Episode 52: Why Most LLM Products Break at Retrieval (And How to Fix Them)

Hugo Bowne-Anderson — Thu, 03 Jul 2025 02:00:00 +1000

Most LLM-powered features do not break at the model. They break at the context. So how do you retrieve the right information to get useful results, even under vague or messy user queries?

In this episode, we hear from Eric Ma, who leads data science research in the Data Science and AI group at Moderna. He shares what it takes to move beyond toy demos and ship LLM features that actually help people do their jobs.

We cover:
• How to align retrieval with user intent and why cosine similarity is not the answer
• How a dumb YAML-based system outperformed so-called smart retrieval pipelines
• Why vague queries like “what is this all about” expose real weaknesses in most systems
• When vibe checks are enough and when formal evaluation is worth the effort
• How retrieval workflows can evolve alongside your product and user needs

If you are building LLM-powered systems and care about how they work, not just whether they work, this one is for you.

LINKS

🎓 Learn more:

Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — next cohort starts July 8: https://maven.com/s/course/d56067f338

📺 Watch the video version on YouTube: YouTube link

Episode 51: Why We Built an MCP Server and What Broke First

Hugo Bowne-Anderson — Fri, 27 Jun 2025 03:00:00 +1000

What does it take to actually ship LLM-powered features, and what breaks when you connect them to real production data?

In this episode, we hear from Philip Carter — then a Principal PM at Honeycomb and now a Product Management Director at Salesforce. In early 2023, he helped build one of the first LLM-powered SaaS features to ship to real users. More recently, he and his team built a production-ready MCP server.

We cover:
• How to evaluate LLM systems using human-aligned judges
• The spreadsheet-driven process behind shipping Honeycomb’s first LLM feature
• The challenges of tool usage, prompt templates, and flaky model behavior
• Where MCP shows promise, and where it breaks in the real world

If you’re working on LLMs in production, this one’s for you!

LINKS

🎓 Learn more:

Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — next cohort starts July 8: https://maven.com/s/course/d56067f338

📺 Watch the video version on YouTube: YouTube link

Episode 50: A Field Guide to Rapidly Improving AI Products -- With Hamel Husain

Hugo Bowne-Anderson — Tue, 17 Jun 2025 18:30:00 +1000

If we want AI systems that actually work, we need to get much better at evaluating them, not just building more pipelines, agents, and frameworks.

In this episode, Hugo talks with Hamel Hussain (ex-Airbnb, GitHub, DataRobot) about how teams can improve AI products by focusing on error analysis, data inspection, and systematic iteration. The conversation is based on Hamel’s blog post A Field Guide to Rapidly Improving AI Products, which he joined Hugo’s class to discuss.

They cover:
🔍 Why most teams struggle to measure whether their systems are actually improving

📊 How error analysis helps you prioritize what to fix (and when to write evals)

🧮 Why evaluation isn’t just a metric — but a full development process

⚠️ Common mistakes when debugging LLM and agent systems

🛠️ How to think about the tradeoffs in adding more evals vs. fixing obvious issues

👥 Why enabling domain experts — not just engineers — can accelerate iteration

If you’ve ever built an AI system and found yourself unsure how to make it better, this conversation is for you.

LINKS

🎓 Learn more:

Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — next cohort starts July 8: https://maven.com/s/course/d56067f338
Hamel & Shreya's course: AI Evals For Engineers & PMs — use code GOHUGORGOHOME for $800 off

📺 Watch the video version on YouTube: YouTube link

Episode 49: Why Data and AI Still Break at Scale (and What to Do About It)

Hugo Bowne-Anderson — Thu, 05 Jun 2025 14:00:00 +1000

If we want AI systems that actually work in production, we need better infrastructure—not just better models.

In this episode, Hugo talks with Akshay Agrawal (Marimo, ex-Google Brain, Netflix, Stanford) about why data and AI pipelines still break down at scale, and how we can fix the fundamentals: reproducibility, composability, and reliable execution.

They discuss:
🔁 Why reactive execution matters—and how current tools fall short
🛠️ The design goals behind Marimo, a new kind of Python notebook
⚙️ The hidden costs of traditional workflows (and what breaks at scale)
📦 What it takes to build modular, maintainable AI apps
🧪 Why debugging LLM systems is so hard—and what better tooling looks like
🌍 What we can learn from decades of tools built for and by data practitioners

Toward the end of the episode, Hugo and Akshay walk through two live demos: Hugo shares how he’s been using Marimo to prototype an app that extracts structured data from world leader bios, and Akshay shows how Marimo handles agentic workflows with memory and tool use—built entirely in a notebook.

This episode is about tools, but it’s also about culture. If you’ve ever hit a wall with your current stack—or felt like your tools were working against you—this one’s for you.

LINKS

🎓 Want to go deeper?
Check out Hugo's course: Building LLM Applications for Data Scientists and Software Engineers.
Learn how to design, test, and deploy production-grade LLM systems — with observability, feedback loops, and structure built in.
This isn’t about vibes or fragile agents. It’s about making LLMs reliable, testable, and actually useful.

Includes over $800 in compute credits and guest lectures from experts at DeepMind, Moderna, and more.
Cohort starts July 8 — Use this link for a 10% discount

Episode 48: HOW TO BENCHMARK AGI WITH GREG KAMRADT

Hugo Bowne-Anderson — Fri, 23 May 2025 23:00:00 +1000

If we want to make progress toward AGI, we need a clear definition of intelligence—and a way to measure it.

In this episode, Hugo talks with Greg Kamradt, President of the ARC Prize Foundation, about ARC-AGI: a benchmark built on Francois Chollet’s definition of intelligence as “the efficiency at which you learn new things.” Unlike most evals that focus on memorization or task completion, ARC is designed to measure generalization—and expose where today’s top models fall short.

They discuss:
🧠 Why we still lack a shared definition of intelligence
🧪 How ARC tasks force models to learn novel skills at test time
📉 Why GPT-4-class models still underperform on ARC
🔎 The limits of traditional benchmarks like MMLU and Big-Bench
⚙️ What the OpenAI O₃ results reveal—and what they don’t
💡 Why generalization and efficiency, not raw capability, are key to AGI

Greg also shares what he’s seeing in the wild: how startups and independent researchers are using ARC as a North Star, how benchmarks shape the frontier, and why the ARC team believes we’ll know we’ve reached AGI when humans can no longer write tasks that models can’t solve.

This conversation is about evaluation—not hype. If you care about where AI is really headed, this one’s worth your time.

LINKS

Includes over $800 in compute credits and guest lectures from experts at DeepMind, Moderna, and more.
Cohort starts July 8 — Use this link for a 10% discount

Episode 47: The Great Pacific Garbage Patch of Code Slop with Joe Reis

Hugo Bowne-Anderson — Mon, 07 Apr 2025 10:00:00 +1000

What if the cost of writing code dropped to zero — but the cost of understanding it skyrocketed?

In this episode, Hugo sits down with Joe Reis to unpack how AI tooling is reshaping the software development lifecycle — from experimentation and prototyping to deployment, maintainability, and everything in between.

Joe is the co-author of Fundamentals of Data Engineering and a longtime voice on the systems side of modern software. He’s also one of the sharpest critics of “vibe coding” — the emerging pattern of writing software by feel, with heavy reliance on LLMs and little regard for structure or quality.

We dive into:
• Why “vibe coding” is more than a meme — and what it says about how we build today
• How AI tools expand the surface area of software creation — for better and worse
• What happens to technical debt, testing, and security when generation outpaces understanding
• The changing definition of “production” in a world of ephemeral, internal, or just-good-enough tools
• How AI is flattening the learning curve — and threatening the talent pipeline
• Joe’s view on what real craftsmanship means in an age of disposable code

This conversation isn’t about doom, and it’s not about hype. It’s about mapping the real, messy terrain of what it means to build software today — and how to do it with care.

LINKS

🎓 Want to go deeper?
Check out my course: Building LLM Applications for Data Scientists and Software Engineers.
Learn how to design, test, and deploy production-grade LLM systems — with observability, feedback loops, and structure built in.
This isn’t about vibes or fragile agents. It’s about making LLMs reliable, testable, and actually useful.

Includes over $800 in compute credits and guest lectures from experts at DeepMind, Moderna, and more.
Cohort starts July 8 — Use this link for a 10% discount

Episode 46: Software Composition Is the New Vibe Coding

Hugo Bowne-Anderson — Thu, 03 Apr 2025 13:00:00 +1100

What if building software felt more like composing than coding?

In this episode, Hugo and Greg explore how LLMs are reshaping the way we think about software development—from deterministic programming to a more flexible, prompt-driven, and collaborative style of building. It’s not just hype or grift—it’s a real shift in how we express intent, reason about systems, and collaborate across roles.

Hugo speaks with Greg Ceccarelli—co-founder of SpecStory, former CPO at Pluralsight, and Director of Data Science at GitHub—about the rise of software composition and how it changes the way individuals and teams create with LLMs.

We dive into:

Why software composition is emerging as a serious alternative to traditional coding
The real difference between vibe coding and production-minded prototyping
How LLMs are expanding who gets to build software—and how
What changes when you focus on intent, not just code
What Greg is building with SpecStory to support collaborative, traceable AI-native workflows
The challenges (and joys) of debugging and exploring with agentic tools like Cursor and Claude

We’ve removed the visual demos from the audio—but you can catch our live-coded Chrome extension and JFK document explorer on YouTube. Links below.

Includes over $2,500 in compute credits and guest lectures from experts at DeepMind, Moderna, and more.
Cohort starts April 7 — Use this link for a 10% discount

🔍 Want to help shape the future of SpecStory?

Greg and the team are looking for design partners for their new SpecStory Teams product—built for collaborative, AI-native software development.

If you're working with LLMs in a team setting and want to influence the next wave of developer tools, you can apply here:

👉 specstory.com/teams

Episode 44: The Future of AI Coding Assistants: Who’s Really in Control?

Hugo Bowne-Anderson — Tue, 04 Feb 2025 13:00:00 +1100

AI coding assistants are reshaping how developers write, debug, and maintain code—but who’s really in control? In this episode, Hugo speaks with Tyler Dunn, CEO and co-founder of Continue, an open-source AI-powered code assistant that gives developers more customization and flexibility in their workflows.

In this episode, we dive into:

The trade-offs between proprietary vs. open-source AI coding assistants—why open-source might be the future.
How structured workflows, modular AI, and customization help developers maintain control over their tools.
The evolution of AI-powered coding, from autocomplete to intelligent code suggestions and beyond.
Why the best developer experiences come from sensible defaults with room for deeper configuration.
The future of LLM-based software engineering, where fine-tuning models on personal and team-level data could make AI coding assistants even more effective.

With companies increasingly integrating AI into development workflows, this conversation explores the real impact of these tools—and the importance of keeping developers in the driver's seat.

LINKS

Episode 43: Tales from 400+ LLM Deployments: Building Reliable AI Agents in Production

Hugo Bowne-Anderson — Fri, 17 Jan 2025 08:00:00 +1100

Hugo speaks with Alex Strick van Linschoten, Machine Learning Engineer at ZenML and creator of a comprehensive LLMOps database documenting over 400 deployments. Alex's extensive research into real-world LLM implementations gives him unique insight into what actually works—and what doesn't—when deploying AI agents in production.

In this episode, we dive into:

The current state of AI agents in production, from successes to common failure modes
Practical lessons learned from analyzing hundreds of real-world LLM deployments
How companies like Anthropic, Klarna, and Dropbox are using patterns like ReAct, RAG, and microservices to build reliable systems
The evolution of LLM capabilities, from expanding context windows to multimodal applications
Why most companies still prefer structured workflows over fully autonomous agents

We also explore real-world case studies of production hurdles, including cascading failures, API misfires, and hallucination challenges. Alex shares concrete strategies for integrating LLMs into your pipelines while maintaining reliability and control.

Whether you're scaling agents or building LLM-powered systems, this episode offers practical insights for navigating the complex landscape of LLMOps in 2025.

LINKS

Episode 42: Learning, Teaching, and Building in the Age of AI

Hugo Bowne-Anderson — Sat, 04 Jan 2025 14:00:00 +1100

In this episode of Vanishing Gradients, the tables turn as Hugo sits down with Alex Andorra, host of Learning Bayesian Statistics. Hugo shares his journey from mathematics to AI, reflecting on how Bayesian inference shapes his approach to data science, teaching, and building AI-powered applications.

They dive into the realities of deploying LLM applications, overcoming “proof-of-concept purgatory,” and why first principles and iteration are critical for success in AI. Whether you’re an educator, software engineer, or data scientist, this episode offers valuable insights into the intersection of AI, product development, and real-world deployment.

LINKS

Episode 40: What Every LLM Developer Needs to Know About GPUs

Hugo Bowne-Anderson — Tue, 24 Dec 2024 15:00:00 +1100

Hugo speaks with Charles Frye, Developer Advocate at Modal and someone who really knows GPUs inside and out. If you’re a data scientist, machine learning engineer, AI researcher, or just someone trying to make sense of hardware for LLMs and AI workflows, this episode is for you.

Charles and Hugo dive into the practical side of GPUs—from running inference on large models, to fine-tuning and even training from scratch. They unpack the real pain points developers face, like figuring out:

How much VRAM you actually need.
Why memory—not compute—ends up being the bottleneck.
How to make quick, back-of-the-envelope calculations to size up hardware for your tasks.
And where things like fine-tuning, quantization, and retrieval-augmented generation (RAG) fit into the mix.

One thing Hugo really appreciate is that Charles and the Modal team recently put together the GPU Glossary—a resource that breaks down GPU internals in a way that’s actually useful for developers. We reference it a few times throughout the episode, so check it out in the show notes below.

🔧 Charles also does a demo during the episode—some of it is visual, but we talk through the key points so you’ll still get value from the audio. If you’d like to see the demo in action, check out the livestream linked below.

This is the "Building LLM Applications for Data Scientists and Software Engineers" course that Hugo is teaching with Stefan Krawczyk (ex-StitchFix) in January. Charles is giving a guest lecture at on hardware for LLMs, and Modal is giving all students $1K worth of compute credits (use the code VG25 for $200 off).

LINKS

The livestream on YouTube
The GPU Glossary by the Modal team
What We’ve Learned From A Year of Building with LLMs by Charles and friends
Charles on twitter
Hugo on twitter
Vanishing Gradients on twitter

Episode 39: From Models to Products: Bridging Research and Practice in Generative AI at Google Labs

Hugo Bowne-Anderson — Tue, 26 Nov 2024 03:00:00 +1100

Hugo speaks with Ravin Kumar,*Senior Research Data Scientist at Google Labs. Ravin’s career has taken him from building rockets at SpaceX to driving data science and technology at Sweetgreen, and now to advancing generative AI research and applications at Google Labs and DeepMind. His multidisciplinary experience gives him a rare perspective on building AI systems that combine technical rigor with practical utility.

In this episode, we dive into:
• Ravin’s fascinating career path, including the skills and mindsets needed to work effectively with AI and machine learning models at different stages of the pipeline.
• How to build generative AI systems that are scalable, reliable, and aligned with user needs.
• Real-world applications of generative AI, such as using open weight models such as Gemma to help a bakery streamline operations—an example of delivering tangible business value through AI.
• The critical role of UX in AI adoption, and how Ravin approaches designing tools like Notebook LM with the user journey in mind.

We also include a live demo where Ravin uses Notebook LM to analyze my website, extract insights, and even generate a podcast-style conversation about me. While some of the demo is visual, much can be appreciated through audio, and we’ve added a link to the video in the show notes for those who want to see it in action. We’ve also included the generated segment at the end of the episode for you to enjoy.

LINKS

As mentioned in the episode, Hugo is teaching a four-week course, Building LLM Applications for Data Scientists and SWEs, co-led with Stefan Krawczyk (Dagworks, ex-StitchFix). The course focuses on building scalable, production-grade generative AI systems, with hands-on sessions, $1,000+ in cloud credits, live Q&As, and guest lectures from industry experts.

Listeners of Vanishing Gradients can get 25% off the course using this special link or by applying the code VG25 at checkout.

Episode 18: Research Data Science in Biotech

Hugo Bowne-Anderson — Thu, 25 May 2023 08:00:00 +1000

Hugo speaks with Eric Ma about Research Data Science in Biotech. Eric leads the Research team in the Data Science and Artificial Intelligence group at Moderna Therapeutics. Prior to that, he was part of a special ops data science team at the Novartis Institutes for Biomedical Research's Informatics department.

In this episode, Hugo and Eric talk about

What tools and techniques they use for drug discovery (such as mRNA vaccines and medicines);
The importance of machine learning, deep learning, and Bayesian inference;
How to think more generally about such high-dimensional, multi-objective optimization problems;
The importance of open-source software and Python;
Institutional and cultural questions, including hiring and the trade-offs between being an individual contributor and a manager;
How they’re approaching accelerating discovery science to the speed of thought using computation, data science, statistics, and ML.

And as always, much, much more!

LINKS

Eric's website
Eric on twitter
Vanishing Gradients on YouTube
Cell Biology by the Numbers by Ron Milo and Rob Phillips
Eric's JAX tutorials at PyCon and SciPy
Eric's blog post on Hiring data scientists at Moderna!

Episode 7: The Evolution of Python for Data Science

Hugo Bowne-Anderson — Mon, 02 May 2022 06:00:00 +1000

Hugo speaks with Peter Wang, CEO of Anaconda, about how Python became so big in data science, machine learning, and AI. They jump into many of the technical and sociological beginnings of Python being used for data science, a history of PyData, the conda distribution, and NUMFOCUS.

They also talk about the emergence of online collaborative environments, particularly with respect to open source, and attempt to figure out the movings parts of PyData and why it has had the impact it has, including the fact that many core developers were not computer scientists or software engineers, but rather scientists and researchers building tools that they needed on an as-needed basis

They also discuss the challenges in getting adoption for Python and the things that the PyData stack solves, those that it doesn’t and what progress is being made there.

People who have listened to Hugo podcast for some time may have recognized that he's interested in the sociology of the data science space and he really considered speaking with Peter a fascinating opportunity to delve into how the Pythonic data science space evolved, particularly with respect to tooling, not only because Peter had a front row seat for much of it, but that he was one of several key actors at various different points. On top of this, Hugo wanted to allow Peter’s inner sociologist room to breathe and evolve in this conversation.

What happens then is slightly experimental – Peter is a deep, broad, and occasionally hallucinatory thinker and Hugo wanted to explore new spaces with him so we hope you enjoy the experiments they play as they begin to discuss open-source software in the broader context of finite and infinite games and how OSS is a paradigm of humanity’s ability to create generative, nourishing and anti-rivlarous systems where, by anti-rivalrous, we mean things that become more valuable for everyone the more people use them! But we need to be mindful of finite-game dynamics (for example, those driven by corporate incentives) co-opting and parasitizing the generative systems that we build.

These are all considerations they delve far deeper into in Part 2 of this interview, which will be the next episode of VG, where we also dive into the relationship between OSS, tools, and venture capital, amonh many others things.

LInks

Peter on twitter
Anaconda Nucleus
Calling out SciPy on diversity (even though it hurts) by Juan Nunez-Iglesias
Here Comes Everybody: The Power of Organizing Without Organizations by Clay Shirky
Finite and Infinite Games by James Carse
Governing the Commons: The Evolution of Institutions for Collective Action by Elinor Olstrom
Elinor Ostrom's 8 Principles for Managing A Commmons

Episode 5: Executive Data Science

Hugo Bowne-Anderson — Wed, 23 Mar 2022 16:00:00 +1100

Hugo speaks with Jim Savage, the Director of Data Science at Schmidt Futures, about the need for data science in executive training and decision, what data scientists can learn from economists, the perils of "data for good", and why you should always be integrating your loss function over your posterior.

Jim and Hugo talk about what data science is and isn’t capable of, what can actually deliver value, and what people really enjoy doing: the intersection in this Venn diagram is where we need to focus energy and it may not be quite what you think it is!

They then dive into Jim's thoughts on what he dubs Executive Data Science. You may be aware of the slicing of the data science and machine learning spaces into descriptive analytics, predictive analytics, and prescriptive analytics but, being the thought surgeon that he is, Jim proposes a different slicing into

(1) tool building OR data science as a product,

(2) tools to automate and augment parts of us, and

(3) what Jim calls Executive Data Science.

Jim and Hugo also talk about decision theory, the woeful state of causal inference techniques in contemporary data science, and what techniques it would behoove us all to import from econometrics and economics, more generally. If that’s not enough, they talk about the importance of thinking through the data generating process and things that can go wrong if you don’t. In terms of allowing your data work to inform your decision making, thery also discuss Jim’s maxim “ALWAYS BE INTEGRATING YOUR LOSS FUNCTION OVER YOUR POSTERIOR”

Last but definitively not least, as Jim has worked in the data for good space for much of his career, they talk about what this actually means, with particular reference to fast.ai founder & QUT professor of practice Rachel Thomas’ blog post called “Doing Data Science for Social Good, Responsibly”. Rachel’s post takes as its starting point the following words of Sarah Hooker, a researcher at Google Brain:

"Data for good" is an imprecise term that says little about who we serve, the tools used, or the goals. Being more precise can help us be more accountable & have a greater positive impact.

And Jim and I discuss his work in the light of these foundational considerations.

Links

Jim on twitter
What Is Causal Inference?An Introduction for Data Scientists by Hugo Bowne-Anderson and Mike Loukides
Jim's must-watch Data Council talk on Productizing Structural Models
[Mastering Metrics}(https://www.masteringmetrics.com/) by Angrist and Pischke
Mostly Harmless Econometrics: An Empiricist's Companion by Angrist and Pischke
The Book of Why by Judea Pearl
Decision-Making in a Time of Crisis by Hugo Bowne-Anderson
Doing Data Science for Social Good, Responsibly by Rachel Thomas