Skip to content
Artwork for The Programming Languages Podcast with Fexingo: Python, Rust, JavaScript, and Modern Coding

The Programming Languages Podcast with Fexingo: Python, Rust, JavaScript, and Modern Coding

Fexingo

Every line of code is a decision, and every programming language encodes a philosophy. In The Programming Languages Podcast, Lucas and Luna move past syntax flame wars to examine the actual trade-offs behind Python, Rust, JavaScript, and the modern coding stack. Each episode dissects a specific language feature, framework choice, or ecosystem shift — from Rust's borrow checker and memory safety guarantees to JavaScript's type system evolution with TypeScript, and Python's dominance in machine learning versus its performance bottlenecks. They ground every discussion in real-world benchmarks, open-source projects like Deno and PyPy, and case studies from companies that bet on one language over another. Lucas brings the reporter's instinct for clarity and hard numbers; Luna tests those findings with the engineer's skepticism and hands-on experience. You will walk away understanding not just what a language does, but why it was designed that way, and when you should — or shouldn't — use it. What does Rust's ownership model teach us about concurrency? Is JavaScript's flexibility a feature or a bug for large-scale systems? Can Python ever overcome the GIL? This is the podcast for developers who are tired of cargo-culting and want to think critically about the tools they use every day. #PythonProgramming #RustLang #JavaScript #TypeScript #ModernCoding #MemorySafety #ProgrammingLanguages #SoftwareEngineering #TechDebate #OpenSource #CodeBenchmarks #Deno #PyPy #GIL #BorrowChecker #Business #FexingoBusiness #Technology Keep every episode free: buymeacoffee.com/fexingo
Play
  • 84 episodes
  • Avg 9 min
  • English

Support the show

