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
  • 69 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.
  • S5 · E214
    Yesterday · 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
    Monday · 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
    Monday · 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
    Saturday · 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
    Friday · 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
  • 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
Showing 1–20 of 69 episodes