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
  • 49 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 · E154
    August 13 · 8 min

    Why Smalltalk Still Matters in Modern Software

    Smalltalk, the language that introduced object-oriented programming decades ago, still shapes modern software development. In this episode, Lucas and Luna explore how Smalltalk's ideas—like objects, messages, and the image-based development model—live on...

    • Transcript
  • S4 · E153
    August 12 · 10 min

    Why TypeScript Is Winning the Modern Web in 2026

    In this episode, Lucas and Luna explore why TypeScript has become the default choice for modern web development, even as JavaScript evolves and new contenders like Python's PyScript and Go's WASM support emerge. Centered on the massive 2026 npm registry...

    • Transcript
  • S4 · E152
    August 11 · 7 min

    Why Kotlin Is the Pragmatic Choice for Server-Side Development

    In this episode, Lucas and Luna explore why Kotlin has become the go-to language for server-side development in 2026, moving beyond its Android fame. They start with a surprising stat: Kotlin now powers over 30 percent of new backend services at major...

    • Transcript
  • S4 · E151
    August 10 · 9 min

    Why Lua Is the Hidden Scripting Powerhouse in 2026

    Lua is everywhere, hiding inside games, embedded systems, and even Adobe products, yet most developers barely notice it. In this episode, Lucas and Luna explore why Lua, a 30-year-old language, is still the go-to choice for embedding scripting into...

    • Transcript
  • S3 · E150
    August 9 · 9 min

    Why Elixir Is the Secret to Fault-Tolerant Backends

    In this milestone 150th episode, Lucas and Luna explore why Elixir, a language born from the Erlang ecosystem, is quietly becoming the go-to choice for fault-tolerant backend systems in 2026. They trace its origins to Ericsson's 1980s telecom switches...

    • Transcript
  • S3 · E149
    August 8 · 9 min

    Crystal Lang Is the Fastest Way to Write Fast Code

    In this episode of The Programming Languages Podcast, Lucas and Luna explore Crystal, the compiled language with Ruby-like syntax and C-like performance. They break down its unique compiled approach, its built-in concurrency model, and why it's gaining...

    • Transcript
  • S3 · E148
    August 7 · 8 min

    Zig's Zero-Dependency Takeover of Systems Programming

    In this episode, Lucas and Luna explore Zig, the systems programming language that's quietly becoming a favorite for performance-critical projects in 2026. They trace its rise from a niche language to a serious contender alongside C and Rust, focusing on...

    • Transcript
  • S3 · E147
    August 6 · 9 min

    How GraalVM Is Redefining Polyglot Performance in 2026

    Lucas and Luna dig into GraalVM, the high-performance runtime that's quietly changing how enterprises run polyglot code. In 2026, as microservices and serverless become the default, GraalVM's native images and Truffle framework are delivering startup...

    • Transcript
  • S3 · E146
    August 5 · 10 min

    Why WebAssembly Is the Compiler Target of 2026

    In this episode of The Programming Languages Podcast, Lucas and Luna dive into WebAssembly's rise as the universal compiler target in 2026. They trace its journey from a browser-only novelty to a cornerstone of edge computing, serverless platforms, and...

    • Transcript
Showing 41–49 of 49 episodes