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
How Rust Is Shaping the Future of AI Infrastructure in 2026
In this episode of The Programming Languages Podcast with Fexingo, Lucas and Luna explore how Rust is becoming the go-to language for building the infrastructure that powers AI and machine learning workloads. They discuss why companies like Hugging Face, Anthropic, and startups in the AI space are adopting Rust for its performance, safety, and concurrency benefits. The hosts break down specific us
How Dart Is Powering Multiplatform Apps in 2026
Episode 90 of The Programming Languages Podcast with Fexingo dives into Dart, the language behind Flutter, and how it's quietly becoming a major player for multiplatform development. Lucas and Luna explore why Dart's just-in-time compilation and hot reload have made it a favorite for startups and enterprises alike, using the example of a fintech app that cut development time by 40 percent. They di
How TypeScript Transformed JavaScript Development in 2026
In this episode of The Programming Languages Podcast with Fexingo, Lucas and Luna explore how TypeScript has become the de facto standard for large-scale JavaScript development. They trace its evolution from a niche superset to a language that now powers over 80% of front-end frameworks and many backend projects. The hosts discuss a specific case study: how a mid-sized fintech startup migrated a m
Why Swift Concurrency Is Reshaping iOS App Architecture in 2026
Lucas and Luna explore how Swift's async/await and actor model are fundamentally changing the way iOS apps are built, moving from callback-heavy code to structured concurrency. They dive into real-world performance gains at companies like Uber and Spotify, where migrating to Swift concurrency cut crash rates and boosted responsiveness. The hosts break down the key concepts—async let, task groups,
Why Tauri Is the Future of Cross-Platform Desktop Apps
In this episode, Lucas and Luna explore Tauri, the rising framework that challenges Electron by using Rust for the backend and web technologies for the frontend. They break down how a typical Electron app using 200 MB of RAM can be replaced by a Tauri app using under 10 MB. They discuss real-world examples like the Discord desktop app's potential switch and the performance gains companies see in p
Why Python Is Still King of Data Engineering in 2026
In this episode, Lucas and Luna dive into why Python remains the undisputed leader in data engineering, even as newer languages like Rust and Go gain traction. They explore the rise of Apache Arrow, the impact of Polars as a Pandas alternative, and how Python's ecosystem around PySpark and Airflow keeps it dominant. With specific benchmarks and real-world examples from companies like Meta and Netf
Why SQLite Is the Hidden Gem of Embedded Databases in 2026
Lucas and Luna explore how SQLite has quietly become the most deployed database engine on the planet, powering everything from smartphones and web browsers to aviation and industrial IoT. They unpack its zero-config design, the surprising scale of its adoption (over one trillion databases in active use), and why it's now gaining traction in edge computing and serverless architectures. The episode
How Zig Challenges C Without a Runtime in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna dive into Zig, the systems programming language that's gaining traction as a modern alternative to C. They explore how Zig's lack of hidden control flow, compile-time memory management, and seamless C interoperability make it a compelling choice for performance-critical projects. With the recent 0.14 release and growing adoption
Why OCaml Is the Secret Weapon for Financial Systems in 2026
Lucas and Luna explore why OCaml, a decades-old functional programming language, is experiencing a quiet resurgence in 2026 — particularly in financial technology and formal verification. They break down how Jane Street Capital processes billions of dollars in trades daily using OCaml, why its type system prevents entire categories of bugs that plague C++ and Java, and how the language's unique 'e
Why Solidity and Rust Are Dominating Smart Contract Development in 2026
In this episode, Lucas and Luna dive into the battle between Solidity and Rust for smart contract development as of mid-2026. They explore how Solidity remains the dominant language on Ethereum, with over 90% of deployed contracts written in it, but how Rust is rapidly gaining ground through platforms like Solana and NEAR, where it powers faster, more secure contracts. The hosts discuss specific c
Why Python Is Still the King of Data Science in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna explore Python's enduring dominance in data science and machine learning, even as newer languages like Mojo and Julia gain traction. They dive into the Python ecosystem's key strengths: the maturity of libraries like PyTorch and scikit-learn, the vast community, and the language's role in the AI boom. They also discuss the challe
Why WebAssembly Is Going Mainstream in 2026
WebAssembly, or Wasm, is no longer just a niche tool for browser gaming. In 2026, it's running server-side functions, powering edge computing, and even replacing containers in some deployments. Lucas and Luna dive into the specific numbers: over 70% of cloud providers now support Wasm runtime, and how companies like Cloudflare and Fastly are using it to reduce cold-start latency from hundreds of m
Why Julia Is Becoming the Language for Scientific Computing in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna dive into Julia — the high-performance language that's quietly reshaping scientific computing, data science, and machine learning. They explore why Julia's just-in-time compilation and multiple dispatch make it a compelling alternative to Python for numerical work, and discuss how the Pumas project is using Julia for pharmaceutic
Why Haskell Is Making a Comeback in Production in 2026
Episode 78 of The Programming Languages Podcast explores Haskell's unexpected resurgence in production environments. Lucas and Luna break down why companies like GitHub, JPMorgan Chase, and a European airline are adopting this purely functional language for critical systems. We focus on the concrete case of a legacy Spark pipeline at a major bank being rewritten in Haskell — cutting infrastructure
How Lua Became the Unsung Hero of Game Development
In this episode of The Programming Languages Podcast with Fexingo, Lucas and Luna explore why Lua, a lightweight scripting language created in 1993, remains the hidden backbone of modern game development. They discuss how game engines like Roblox and World of Warcraft embed Lua for modding and customization, the language's unique design trade-offs (no native classes, 1-based indexing), and why its
How Elixir Powers Fault-Tolerant Real-Time Systems in 2026
In this episode, Lucas and Luna dive into Elixir—a language that's quietly becoming the go-to for building fault-tolerant, real-time systems. They explore how Elixir's actor model, built on the Erlang VM, allows companies like Discord and Pinterest to handle millions of concurrent users with minimal downtime. The conversation focuses on Discord's migration from Go to Elixir in 2023 and how that de
How Apache Kafka Became the Backbone of Event-Driven Architecture in 2026
Lucas and Luna dive into Apache Kafka's evolution from a LinkedIn messaging system to the de facto standard for event-driven architecture in 2026. They unpack how Kafka's log-based design handles millions of events per second at companies like Uber and Netflix, why its ecosystem has grown to include Kafka Connect and Kafka Streams, and how new tiered storage and KRaft consensus are reshaping its f
How Erlang Is Powering WhatsApp and Telecoms in 2026
In this episode, Lucas and Luna dive into Erlang, the 40-year-old language that still runs WhatsApp's messaging backbone and powers telecom switches handling billions of calls. They explore why Erlang's actor model, hot code swapping, and fault tolerance are uniquely suited for high-reliability systems, and how it compares to modern languages like Rust and Go. The hosts discuss real-world numbers:
Why GraphQL Is NOT Dead in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna challenge the growing narrative that GraphQL is a failed experiment. They examine a real-world case: how a mid-size e-commerce company achieved a 40 percent reduction in mobile data usage by switching from REST to GraphQL in mid-2025. The hosts break down the performance numbers, discuss why some teams struggle with GraphQL, and
How Go Is Winning the Cloud-Native Wars in 2026
Lucas and Luna dive into why Go has become the dominant language for cloud-native infrastructure, using Kubernetes as a case study. They discuss Go's simplicity, fast compile times, and concurrency model, and how it compares to Rust and Java for microservices. With over 7 out of 10 cloud-native projects now using Go, they explore the trade-offs and why big tech like Uber and Twitch are migrating t
Why Rust Is Becoming the Standard for Embedded Systems in 2026
Lucas and Luna dive into why Rust is rapidly becoming the go-to language for embedded systems development. With a focus on memory safety, zero-cost abstractions, and growing ecosystem support, they explore real-world adoption by companies like Google in Android's Rust-based Binder driver and Infineon's Rust SDK for microcontrollers. They discuss how Rust's ownership model eliminates entire classes
How Kotlin Is Dominating Android and Beyond in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna explore how Kotlin has become the dominant language for Android development and is now expanding into server-side, multiplatform, and data science. They discuss Kotlin's rise from JetBrains' lab to Google's preferred language, its modern features like coroutines and null safety, and how it's competing with Java, Swift, and Rust.
How Dart Is Winning Over Mobile and Web Developers in 2026
Lucas and Luna dive into Dart's surprising surge in 2026. With Flutter powering everything from mobile apps to embedded displays, Dart has become one of the fastest-growing languages on GitHub. We look at why developers are choosing it over JavaScript and Kotlin, how Google's investment is paying off, and a real-world case study from a fintech startup that cut its codebase in half. Plus, the hosts
How TypeScript Is Eating the JavaScript World in 2026
Lucas and Luna explore how TypeScript has grown from a niche superset to the default language for large-scale JavaScript development in 2026. They break down the recent milestone of 70% adoption among professional developers, the impact of the TypeScript 5.8 release with its new decorator standard, and why companies like Vercel and Google are investing heavily in the ecosystem. The episode also co
How Modern C++ Is Still Dominating in 2026
Lucas and Luna explore the surprising staying power of C++ in 2026. With recent updates like C++23 and C++26 on the horizon, the language continues to dominate high-performance domains—from game engines to financial trading to autonomous vehicles. They break down why C++ remains indispensable despite the rise of Rust and Zig, using concrete examples like Unreal Engine 5 and high-frequency trading
How Rust Is Rewriting the Linux Kernel in 2026
Episode 66 dives into Rust's growing role inside the Linux kernel as of June 2026. Lucas and Luna explore the recent merge of Rust-for-Linux patches into mainline, the number of Rust drivers now shipping, and what this means for memory safety in critical infrastructure. They discuss the tension between C maintainers and Rust advocates, the performance trade-offs, and why companies like Google and
Why Developers Are Turning to Mojo for AI Performance
Lucas and Luna dive into Mojo, a new programming language designed to combine Python's usability with C-level performance for AI and ML workloads. They explore how Modular's creation uses MLIR to run AI models up to 3500 times faster than Python, why it's gaining traction in the AI community in 2026, and how it compares to alternatives like CUDA and Julia. With specific benchmarks and real-world u
Why SQLite Powers Billions of Devices in 2026
In this episode of The Programming Languages Podcast with Fexingo, Lucas and Luna unpack the quiet dominance of SQLite — the world's most deployed database engine. They explore why this embedded, serverless library runs on more than one trillion devices, from smartphones and cars to web browsers and spacecraft. The hosts dive into SQLite's unique architecture: no client-server setup, zero configur
Why Zig Is Poised to Replace C in Systems Programming
Zig, a new systems programming language, is gaining traction as a potential successor to C. In this episode, Lucas and Luna explore why developers are turning to Zig for its safety, clarity, and simplicity. They discuss how Zig's approach to memory management, compile-time execution, and cross-compilation offers concrete advantages over C for systems programming. The hosts examine real-world adopt
Why OCaml Is the Language for Financial Systems in 2026
Episode 62 of The Programming Languages Podcast explores why OCaml has become a powerhouse in the financial technology sector. Lucas and Luna examine how Jane Street, a quantitative trading firm, relies on OCaml for its core trading systems—processing billions of dollars daily. They discuss OCaml's strong static typing, pattern matching, and garbage collection that make it ideal for correctness-cr
How SQLite Powers Billions of Devices in 2026
Lucas and Luna dive into the quiet dominance of SQLite — the embedded database engine that runs on over a trillion devices, from smartphones and web browsers to aircraft and IoT sensors. They unpack why a library with no server, no configuration, and no separate process has become the most deployed database in the world. Using real numbers — including the 2025 SQLite Consortium release — they expl
How R Is Powering Data Science in 2026
Lucas and Luna explore why R, the 30-year-old statistical programming language, is experiencing a renaissance in 2026. They break down the explosion of the R-Universe package ecosystem—now over 25,000 packages—and how modern tools like Quarto and the Tidyverse are making R competitive with Python for data science. The hosts discuss a real-world case: how the U.S. Census Bureau's switch to R for it
Why WebAssembly Is the Future of Cloud Computing in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna explore how WebAssembly (Wasm) is quietly transforming cloud computing. They dive into a concrete case: Fastly's adoption of Wasm for edge computing, which reduced cold-start times from 50 milliseconds to under 1 millisecond. They discuss why startups like Fermyon and Suborbital are betting on Wasm over containers, and how the co
How Zig Is Poised to Replace C in Systems Programming
In this episode of The Programming Languages Podcast, Lucas and Luna explore why Zig is gaining momentum as a modern alternative to C for systems programming. They dive into Zig's core design philosophy: no hidden control flow, first-class cross-compilation, and a compile-time execution model that eliminates the preprocessor. Lucas breaks down how Zig's comptime feature allows metaprogramming with
How Lua Became the Unsung Hero of Game Development
Lua is everywhere in gaming, yet most developers barely know it exists. In this episode, Lucas and Luna trace how a tiny scripting language from Brazil became the embedded language of choice for World of Warcraft, Roblox, and even Redis. They unpack why Lua's simplicity and C-friendly design made it a natural fit for games, how Roblox created an entire economy around it, and what LuaJIT's uncertai
How Scala 3 Is Winning Back Enterprise Developers in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna explore why Scala 3 is quietly gaining traction among enterprise developers in 2026. They break down specific language improvements like enums, given/using clauses, and the new macro system, and compare Scala's strengths to Kotlin and Java. They also touch on real-world adoption at companies like ZIO and Akka, and reflect on whet
Why Haskell Is the Language for Correctness in 2026
In this episode of The Programming Languages Podcast, Lucas and Luna explore why Haskell is experiencing a resurgence in 2026 as the go-to language for mission-critical software where correctness is paramount. They dive into how companies like Mercury, a fintech startup, have adopted Haskell for its strong type system and purity guarantees, reducing production bugs by 40% compared to their previou
Why Developers Are Choosing Gleam for Type-Safe BEAM in 2026
This episode of The Programming Languages Podcast dives into Gleam, a type-safe, functional language that compiles to Erlang's BEAM VM. Lucas and Luna unpack why developers frustrated with Elixir's dynamic typing and JavaScript's complexity are flocking to Gleam. They discuss Gleam's strict type system, its seamless interop with Erlang and Elixir libraries, and real-world adoption at companies lik
Why Elixir's OTP Is the Secret Weapon for Fault-Tolerant Systems
Lucas and Luna explore why Elixir's OTP (Open Telecom Platform) is gaining traction for building fault-tolerant, concurrent systems in 2026. They dive into a specific case: how Discord uses Elixir and OTP to handle millions of concurrent voice and chat users with minimal downtime. The hosts break down OTP's supervision trees, GenServers, and how Elixir's Erlang heritage makes it a unique choice fo
Why Julia Is the Language for Scientific Computing in 2026
Lucas and Luna explore why Julia, the high-performance language for numerical analysis, is finally breaking into production environments in 2026. They focus on the specific case of the Julia package ecosystem, particularly the DifferentialEquations.jl library, which is now used by NASA and Pfizer for modeling complex systems. The episode contrasts Julia with Python's NumPy and SciPy stack, examini
How Pony Is Bringing Safe Concurrency to Production Systems
Pony is an open-source programming language that brings the actor model and reference capabilities together for provably safe concurrency without a garbage collector pause. In this episode, Lucas and Luna explore how Pony's type system eliminates data races at compile time, why it's gaining traction in high-frequency trading and IoT, and how it compares to Rust, Erlang, and Go for concurrent workl
Why Developers Are Choosing Elixir for Real-Time Systems in 2026
In this episode, Lucas and Luna explore why Elixir, built on the Erlang VM, has become the language of choice for real-time, fault-tolerant systems in 2026. They dive into a specific case: Discord's move to Elixir for its messaging infrastructure, handling 400 million concurrent events daily with 99.999% uptime. The discussion covers the Actor model, OTP's supervision trees, and how Elixir's Phoen
Why Developers Are Choosing Kotlin for Server-Side in 2026
Episode 49 of The Programming Languages Podcast explores the rise of Kotlin on the server side. Lucas and Luna discuss why developers are increasingly choosing Kotlin over Java for backend systems, citing Kotlin's concise syntax, null safety, and seamless Java interop. They examine real-world adoption at companies like Netflix and Uber, and analyze how Kotlin's features like coroutines and data cl
Why Go Is the Language for Cloud Infrastructure in 2026
Lucas and Luna dive into why Go (Golang) has become the dominant language for cloud infrastructure in 2026. They break down how Go's concurrency model, fast compilation, and built-in tooling make it the default choice for Docker, Kubernetes, Terraform, and countless other cloud-native projects. Specific numbers: Go now powers over 75% of CNCF projects. The episode explores the technical decisions
Why Developers Are Coding on iPads and Tablets in 2026
Lucas and Luna dig into the surprising rise of tablet-based coding. With Apple's iPad Pro M4 pushing 120 fps in Xcode and Samsung's DeX mode running full VS Code, more developers are ditching laptops for slates. They break down the hardware specs, the software gaps (no Docker on iPad, limited local emulation), and the real-world workflow of a mobile developer who codes entirely on an iPad. Plus: w
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
Recommended
Saints‘ Hill Church Podcast
The Arab Film Club Podcast
AI Fire Daily
The Fifteenth Page Show | AI Systems, Marketing Tips, andContent Marketing Strategy for Busy Teams
Intrigue Outloud
The Daily
Doctor Zhivago Slow Read
Conspiracy Files with Paige Carter
This Past Weekend w/ Theo Von
The Theory of Psychoanalysis - Carl Jung
A Life Engineered
پادکست بهزاد بلور | Behzad Bolour's Podcast
