Home
Podcasts
The Programming Languages Podcast with Fexingo: Python, Rust, JavaScript, and Modern Coding
The Programming Languages Podcast with Fexingo: Python, Rust, JavaScript, and Modern Coding
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.
Episodes
Why TypeScript Is Eating JavaScript in 2026
In this episode of The Programming Languages Podcast with Fexingo, hosts Lucas and Luna explore the meteoric rise of TypeScript in 2026. They dive into how TypeScript's adoption has surged past 80% among professional JavaScript developers, driven by the rise of AI-generated code and the need for type safety in large codebases. Lucas breaks down the key numbers from the State of JS 2025 survey, inc
Why Developers Are Rewriting Everything in Rust in 2026
Rust is no longer just for systems programmers. In 2026, its ownership model and safety guarantees are driving adoption across web services, embedded devices, and even frontend tooling. Lucas and Luna unpack the data: GitHub's Octoverse shows Rust grew 50% year-over-year in contributors, while the Linux kernel and Android now mandate Rust for new code. They examine why companies like Meta, Amazon,
How Dart and Flutter Are Winning Cross-Platform in 2026
Lucas and Luna dive into why Dart and Flutter have become the dominant cross-platform framework in 2026, overtaking React Native and other competitors. They examine the technical decisions that made Flutter fast—like the Skia graphics engine and the Dart virtual machine—and discuss how Google's bet on Fuchsia OS and ambient computing is driving investment. Lucas walks through the key metrics: over
How AWK Is Still the Best Command-Line Data Tool in 2026
Lucas and Luna explore why AWK, a text-processing language from 1977, remains irreplaceable for one-liner data analysis on the command line. They walk through a specific example: extracting and summing top seller data from a 50,000-line CSV in a single line of AWK, comparing it to Python and SQL. The episode covers AWK's pattern-action model, associative arrays, and why it beats modern tools for q
Why the JVM Is Still Dominant in Production in 2026
Lucas and Luna dig into why the Java Virtual Machine, despite being over three decades old, remains the runtime of choice for mission-critical backend systems in 2026. They examine Project Loom's virtual threads, which have slashed latency for concurrent applications, and compare GraalVM's native-image compilation against Go's compiled binaries. The conversation cites real numbers: how a major tra
Why OCaml Is the Dark Horse of Financial Tech in 2026
Lucas and Luna explore why OCaml, a language born in the 1990s, is quietly becoming the backbone of high-stakes financial systems. They examine its role at Jane Street Capital, where OCaml handles $5 trillion in daily trading volume, and contrast it with Rust's approach to safety. The episode also touches on why OCaml's strict typing catches bugs that cause billion-dollar losses in other languages
How Carbon Language Plans to Replace C++
Google's Carbon language was introduced in 2022 as a potential successor to C++. As of mid-2026, where does it stand? Lucas and Luna examine Carbon's design goals, its interoperability with existing C++ codebases, and the challenges it faces in gaining adoption. They discuss the open-source community's response, the role of Google's internal use, and why replacing a language as entrenched as C++ i
Why Every Developer Should Learn SQL in 2026
In this episode, Lucas and Luna explore why SQL remains the most underrated skill for developers in 2026. They break down how SQLite processes over one trillion queries per day, why modern tools like DuckDB are making SQL relevant for data science, and how knowing window functions can separate a junior from a senior engineer. They also discuss the rise of SQL-based analytics in fintech and how com
Why WebAssembly Is Transforming Cloud Computing in 2026
In this episode, Lucas and Luna explore how WebAssembly (Wasm) is moving beyond the browser to reshape cloud computing. They focus on a specific case: the rise of serverless Wasm runtimes like WasmEdge and Fermyon Spin, which are enabling faster cold starts and language-agnostic microservices. Lucas explains how WebAssembly reduces container overhead by 50-70% in certain workloads, citing a 2025 C
Why Zig Is the Systems Language to Watch in 2026
Episode 37 of The Programming Languages Podcast dives into Zig, a systems programming language that's gaining traction in 2026 for its simplicity, safety, and performance. Lucas and Luna explore why Zig is challenging C and Rust, its unique approach to memory management, and how it's being adopted in embedded systems, game development, and tooling. They discuss the language's zero-cost abstraction
How Mojo Is Synthesising Python and ML Performance in 2026
Episode 36 of The Programming Languages Podcast examines Mojo, the new language from Modular AI that aims to combine Python's usability with C-like performance for machine learning workloads. Lucas and Luna break down Mojo's unique 'syntactic sugar plus MLIR' approach, why it's not just another Python competitor, and what the 2026 ecosystem looks like — including the just-released Mojo 1.0 standar
Why Lua Is Powering Game Engines and Embedded Systems in 2026
Lucas and Luna explore why Lua, a lightweight scripting language from the 1990s, has become the secret engine behind game modding, embedded IoT, and even Redis scripting in 2026. With 1.5 billion devices running Lua via the Corona SDK alone, they break down its design philosophy of minimalism, its surprising role in the Roblox ecosystem, and why it's gaining new traction in constrained environment
Why PostgreSQL Is the Database Winning 2026
Lucas and Luna drill into a single concrete number: PostgreSQL's 40 percent market share growth among new deployments in 2026. They trace how the database went from an academic underdog to the default choice for AI workloads, real-time analytics, and mission-critical OLTP. The hosts walk through three specific drivers — the pgvector extension for vector search, the rise of managed Postgres on clou
How Kubernetes Forced a New Generation of Programming Languages
Kubernetes changed how we deploy software, but few people talk about how it changed the languages we write that software in. This episode explores Kubernetes as a language forcing function — why Go became the lingua franca of cloud-native infrastructure, how Rust carved out a niche for performance-critical components, and why Python and JavaScript had to adapt rather than lead. Lucas and Luna walk
Why Gleam Is the Language Bringing Erlang to the Masses
Gleam is a statically typed language that compiles to Erlang's BEAM virtual machine, bringing the reliability of Erlang and Elixir to developers who prefer a Rust-like type system. In this episode, Lucas and Luna explore how Gleam's strong types and simple syntax are making BEAM languages accessible to a new generation of programmers. They examine real-world adoption at companies like Bluetau and
How SQLite Became the Hidden Database Powering Everything
SQLite is the most deployed database engine on earth, running on billions of devices from smartphones to airplanes. Yet most developers barely think about it. In this episode of The Programming Languages Podcast with Fexingo, Lucas and Luna explore how SQLite became a critical piece of infrastructure, why its single-file design and public-domain licensing made it ubiquitous, and how it handles con
Why Formal Verification Is Entering Mainstream Development
Episode 30 of The Programming Languages Podcast explores formal verification — the practice of mathematically proving code correctness — and why it's moving beyond aerospace and academia into everyday development. Lucas and Luna examine how Amazon Web Services uses TLA+ to verify its distributed systems, preventing outages like the ones that cost e-commerce platforms millions per hour. They break
How Developers Are Fighting Supply Chain Attacks in 2026
Software supply chain attacks hit a new record in Q1 2026, with the number of malicious packages discovered on public registries up 80 percent year-over-year. Lucas and Luna break down how a single compromised npm package called 'event-stream' in 2018 foreshadowed today's crisis, and examine the new defenses developers are adopting: signature-based attestation from the Sigstore project, dependency
Why Kotlin Multiplatform Is Winning in 2026
Lucas and Luna dive into the rise of Kotlin Multiplatform in 2026. They explain how JetBrains' language is enabling true code sharing across iOS, Android, and web, with a focus on practical adoption at companies like Netflix and Uber. The episode unpacks how Kotlin's compiler and concurrency model give it an edge over Flutter and React Native, and why developers are moving beyond the JVM to target
Why Zig Is the Systems Language to Watch in 2026
Episode 27 of The Programming Languages Podcast explores Zig—a systems language that's gaining traction among embedded developers, game engine builders, and CLI tool authors. Lucas explains how Zig's compile-time execution replaces C macros, its lack of hidden control flow makes performance predictable, and its cross-compilation story solves the 'just works on my machine' problem. Luna asks whethe
How Go Conquered Cloud-Native Infrastructure
Episode 26 of The Programming Languages Podcast explores why Go has become the default language for cloud-native infrastructure. Lucas and Luna trace Go's rise from a 2009 experiment at Google to powering tools like Docker, Kubernetes, and Terraform. They break down what makes Go different: its goroutine concurrency model, fast compilation, and the controversial decision to omit generics for a dec
Why Rust Is Winning Over Python for Systems Programming in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna explore why Rust is increasingly replacing Python for systems-level programming in 2026, focusing on a specific case: how a major fintech startup migrated its core transaction engine from Python to Rust, cutting latency by 80% and eliminating memory-safety bugs. They discuss Rust's ownership model, the trade-offs in developer pro
Why TypeScript Is Eating JavaScript in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna explore how TypeScript has become the dominant language for web development by June 2026, surpassing JavaScript in enterprise adoption. They break down why TypeScript's type system saves teams from costly runtime errors, how Microsoft's strategy of gradual adoption won over developers, and why even die-hard JavaScript fans are ma
Why Python 4.0 Is Not Coming in 2026
In this episode, Lucas and Luna explore why the Python community is deliberately holding off on a Python 4.0 release despite increasing pressure from performance-hungry domains like AI inference and real-time data pipelines. They unpack the core tension: Python 3.x has become too stable and too widely embedded to risk a major version break. The discussion focuses on the Python Steering Council's r
Why Semantic Versioning Is Breaking Your Build Pipeline
Lucas and Luna dive into the quiet crisis of semantic versioning—how the 20-year-old convention of MAJOR.MINOR.PATCH is failing modern dependency management. They unpack the real-world example of the left-pad incident, explain why 'breaking change' has become a meaningless label, and explore how tools like Rust's Cargo and the Go module system are experimenting with alternatives. Specific numbers:
Why GitHub Copilot Isnt Enough Anymore in 2026
Episode 21 of The Programming Languages Podcast digs into the rapidly shifting landscape of AI coding assistants. Lucas and Luna explore why GitHub Copilot — once the market leader — is facing real competition from tools like Anthropic's Claude Code, JetBrains AI, and Cursor. They examine a concrete case: how a mid-sized startup replaced Copilot with Claude Code and saw a 40% reduction in code rev
Why GraphQL Is Thriving in 2026 Beyond the Hype Cycle
Episode 20 dives into GraphQL's surprising second life. Five years after the backlash, GraphQL is quietly powering major architectures at GitHub, Shopify, and Netflix. Lucas and Luna unpack the real reason adoption rebounded — not because of the query language itself, but because of a tiny caching layer called the 'persisted query registry'. They walk through how GitHub cut API latency by 40 perce
Why Haskell Still Matters in 2026
Episode 19 explores Haskell's quiet but powerful role in 2026's software landscape. Lucas and Luna examine how this purely functional language, often seen as academic, is powering critical systems at companies like Facebook, GitHub, and Cardano. They discuss Haskell's unique strengths in correctness, concurrency, and domain-specific languages, and why it remains relevant despite competition from R
How OCaml Powers Quantitative Finance Behind the Scenes
When you think of programming languages in finance, Python and C++ usually come to mind. But for decades, OCaml has quietly powered some of the most latency-sensitive and correctness-critical trading systems on Wall Street. In this episode, Lucas and Luna explore why quantitative finance firms like Jane Street and Citadel Securities bet big on this functional programming language — from its strong
How Dart Is Winning the Cross-Platform App War in 2026
In this episode, Lucas and Luna explore why Dart—the language behind Google's Flutter—has become the dominant force in cross-platform mobile and desktop development in 2026. They trace its unexpected rise from a niche web language to powering over 30% of new app launches on the iOS and Android app stores, according to recent data from app analytics firm Sensor Tower. The hosts dive into Flutter's
How WebAssembly Is Reshaping Edge Computing in 2026
Lucas and Luna dive into WebAssembly’s unexpected second life: powering edge computing. They trace how a technology originally designed to bring native-speed code to browsers is now running server-side functions at the edge, slashing cold-start times from hundreds of milliseconds to under a millisecond. The hosts break down a real-world case: a large e-commerce platform that cut its checkout laten
How Elixir Solved Twitter Scale Problems
In this episode, Lucas and Luna dive into the origin story of Elixir—a language born from José Valim's frustration with Ruby's concurrency limits. They unpack how Elixir's actor model, built on the Erlang VM, powers fault-tolerant systems like Discord's 5 million concurrent voice users. The hosts walk through real-world challenges: how Elixir's OTP (Open Telecom Platform) allows hot code swapping
Why Carbon Could Be C Plus Plus Successor
In this episode of The Programming Languages Podcast, Lucas and Luna explore Carbon, the experimental language from Google designed as a successor to C++. They unpack why Carbon was created, how it aims to fix C++'s legacy pain points without breaking existing codebases, and the current state of its open-source development in 2026. The conversation contrasts Carbon with Rust's memory-safety approa
How Lua Became the Embedded Language Powering Games and IoT
Episode 13 of The Programming Languages Podcast dives into Lua, the lightweight scripting language that quietly powers everything from World of Warcraft addons to Redis scripts and embedded IoT devices. Lucas explains how Lua's simple C API, small footprint, and fast interpreter made it the go-to embedded language, while Luna questions why it hasn't broken into broader application development. The
How AI Coding Assistants Are Reshaping Developer Workflows
Episode 12 explores how AI coding assistants like GitHub Copilot, Amazon CodeWhisperer, and Google's Gemini for Code are changing the way developers write software. Lucas and Luna discuss real-world adoption rates, productivity gains, and the shift from writing code to reviewing and prompting. They dive into the economics of these tools, the debate over code quality, and what this means for junior
Why JSON Is the Glue Holding Modern Software Together
In episode 11 of The Programming Languages Podcast, Lucas and Luna dive into JSON — the unglamorous data format that quietly powers everything from REST APIs to machine learning pipelines. They unpack why JSON won the format wars, how it broke XML's grip, and where its limits start to show (no types, no comments, no streaming). Lucas digs into the recent IETF RFC 9427 updates that finally standard
Why SQL Is Making a Comeback in 2026
Episode 10 of The Programming Languages Podcast with Fexingo explores the surprising resurgence of SQL in 2026. Lucas and Luna dive into why SQL—often dismissed as a legacy language—is now being embraced by data engineers, ML practitioners, and even frontend developers. They discuss the rise of DuckDB, the adoption of SQL-based transformations in tools like dbt, and how new SQL extensions for vect
How a 17000 Line Python Codebase Broke in Production
A SaaS company's 17,000-line Python monolith crashed under 400 concurrent users on a Tuesday morning. Lucas and Luna walk through the real root cause: a single mutable default argument in a request handler that silently corrupted session state for hours before cascading into a full database connection pool exhaustion. They trace the bug from stack trace to fix, compare how Rust and Go would have c
Why SQLite Is the Most Deployed Database in the World
In this episode of The Programming Languages Podcast with Fexingo, Lucas and Luna explore why SQLite—a tiny, embedded database engine—is the most deployed database on the planet. They trace its origins with D. Richard Hipp back in 2000, unpack how it powers everything from smartphones to airplanes to web browsers, and discuss the surprising trade-offs that make it a go-to choice for millions of de
Why Kotlin Is Winning the Android World
In this episode of The Programming Languages Podcast, Lucas and Luna explore why Kotlin has become the dominant language for Android development. They trace its rise from a niche JVM language to Google's preferred choice, citing concrete numbers: 85% of the top 10,000 Android apps now use Kotlin, and the language's adoption is growing 30% year over year. They discuss how JetBrains designed Kotlin
Zig Is the Language That Rust Left Behind
Lucas and Luna explore why Zig is gaining traction as a simpler alternative to Rust for systems programming. They break down Zig's compile-time execution model, its approach to memory safety without a borrow checker, and why startups like TigerBeetle and Uber are experimenting with it. The conversation covers a specific benchmark where Zig outperformed Rust in a financial database workload, and wh
Why Go Is Winning the Cloud Infrastructure Wars
Episode 5 of The Programming Languages Podcast shifts focus to Go — the language Google built for scale. Lucas and Luna break down why Go, not Rust or Python, dominates cloud-native infrastructure in 2026. They trace Go's rise from Docker and Kubernetes to the CNCF ecosystem, crunch concrete adoption numbers: 82 percent of all cloud-native projects on GitHub are written in Go. Luna pushes back on
How Wasm Is Changing Serverless Computing
In this episode of The Programming Languages Podcast, Lucas and Luna explore WebAssembly's growing role in serverless computing. They break down how Wasm is being used to run lightweight, secure functions on the edge, comparing it to traditional container-based serverless platforms. The discussion focuses on a specific case: Fastly's Compute@Edge platform, which processes over 10 billion requests
TypeScript in 2026 The Type Safety Wave
Lucas and Luna explore how TypeScript has gone from a Microsoft experiment to the default choice for serious JavaScript development. They break down the numbers: npm downloads, job postings, and the 2026 State of JS survey showing TypeScript adoption at 89% among professional developers. Lucas walks through two concrete examples of type safety preventing production bugs, and they discuss whether T
Why Rust Is Eating the Systems Programming World
In episode two of The Programming Languages Podcast, Lucas and Luna explore why Rust is rapidly displacing C and C++ in systems programming. They examine the 2026 TIOBE index showing Rust entering the top 15, Google's decision to write Android firmware components in Rust, and Microsoft's claim that 70 percent of its security patches stem from memory safety bugs that Rust eliminates. The conversati
Why Python Is Still King in 2026
In the debut episode of The Programming Languages Podcast with Fexingo, Lucas and Luna zoom in on Python's enduring dominance as we hit mid-2026. They break down a single surprising number: Python now runs over 72% of all AI/ML workloads in production, up from 63% two years ago. They contrast this with the Rust hype cycle — yes, Rust is eating systems programming, but it's nowhere near Python's br
Recommended
1984, by George Orwell
19 Keys Presents High Level Conversations
19 Observations on mining and refining of critical minerals
1A
1Dime Radio
오늘 미국은
$100M Offers by Alex Hormozi, Book Summary, Podcast, English
0xResearch
10000 MINUTES
1000 Things You Should Know
1000x
1001 Classic Short Stories & Tales
