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
  • 47 episodes
  • daily
  • 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.
  • S4 · E192
    Yesterday · 9 min

    Why Software Teams Are Abandoning Git Monorepos

    In this episode of The Programming Languages Podcast, Lucas and Luna explore why major engineering organizations are quietly moving away from monolithic code repositories. With GitHub and GitLab pushing monorepo architectures for faster CI pipelines, we...

    • Transcript
  • S4 · E191
    Saturday · 10 min

    Why Go Is Winning the Cloud Infrastructure Race

    In September 2026, Go has quietly become the default language for cloud-native infrastructure, yet few developers understand why. We break down how Google's creation solved the concurrency problem that C++ and Java struggled with, using specific examples...

    • Transcript
  • S4 · E190
    Friday · 10 min

    How Rust Memory Safety Saved Cloud Infrastructure

    We examine why major tech firms are rewriting core infrastructure in Rust to eliminate entire classes of bugs. From memory safety guarantees that prevent data breaches to the steep learning curve for developers, we break down the real cost and benefit of...

    • Transcript
  • S4 · E189
    Friday · 9 min

    The Silent Tax of Developer Burnout in Modern Software

    We are looking at the specific mechanics of context switching and how it quietly destroys engineering velocity. In this episode, Lucas and Luna break down why the average developer loses nearly two hours a day to fragmented attention, citing recent...

    • Transcript
  • S4 · E188
    Thursday · 10 min

    How Static Analysis Prevents Production Outages

    We examine how major engineering teams are using static analysis tools to catch logic errors before code reaches production. Lucas and Luna discuss the shift from manual code reviews to automated safety nets, featuring specific examples of how type...

    • Transcript
  • S4 · E187
    Tuesday · 11 min

    How Python Dominates AI Infrastructure in 2026

    We explore why Python remains the undisputed king of artificial intelligence development despite performance criticisms. From PyTorch ecosystem dominance to the rise of typed Python, we analyze how enterprises balance developer velocity with runtime...

    • Transcript
  • S4 · E186
    September 14 · 8 min

    The Silent Killer of Software Teams

    In this episode, Lucas and Luna dissect the hidden crisis of context switching in modern engineering teams. With AI copilots promising to accelerate coding, many organizations are seeing productivity stall rather than soar. We explore why fragmented...

    • Transcript
  • S4 · E185
    September 13 · 9 min

    Why Your Codebase Is Too Big to Debug

    In this episode of The Programming Languages Podcast, Lucas and Luna explore the hidden complexity crisis in modern software engineering. They examine how the average enterprise codebase has grown to over two million lines of code, making traditional...

    • Transcript
  • S4 · E184
    September 12 · 10 min

    The Hidden Cost of Developer Burnout in Modern Software

    We examine the silent crisis of software maintainability and how code ownership prevents engineering burnout. Lucas and Luna explore why modular monoliths beat microservice complexity, discussing real-world examples from companies like Figma and Netflix...

    • Transcript
  • S4 · E183
    September 11 · 9 min

    How Code Ownership Prevents Engineering Burnout

    In this episode, Lucas and Luna explore the 'Bus Factor' problem in modern software teams. With September 2026 marking a peak in developer turnover, we examine how distributed ownership models fail when no single engineer feels responsible for a module's...

    • Transcript
  • S4 · E182
    September 11 · 10 min

    How Modular Monoliths Beat Microservice Complexity

    In this episode, Lucas and Luna dismantle the microservices craze by exploring the modular monolith architecture. With enterprise software costs rising and developer burnout peaking in September 2026, they examine why companies like Netflix and Shopify...

    • Transcript
  • S4 · E181
    September 9 · 9 min

    The Hidden Tax of Developer Burnout

    In this episode, Lucas and Luna explore the quiet crisis of developer burnout, moving beyond generic wellness tips to examine the structural causes in modern software teams. They analyze recent data on sprint cycles, the impact of context-switching on...

    • Transcript
  • S4 · E180
    September 8 · 8 min

    The Silent Crisis of Software Maintainability

    In 2026, the tech industry faces a quiet emergency that rarely makes headlines: the crumbling foundation of our most critical codebases. While we celebrate new languages like Mojo and Rust, the vast majority of enterprise software is built on decades-old...

    • Transcript
  • S4 · E179
    September 7 · 9 min

    The Hidden Cost of Technical Debt in Modern Software

    We look at how the decision to skip type checking in Python and JavaScript has created a massive, invisible tax on enterprise engineering teams. Using data from recent developer surveys and specific case studies from large-scale infrastructure projects...

    • Transcript
  • S4 · E178
    September 6 · 11 min

    How AI Copilots Changed Developer Hiring

    In this episode of The Programming Languages Podcast, Lucas and Luna examine how the widespread adoption of AI coding assistants has fundamentally altered software engineering hiring. They analyze data from major tech firms showing a shift from...

    • Transcript
  • S4 · E177
    September 5 · 12 min

    How Code Reviews Kill Productivity

    Most engineering leaders believe code reviews are the primary defense against bugs, but new data suggests they are actually the biggest bottleneck in modern software delivery. In this episode, we look at the specific mechanics of how peer review creates...

    • Transcript
  • S4 · E176
    September 4 · 9 min

    How TypeScript Fixed JavaScripts Type Problem

    In this episode, Lucas and Luna explore how TypeScript transformed the JavaScript ecosystem by introducing static type checking to a dynamic language. They dive into the specific mechanics of how types are inferred, the debate around explicit versus...

    • Transcript
  • S4 · E175
    September 3 · 7 min

    How Rust Is Reshaping Enterprise Cloud Infrastructure

    Enterprise IT is quietly migrating critical infrastructure workloads from C++ and Go to Rust, driven by memory safety guarantees that eliminate entire classes of bugs. We examine why major cloud providers are adopting Rust for kernel-level networking...

    • Transcript
  • S4 · E174
    September 2 · 10 min

    Why Python Type Hinting Is Saving Enterprise Codebases

    We dig into the specific mechanics of PEP 484 and how static type checking has moved from a developer nicety to an enterprise necessity. Lucas and Luna explore why major tech firms are adopting strict typing not just for IDE autocomplete, but to prevent...

    • Transcript
  • S4 · E173
    September 1 · 10 min

    How WebAssembly Is Reshaping Cloud Development

    WebAssembly, or Wasm, has moved from a browser curiosity to the backbone of serverless edge computing in 2026. Lucas and Luna explore how companies like Cloudflare and Fastly are deploying Wasm modules to replace heavy virtual machines with lightweight...

    • Transcript
Showing 1–20 of 47 episodes