Goes straight to the publisher. podnod takes nothing.

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • S5 · E229
    November 2 · 11 min

    Why Your Codebase Is Becoming Unmaintainable

    Most software teams treat documentation as an afterthought, but in this episode we examine how the lack of living architecture diagrams is causing critical project failures. We look at a specific case where a mid-sized fintech company lost three months...

    • Transcript
  • S5 · E228
    November 1 · 11 min

    The Hidden Cost of AI Code Generation

    We look at how AI coding assistants are changing the economics of software development. Lucas and Luna discuss a recent survey showing that while developers use AI for boilerplate, they spend more time reviewing generated code than writing it from...

    • Transcript
  • S5 · E227
    October 31 · 12 min

    Why Senior Engineers Hate Documentation

    We explore the hidden productivity tax of enterprise documentation and why the best engineers often treat it as optional. Using a specific case from a major fintech firm, we examine how over-engineered wikis create false confidence while actual system...

    • Transcript
  • S5 · E226
    October 29 · 7 min

    Why Your Software Team Is Stuck In The Integration Trap

    We dissect the hidden friction of modern software development, focusing on how API sprawl and integration debt are silently killing productivity. Using a concrete example from a mid-sized logistics firm that lost forty percent of its engineering capacity...

    • Transcript
  • S5 · E225
    October 28 · 8 min

    Why AI Coding Assistants Are Making Bugs Harder to Find

    We look at the paradox of AI coding assistants: they write code faster but introduce subtle, systemic bugs that are harder to debug than traditional errors. Using a specific case study of a fintech startup’s deployment failure in early October 2026, we...

    • Transcript
  • S5 · E224
    October 27 · 8 min

    The Rust Adoption Crisis in Enterprise Codebases

    Lucas and Luna dissect why major financial institutions are quietly rewriting core banking infrastructure in Rust despite a severe shortage of experienced engineers. They examine the specific productivity gap between legacy C++ teams and new Rust...

    • Transcript
  • S5 · E223
    October 26 · 13 min

    Why Your Codebase Is Rotting From The Inside Out

    Most engineering leaders blame technical debt for slowing their teams, but the real rot is often invisible: architectural drift. In this episode, we examine how companies like Netflix and Amazon managed to keep monoliths viable by enforcing strict...

    • Transcript
  • S5 · E222
    October 25 · 7 min

    Why Your Tech Stack Is Draining Your Budget

    We dissect the hidden economics of software development by looking at how language choice impacts long-term maintenance costs. Using a specific case study of a mid-sized fintech firm that switched from a legacy Java monolith to modular Go services, we...

    • Transcript
  • S5 · E221
    October 24 · 10 min

    Why Your Startup Chose The Wrong Tech Stack

    We break down the specific decision-making framework that leads engineering leaders to select programming languages based on hiring velocity rather than runtime performance. Using a hypothetical Series B SaaS company that migrated from Python to Go, we...

    • Transcript
  • S5 · E220
    October 23 · 11 min

    How Rust Is Rewiring Enterprise Software Security

    We look at why major tech firms are rewriting core infrastructure in Rust to solve memory safety issues that have plagued C and C++ for decades. From Microsoft’s adoption to Linux kernel integration, we explore the concrete shift away from buffer...

    • Transcript
  • S5 · E219
    October 22 · 11 min

    Why Software Teams Are Failing at Testing

    In this episode of The Programming Languages Podcast, Lucas and Luna dissect the critical gap between writing code and verifying it. They explore why modern development teams, despite having advanced CI/CD pipelines, still struggle with flaky tests and...

    • Transcript
  • S5 · E218
    October 21 · 9 min

    Why Software Teams Are Losing The Battle Against Complexity

    Software teams are drowning in a sea of complexity, not because they lack talent, but because the tools and architectures we rely on have become increasingly opaque. In this episode, Lucas and Luna explore the rising tide of cognitive load in modern...

    • Transcript
  • S5 · E217
    October 19 · 8 min

    How Rust Is Changing System Programming

    Lucas and Luna explore why Rust is moving from niche systems programming into mainstream enterprise backend development. They examine the memory safety guarantees that reduce production outages, the specific friction points in adopting a new language...

    • Transcript
  • S5 · E216
    October 18 · 10 min

    Why Code Reviews Are Stifling Innovation

    We explore the paradox of modern software development where rigorous code review processes, intended to ensure quality and security, are inadvertently becoming the primary bottleneck for innovation. Using specific examples from enterprise teams at...

    • Transcript
  • S5 · E215
    October 17 · 12 min

    The Silent Killer of Software Teams

    Most engineering leaders focus on hiring speed or code quality, but a specific behavioral pattern is quietly destroying productivity. We examine the phenomenon of context switching and the cognitive tax it imposes on senior developers. Using data from...

    • Transcript
  • S5 · E214
    October 13 · 8 min

    Why Enterprise Codebases Are Stagnating

    Lucas and Luna examine the structural decay of legacy enterprise systems. They explore how monolithic architectures, dependency hell, and the rise of Rust are forcing a rethink of modern software reliability. The episode dives into specific migration...

    • Transcript
  • S5 · E213
    October 12 · 10 min

    The Silent Tax of Technical Debt in Software Teams

    We talk about the invisible tax that technical debt extracts from engineering teams, using a specific case where a mid-sized fintech firm found its velocity halved not because of new features, but because of legacy integration costs. We break down how...

    • Transcript
  • S5 · E212
    October 12 · 11 min

    How Memory Safety Is Reshaping Software Reliability

    We examine why enterprises are shifting from manual memory management to systems that prevent leaks and corruption at the source. With security breaches costing millions, we look at how Rust and modern language design are reducing production outages...

    • Transcript
  • S5 · E211
    October 10 · 9 min

    How Type Safety Prevents Production Outages

    We examine why modern engineering teams are migrating from dynamic scripting to strict type systems, using TypeScript adoption as the primary case study. With runtime errors costing enterprises millions in downtime, we break down how static analysis...

    • Transcript
  • S5 · E210
    October 9 · 10 min

    Why Your Microservices Are Slowing You Down

    Most engineering leaders assume microservices mean speed, but the reality is often latency and distributed complexity. This episode examines how a major fintech firm reduced their service count by half, cut deployment time by forty percent, and improved...

    • Transcript
Showing 1–20 of 84 episodes