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 · E209
    October 7 · 8 min

    How Rust Is Rewiring Enterprise Software Security

    Enterprise software is facing a crisis of trust, with memory safety vulnerabilities accounting for nearly seventy percent of critical CVEs in major platforms. This episode explores how Microsoft and Mozilla are shifting from reactive patching to...

    • Transcript
  • S5 · E208
    October 7 · 7 min

    Why Code Reviews Are Failing Modern Teams

    We dissect why the traditional pull request review model is creating bottlenecks rather than quality, using data from major open source maintainers to show how asynchronous communication and context-switching are killing developer velocity. Lucas and...

    • Transcript
  • S5 · E207
    October 5 · 10 min

    Why Your Tech Stack Is Draining Your Budget

    Lucas and Luna dissect the hidden financial bleed in modern software engineering, focusing on the specific economics of developer tooling complexity. With October fifth twenty twenty six as the backdrop, they analyze how teams are wasting millions on...

    • Transcript
  • S5 · E206
    October 5 · 12 min

    The Hidden Cost of Developer Tooling Complexity

    We explore the surprising economic reality behind modern software development: the hidden tax of tooling complexity. Using a recent case study from a mid-sized fintech company, we break down how an over-engineered build system added weeks to deployment...

    • Transcript
  • S5 · E205
    October 4 · 7 min

    The Hidden Cost of Software Complexity

    We talk about how the pressure to adopt new frameworks and languages is creating a maintenance nightmare for engineering teams. Lucas and Luna look at the specific case of a mid-sized fintech company that tried to migrate its core ledger system from...

    • Transcript
  • S5 · E204
    October 2 · 8 min

    Why Code Review Is The Real Bottleneck

    We talk about the hidden friction in pull requests and why waiting for code review slows down teams more than writing bad code. Lucas breaks down how Slack threads kill context, while Luna shares a story about a critical deployment delayed by one...

    • Transcript
  • S5 · E203
    October 2 · 10 min

    How AI Coding Assistants Are Rewiring Junior Developers

    In this episode of The Programming Languages Podcast, Lucas and Luna explore the structural shift in software engineering caused by generative AI tools. They examine how junior developers are bypassing foundational debugging skills by relying on GitHub...

    • Transcript
  • S5 · E202
    October 1 · 12 min

    How Type Inference Cuts Software Bugs

    We dig into how modern type systems, from TypeScript to Rust, are silently rewriting developer workflows. Lucas and Luna explore why explicit contracts reduce production outages more effectively than unit tests alone. We look at specific case studies...

    • Transcript
  • S5 · E201
    September 30 · 10 min

    Why Your Codebase Is Becoming Unreadable

    In this episode of The Programming Languages Podcast, Lucas and Luna examine the growing crisis of 'code decay' — where software becomes harder to understand over time despite no new features being added. They explore how technical debt compounds through...

    • Transcript
  • S4 · E200
    September 29 · 10 min

    Why Your Codebase Is Becoming Unreadable

    Lucas and Luna explore the growing crisis of code readability in modern software engineering. With teams prioritizing speed over clarity, documentation is often an afterthought. They examine how unreadable code leads to increased maintenance costs...

    • Transcript
  • S4 · E199
    September 28 · 12 min

    How Python Conquered The AI Infrastructure Race

    In this episode of The Programming Languages Podcast, Lucas and Luna explore why Python has become the undisputed lingua franca of artificial intelligence infrastructure. While Rust dominates memory safety and Go powers cloud networking, Python’s grip on...

    • Transcript
  • S4 · E198
    September 27 · 9 min

    Why Modern Codebases Are Failing Without Documentation

    In this episode of The Programming Languages Podcast, Lucas and Luna examine why high-per engineering teams are seeing a collapse in velocity despite using modern tools like Python and Rust. They explore the rise of self-documenting code as a myth...

    • Transcript
  • S4 · E197
    September 25 · 10 min

    How WebAssembly Is Reshaping Cloud Infrastructure

    WebAssembly has moved from browser experiments to server-side workhorse in just a few years. In this episode, we look at why major cloud providers are integrating WASI — the WebAssembly System Interface — into their edge computing stacks. We explore how...

    • Transcript
  • S4 · E196
    September 25 · 10 min

    Why Your Tech Stack Is Draining Your Budget

    In this episode of The Programming Languages Podcast, Lucas and Luna dissect the hidden financial drag of legacy software architectures. They examine how technical debt compounds like interest on a high-yield loan, using specific examples from cloud...

    • Transcript
  • S4 · E195
    September 24 · 6 min

    Why Software Teams Kill Legacy Code

    We talk about the economics of legacy code. It is not just about old syntax or forgotten libraries. It is about the hidden tax on engineering velocity and how modern teams handle technical debt. Lucas and Luna explore why rewriting systems often fails...

    • Transcript
  • S4 · E194
    September 23 · 10 min

    Why Software Teams Are Killing Legacy Code

    In this episode of The Programming Languages Podcast, Lucas and Luna tackle the most uncomfortable truth in modern engineering: why smart teams are deliberately deleting working code. They explore the 'zero-based budgeting' approach to software...

    • Transcript
  • S4 · E193
    September 21 · 10 min

    How Code Ownership Prevents Engineering Burnout

    We examine the counterintuitive reality that strict code ownership, often touted as a way to reduce chaos, is actually a primary driver of developer burnout and organizational silos. Using recent data from Stack Overflow and internal metrics from major...

    • Transcript
  • S4 · E192
    September 20 · 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
    September 19 · 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
    September 18 · 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
Showing 21–40 of 84 episodes