The Programming Languages Podcast with Fexingo: Python, Rust, JavaScript, and Modern Coding

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 its 2030 Census modeling saved an estimated $15 million in licensing fees. They also cover the rise of R in biotech, with companies like Moderna using R for clinical trial analysis. The episode ends with a look at why R's built-in statistical graphics and domain-specific packages give it an edge for certain workflows. Lucas and Luna also briefly touch on listener support and how it keeps the show ad-free. #R #DataScience #RStats #Tidyverse #RUniverse #Statistics #Programming #Technology #FexingoBusiness #BusinessPodcast #OpenSource #Census #Moderna #Quarto #RMarkdown #DataVisualization #Renaissance #2026 Keep every episode free: buymeacoffee.com/fexingo

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 component model is enabling polyglot microservices. The hosts also touch on the rise of Wasm in serverless platforms, including a 2026 benchmark showing Wasm outperforming Node.js and Python by 10x in throughput for certain workloads. If you're a developer wondering whether Wasm is more than a browser novelty, this episode gives you the data and context to understand its server-side future. #WebAssembly #Wasm #CloudComputing #Serverless #EdgeComputing #Fastly #Fermyon #Suborbital #PolyglotMicroservices #ComponentModel #Technology #Programming #FexingoBusiness #BusinessPodcast #TechPodcast #CloudNative #WASI #ComputeAtEdge Keep every episode free: buymeacoffee.com/fexingo

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 without macros, and he cites the growing number of production tools—like the Bun runtime and TigerBeetle—that are built in Zig. Luna questions whether Zig's minimal standard library is a feature or a pain point, and they compare the Zig learning curve to Rust's. They also discuss the Zig community's focus on compiler self-hosting and the project's recent 0.14 release. The episode closes with a look at where Zig sits in the 2026 systems landscape: not yet mainstream, but increasingly hard to ignore for developers who need C-level performance without C's pitfalls. #Zig #SystemsProgramming #ProgrammingLanguages #Technology #CProgramming #CompilerDesign #Metaprogramming #CrossCompilation #Comptime #Bun #TigerBeetle #SelfHosting #Podcast #FexingoBusiness #BusinessPodcast #TechPodcast #SoftwareEngineering #Coding Keep every episode free: buymeacoffee.com/fexingo

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 uncertain future means for the ecosystem. If you've ever modded a game or written a WoW addon, you've touched Lua. This episode explains why that matters for the next generation of programmable worlds. #Lua #GameDevelopment #Roblox #WorldOfWarcraft #EmbeddedScripting #LuaJIT #ProgrammingLanguages #Technology #FexingoBusiness #BusinessPodcast #SoftwareEngineering #IndieDev #Modding #CAPI #BrazilTech #Gaming #TechHistory #DeveloperTools Keep every episode free: buymeacoffee.com/fexingo

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 whether Scala's learning curve is finally easing. A must-listen for developers evaluating JVM languages for production systems. #Scala3 #Programming #Technology #JVM #EnterpriseSoftware #TypeSafety #FunctionalProgramming #ZIO #Akka #Kotlin #Java #Scala #SoftwareDevelopment #Coding #FexingoBusiness #BusinessPodcast #TechPodcast #ProgrammingLanguages Keep every episode free: buymeacoffee.com/fexingo

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 previous Java codebase. Lucas explains the concept of 'type-driven development' and how Haskell's lazy evaluation and monadic I/O force developers to think about edge cases upfront, leading to more reliable systems. Luna pushes back on the learning curve, and they discuss how the GHC compiler's improvements and the growing ecosystem of libraries like Servant and Persistent are lowering the barrier to entry. They also touch on the wider trend in 2026 of financial institutions and healthcare systems adopting Haskell for regulatory compliance and auditability. The episode closes with a reflection on whether correctness will ever outweigh developer productivity in language adoption. #Haskell #ProgrammingLanguages #FunctionalProgramming #TypeDrivenDevelopment #SoftwareCorrectness #Mercury #Fintech #GHC #Servant #Persistent #Monads #LazyEvaluation #Technology #FexingoBusiness #BusinessPodcast #LucasAndLuna #Episode55 #TechDebate Keep every episode free: buymeacoffee.com/fexingo

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 like Supabase. The hosts also explore Gleam's growing ecosystem, including its build tool and package manager, and why its simplicity is a breath of fresh air for concurrent systems. Whether you're a BEAM veteran or just curious about the next big language, this episode delivers one concrete takeaway: Gleam is the language that makes type-safe, fault-tolerant programming accessible without the cognitive overhead of Haskell or Rust. #Gleam #BEAM #Erlang #Elixir #TypeSafety #FunctionalProgramming #Concurrency #Supabase #ProgrammingLanguages #Tech2026 #Technology #FexingoBusiness #BusinessPodcast #CodeCraft #DeveloperTools #OpenSource #SoftwareEngineering #WebDevelopment Keep every episode free: buymeacoffee.com/fexingo

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 for modern infrastructure. They also discuss the trade-offs versus Go or Rust for similar workloads, and why startups are increasingly adopting Elixir for real-time features. A concrete look at a language that prioritises resilience over raw speed. #Elixir #OTP #Erlang #FaultTolerant #Concurrency #Discord #GenServer #SupervisionTrees #RealTime #SoftwareEngineering #Technology #ProgrammingLanguages #TechPodcast #FexingoBusiness #BusinessPodcast #OpenTelecomPlatform #BEAM #PhoenixFramework Keep every episode free: buymeacoffee.com/fexingo

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, examining how Julia's just-in-time compilation and multiple dispatch solve the 'two-language problem' that has plagued data scientists for decades. Lucas explains how Julia's compiler, LLVM-based, achieves C-like performance without dropping into C or C++ for hot loops. Luna asks whether Julia's relatively small community and package maturity are still barriers. They discuss the impact of Julia's integration with Jupyter notebooks and VS Code, and how companies like AstraZeneca and the Allen Institute have adopted Julia for drug discovery and neuroscience. The episode closes with a reflection on whether Julia will remain a niche tool or become a mainstream language for data-heavy industries. #JuliaLanguage #ScientificComputing #NumericalAnalysis #DifferentialEquations #JITCompilation #MultipleDispatch #LLVM #TwoLanguageProblem #NumPy #SciPy #Python #DataScience #HPC #HighPerformanceComputing #AstraZeneca #NASA #Pfizer #AllenInstitute Keep every episode free: buymeacoffee.com/fexingo

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 workloads. They walk through a real example: a Pony program that manages thousands of simultaneous WebSocket connections with zero shared mutable state. Along the way, they discuss the language's origin story at Causality Labs, its adoption at companies like Wallaroo Labs and Sendence, and why the Pony community's focus on formal correctness is attracting researchers and engineers tired of debugging race conditions. If you're building systems where every millisecond and every thread matters, Pony might be the language you haven't tried — but should. #PonyLanguage #ConcurrentProgramming #ActorModel #ReferenceCapabilities #NoDataRaces #SafeConcurrency #SystemsProgramming #HighFrequencyTrading #IoT #OpenSource #CausalityLabs #WallarooLabs #Sendence #RealTimeSystems #ProgrammingLanguages #Technology #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 Phoenix framework with LiveView is changing web development. They also address common criticisms, like the learning curve and ecosystem maturity, and contrast Elixir with Go and Rust for high-concurrency workloads. A concrete look at where Elixir shines and where it doesn't. #Elixir #RealTimeSystems #Concurrency #ErlangVM #OTP #PhoenixFramework #LiveView #Discord #FaultTolerance #ActorModel #Programming #Technology #SoftwareDevelopment #HighConcurrency #WebDevelopment #Backend #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 classes improve developer productivity. The episode also touches on Kotlin's growing ecosystem, including frameworks like Ktor and Spring Boot with Kotlin support. A must-listen for anyone considering Kotlin for their next backend project. #Kotlin #ServerSideKotlin #JavaAlternative #JVM #BackendDevelopment #Coroutines #Ktor #SpringBoot #NetflixTech #UberEngineering #NullSafety #DeveloperProductivity #ProgrammingLanguages #Technology #FexingoBusiness #BusinessPodcast #TechPodcast #ModernCoding Keep every episode free: buymeacoffee.com/fexingo

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 that made Go win—like goroutines over threads, and static binaries. They discuss the trade-offs Go made (no generics originally, simpler error handling) and why those trade-offs were right for infrastructure. A must-listen for developers choosing their next language for backend or cloud work. #GoLang #Golang #CloudInfrastructure #CloudNative #Kubernetes #Docker #Terraform #Concurrency #Goroutines #CNCF #ProgrammingLanguages #Backend #DevOps #InfrastructureAsCode #Technology #FexingoBusiness #BusinessPodcast #TheProgrammingLanguagesPodcast Keep every episode free: buymeacoffee.com/fexingo

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: what the rise of cloud IDEs means for the future of the workstation. If you've ever wondered whether you could code on a tablet, this episode is for you. #iPadPro #TabletCoding #M4Chip #Xcode #VSCode #SamsungDeX #CloudIDE #MobileDevelopment #RemoteWork #DeveloperWorkflow #Technology #Fexingo #FexingoBusiness #BusinessPodcast #ProgrammingLanguages #Coding #iPad #DeveloperTools Keep every episode free: buymeacoffee.com/fexingo

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, including the 90% satisfaction rating and the dramatic shift of major libraries like React, Vue, and Svelte to first-class TypeScript support. They also discuss how TypeScript is expanding beyond the browser into backend with Deno and Bun, and the impact of Microsoft's recent push for stricter TypeScript configurations in open-source projects. The episode closes with a look at how TypeScript is reshaping developer education and tooling in 2026. #TypeScript #JavaScript #ProgrammingLanguages #Technology #FexingoBusiness #BusinessPodcast #StateOfJS #Deno #Bun #Microsoft #OpenSource #TypeSafety #React #Vue #Svelte #DeveloperTools #AI #CodeGeneration Keep every episode free: buymeacoffee.com/fexingo

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, and Microsoft are prioritizing Rust for performance-critical paths, and how the newly stable Rust 2025 edition has improved async support and compile times. Luna raises the learning curve concern, while Lucas counters with concrete examples of reduced debugging time. They also discuss the broader ecosystem shift—libraries like Tokio, Serde, and Bevy are maturing fast. The episode grounds its claims in specific numbers, avoiding hype, and ends with a forward-looking question about Rust's potential to replace C++ in the next decade. #Rust #ProgrammingLanguages #SystemsProgramming #Performance #Safety #LinuxKernel #Android #GitHubOctoverse #Tokio #Serde #Bevy #CPlusPlus #WebAssembly #EmbeddedSystems #Tech2026 #FexingoBusiness #BusinessPodcast #Technology Keep every episode free: buymeacoffee.com/fexingo

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 2 million apps on Google Play, a 40% developer satisfaction lead over React Native in Stack Overflow's 2025 survey, and why companies like Toyota and BMW are building their in-car interfaces with Flutter. Luna brings up the elephant in the room—whether Dart's niche status hurts hiring—and they debate the tradeoffs. No ads: support at buy me a coffee dot com slash fexingo. #Dart #Flutter #CrossPlatform #ReactNative #MobileDevelopment #Google #FuchsiaOS #Skia #JITCompilation #AOTCompilation #TechPodcast #ProgrammingLanguages #DeveloperTools #AmbientComputing #InCarUI #Toyota #BMW #FexingoBusiness Keep every episode free: buymeacoffee.com/fexingo

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 quick, one-off transformations. Lucas argues that knowing AWK makes you faster at everyday data tasks, while Luna asks about readability and team workflows. #AWK #CommandLine #Unix #TextProcessing #DataAnalysis #Linux #Bash #Programming #Technology #FexingoBusiness #BusinessPodcast #ProductivityTools #OneLiners #CSV #Sed #Grep #Regex #DeveloperTools Keep every episode free: buymeacoffee.com/fexingo

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 trading platform cut p99 latency from 12 milliseconds to under 2 milliseconds using virtual threads, and why the JVM's mature garbage collectors handle multi-terabyte heaps more predictably than newer runtimes. The hosts also discuss the JVM's expanding role in data engineering through Apache Spark and its synergy with Kotlin. A donation segment acknowledges listener support for keeping the show ad-free. #JVM #Java #ProjectLoom #VirtualThreads #GraalVM #NativeImage #Kotlin #ApacheSpark #GarbageCollection #G1GC #ZGC #Go #CloudNative #Backend #Latency #Performance #Technology #FexingoBusiness Keep every episode free: buymeacoffee.com/fexingo

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. A must-listen for developers curious about functional programming in production. #OCaml #JaneStreetCapital #FunctionalProgramming #FinancialTechnology #ProgrammingLanguages #SoftwareDevelopment #TypeSafety #RustLanguage #QuantitativeFinance #TradingSystems #MLInference #TechPodcast #FexingoBusiness #BusinessPodcast #Technology #LucasAndLuna #PodcastEpisode41 #DarkHorseLanguage Keep every episode free: buymeacoffee.com/fexingo

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++ is a multi-decade project. Specific numbers: Carbon's initial announcement GitHub stars, current commit velocity, and the size of the C++ codebase it targets. #CarbonLanguage #CPlusPlus #Google #ProgrammingLanguages #SystemsProgramming #SoftwareEngineering #OpenSource #LanguageDesign #LegacyCode #Interoperability #Technology #Podcast #FexingoBusiness #BusinessPodcast #TheProgrammingLanguagesPodcast #Episode40 #2026 #TechTrends Keep every episode free: buymeacoffee.com/fexingo

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 companies like Stripe use SQL to run real-time risk models. If you've been ignoring SQL, this episode will convince you to reconsider. #SQL #SQLite #DuckDB #Database #DataEngineering #Analytics #Stripe #Fintech #WindowFunctions #PostgreSQL #QueryOptimization #ProgrammingLanguages #Technology #FexingoBusiness #BusinessPodcast #DeveloperSkills #CareerGrowth #DataScience Keep every episode free: buymeacoffee.com/fexingo

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 Cloud Native Computing Foundation survey showing 45% of cloud infrastructure teams now experiment with Wasm. Luna challenges whether Wasm can replace containers entirely, and they discuss real-world adoption at companies like Adobe and Shopify. The hosts also touch on the upcoming WebAssembly GC proposal and its impact on Java and Python developers. A donation segment is woven in naturally. #WebAssembly #CloudComputing #Serverless #WasmEdge #FermyonSpin #CNCF #Adobe #Shopify #Containers #Microservices #CloudNative #WasmGC #Java #Python #Technology #ProgrammingLanguages #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 abstractions, compile-time execution, and its role in reducing undefined behavior without a garbage collector. With concrete examples from the Godot game engine and the Bun JavaScript runtime, this episode explains why developers are choosing Zig for projects requiring fine-grained control and reliability. If you're curious about the next big thing in systems programming, this conversation covers what makes Zig different from its predecessors and where it's headed. #Zig #SystemsProgramming #ProgrammingLanguages #FexingoBusiness #Technology #Podcast #LucasAndLuna #EmbeddedSystems #GameDevelopment #MemorySafety #CompileTime #Godot #Bun #CRust #NoGarbageCollector #CrossCompilation #SoftwareDevelopment #ZeroCostAbstractions Keep every episode free: buymeacoffee.com/fexingo

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 standard library. They explore concrete benchmarks (up to 35000x speedup on certain matrix operations), the controversial decision to keep Mojo closed source, and whether it truly threatens Python in data science. The conversation also touches on Mojo's borrow checker (Rust-like memory safety) and how it integrates with existing Python tooling like NumPy and PyTorch. #Mojo #ModularAI #Python #MachineLearning #MLIR #Performance #SystemsProgramming #BorrowChecker #DataScience #AI #Compiler #OpenSource #NumPy #PyTorch #Technology #ProgrammingLanguages #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 environments like ESP32 microcontrollers. They also discuss the trade-offs—why Lua isn't for large-scale applications—and where it sits alongside Python and JavaScript in the modern developer's toolkit. #Lua #GameDevelopment #EmbeddedSystems #Roblox #Redis #IoT #ESP32 #ProgrammingLanguages #ScriptingLanguages #CoronaSDK #Minimalism #Technology #FexingoBusiness #BusinessPodcast #TheProgrammingLanguagesPodcast #LuaIn2026 #LightweightScripting #SoftwareEngineering Keep every episode free: buymeacoffee.com/fexingo

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 cloud providers, and the collapse of the Oracle-to-SQL Server duopoly in enterprise. They also touch on the surprising role of Notion, which moved its entire 100-plus terabyte infrastructure from MongoDB to Postgres in 2025. If you are choosing a database for your next project, this episode gives you the specific reasons why Postgres might be the pick for 2026. #PostgreSQL #Database #Technology #OpenSource #pgvector #AI #VectorSearch #CloudComputing #Notion #MongoDB #Oracle #SQLServer #OLTP #RealTimeAnalytics #TechPodcast #FexingoBusiness #BusinessPodcast #LukeAndLuna Keep every episode free: buymeacoffee.com/fexingo

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 through the design decisions that made Go the default for kube-native tooling, the rise of eBPF as a Rust use case, and what the Kubernetes API design philosophy means for language adoption in 2026. They also consider whether the next wave of infrastructure languages will emerge from inside or outside the Kubernetes ecosystem. Specific examples include the Operator pattern, the contribution of projects like Krustlet and KubeVirt, and the surprising role of CUE in configuration. #Kubernetes #Go #Rust #CloudNative #eBPF #OperatorPattern #Krustlet #CUE #KubeVirt #Configuration #Infrastructure #ProgrammingLanguages #Technology #ContainerOrchestration #DevOps #FexingoBusiness #BusinessPodcast #TechConversation Keep every episode free: buymeacoffee.com/fexingo

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 Gleam fits into the growing ecosystem of typed functional languages. The episode also covers the language's unique approach to pattern matching, its interop with existing Erlang and Elixir code, and why its v1.0 release in 2025 is gaining traction among developers tired of JavaScript's complexity. #Gleam #Erlang #BEAM #FunctionalProgramming #TypeSystems #Rust #Elixir #Technology #TechPodcast #ProgrammingLanguages #SoftwareDevelopment #StaticTyping #PatternMatching #Bluetau #FexingoBusiness #BusinessPodcast #Podcast #Fexingo Keep every episode free: buymeacoffee.com/fexingo

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 concurrency without a server. They discuss its origins in the 2000 dot-com bust, its adoption by every major mobile OS, and its surprising role in the 2026 serverless and edge computing landscape. Specific numbers: over one trillion SQLite databases are in active use, and the codebase has 100 percent branch test coverage. The hosts also touch on SQLite's limitations and when you should reach for something else. If you've ever wondered what's really storing your phone's text messages or your browser's bookmarks, this episode is for you. #SQLite #Database #EmbeddedDatabase #Serverless #EdgeComputing #OpenSource #PublicDomain #DevTools #SoftwareInfrastructure #MobileDevelopment #Backend #DataStorage #Technology #Coding #Fexingo #FexingoBusiness #BusinessPodcast #ProgrammingLanguagesPodcast Keep every episode free: buymeacoffee.com/fexingo

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 down the core trade-off: formal methods catch bugs that testing never will, but they require a fundamentally different mindset and impose steep upfront costs. With tools like Dafny, F*, and the rise of Rust's safety guarantees, the hosts ask whether 2026 is finally the year formal verification goes mainstream. The conversation touches on the real-world math behind Amazon's DynamoDB consistency proofs, why start-ups are hiring verification engineers, and the open-source projects leading the charge. #FormalVerification #TLA+ #AmazonWebServices #Dafny #Rust #ProgrammingLanguages #SoftwareCorrectness #DistributedSystems #DynamoDB #TechPodcast #Technology #FexingoBusiness #BusinessPodcast #Podcast #Programming #SoftwareEngineering #OpenSource #CodeQuality Keep every episode free: buymeacoffee.com/fexingo

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 pinning with verified lockfiles, and runtime monitoring tools like OpenGuard. They drill into the specific case of the 'user-agent-parse' attack in February 2026, where a typosquatted package exfiltrated AWS credentials from 2000 CI pipelines before being caught. The episode concludes with a practical checklist any team can implement this week to reduce their exposure, including why 'just audit your dependencies' is no longer enough. No abstract warnings: concrete tools, real CVEs, and a realistic threat model for a mid-sized engineering team in mid-2026. #SupplyChainSecurity #SoftwareSecurity #npm #Sigstore #OpenGuard #Typosquatting #DevOps #CyberSecurity #JavaScript #PythonPackaging #CI/CD #PackageManagement #DependencyHell #Technology #FexingoBusiness #BusinessPodcast #DeveloperTools #OpenSourceSecurity Keep every episode free: buymeacoffee.com/fexingo

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 native platforms. Specific numbers: Kotlin Multiplatform adoption grew 40% year-over-year since 2024, with 15% of new mobile apps using it by early 2026. The discussion includes real-world performance benchmarks and developer experience comparisons. #KotlinMultiplatform #JetBrains #MobileDevelopment #CrossPlatform #Android #iOS #Flutter #ReactNative #ProgrammingLanguages #Technology #FexingoBusiness #BusinessPodcast #SoftwareEngineering #Kotlin #NativeApps #CodeSharing #Netflix #Uber Keep every episode free: buymeacoffee.com/fexingo

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 whether Zig's manual memory management is a dealbreaker for most teams, and presses Lucas on what's missing: maturity, library ecosystem, and documentation. The hosts compare Zig to Rust, C, and Go, using specific examples like building a zero-overhead allocator and cross-compiling for Raspberry Pi from macOS. They close on whether Zig's 'no hidden allocations' philosophy is worth the trade-off for production code in 2026. #Zig #SystemsProgramming #ProgrammingLanguages #Technology #CompileTime #CrossCompilation #EmbeddedSystems #GameDev #CLI #Performance #MemoryManagement #Rust #CProgramming #GoLang #Allocators #DeveloperTools #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 decade. With cloud workloads exploding, Go's balance of productivity and performance has made it the language behind most of the modern DevOps stack. The episode draws on real usage data, including a 2025 survey showing 68% of Kubernetes contributors primarily use Go, and examines where Go still struggles — like its limited native GUI or mobile support. By the end, listeners will understand why Go earned its reputation as 'the language for the network age' and whether it can maintain that lead as newer languages like Rust and Zig gain traction. #Go #Golang #CloudNative #Kubernetes #Docker #Terraform #Concurrency #Goroutines #Google #DevOps #InfrastructureAsCode #BackendEngineering #ProgrammingLanguages #Technology #CloudComputing #FexingoBusiness #BusinessPodcast #Podcast Keep every episode free: buymeacoffee.com/fexingo

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 productivity, and why the shift is accelerating despite Python's dominance in AI and data science. The conversation also touches on the role of AI coding assistants in smoothing Rust's learning curve. If you're a developer deciding between Python's rapid prototyping and Rust's performance guarantees, this episode gives you concrete numbers and real-world context to inform your choice. #Rust #Python #SystemsProgramming #ProgrammingLanguages #Fintech #MemorySafety #Performance #Latency #DeveloperProductivity #AICodingAssistants #TransactionEngine #OwnershipModel #BorrowChecker #Coding #Technology #FexingoBusiness #BusinessPodcast #Podcast Keep every episode free: buymeacoffee.com/fexingo

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 making the switch. With the rise of AI coding assistants that generate TypeScript by default, the language's popularity shows no signs of slowing. Lucas shares data on TypeScript's 40% year-over-year growth in package downloads and its impact on developer productivity, while Luna questions whether TypeScript adds unnecessary complexity for small projects. The hosts also discuss the role of Deno and Bun in the TypeScript ecosystem, and why TypeScript is now the default for new React and Node.js projects. A must-listen for any web developer wondering whether to make the jump. #TypeScript #JavaScript #Microsoft #WebDevelopment #ProgrammingLanguages #TypeSystems #Deno #Bun #NodeJS #React #AI #DeveloperProductivity #Technology #FexingoBusiness #BusinessPodcast #TechPodcast #SoftwareEngineering #TypeSafety Keep every episode free: buymeacoffee.com/fexingo

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 recent rejection of a 4.0 proposal, the migration costs that would dwarf any theoretical benefit, and how the ecosystem is instead evolving through PEPs that add optional static typing, subinterpreters, and a JIT compiler without bumping the major version number. Specific numbers include 200 million lines of production Python code affected and a projected 3-5 year migration cost of $1.2 billion across the Fortune 500. The episode closes with a look at whether other languages like Rust or Mojo might fill the performance gap Python is leaving on the table. #Python #Python4 #ProgrammingLanguages #SoftwareEngineering #TechPodcast #OpenSource #PEP #Performance #JITCompiler #StaticTyping #Subinterpreters #SteeringCouncil #Fortune500 #MigrationCost #AI #Inference #Mojo #Rust Keep every episode free: buymeacoffee.com/fexingo

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: a 2025 survey found 37% of npm packages pinned to exact versions, up from 12% in 2020, signaling a collapse of trust in semver. Luna challenges whether 'no breaking changes' is even possible in practice. #SemanticVersioning #DependencyManagement #npm #Rust #Cargo #GoModules #leftpad #SoftwareEngineering #DevOps #PackageManagers #Versioning #BreakingChanges #DependencyHell #OpenSource #Technology #FexingoBusiness #BusinessPodcast #ProgrammingLanguagesPodcast Keep every episode free: buymeacoffee.com/fexingo

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 review cycle time. The hosts break down the architectural differences, the rise of agentic coding, and what this means for developers choosing their stack in 2026. No hype, just the trade-offs that matter. #AI #CodingAssistants #GitHubCopilot #ClaudeCode #JetBrainsAI #Cursor #DeveloperTools #AgenticCoding #Productivity #CodeReview #TechTrends2026 #LLM #Anthropic #OpenAI #VSCODE #FexingoBusiness #TechnologyPodcast #ProgrammingLanguages Keep every episode free: buymeacoffee.com/fexingo

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 percent using persisted queries, why Shopify's storefront API survived Black Friday with zero downtime, and what the new Relay compiler means for frontend teams. If you wrote off GraphQL in 2023, this episode might change your mind. No abstract praise — just the concrete design decisions that made the comeback real. #GraphQL #API #GitHub #Shopify #Netflix #Relay #PersistedQueries #Technology #WebDevelopment #Backend #Frontend #Engineering #Caching #APIDesign #Scalability #FexingoBusiness #BusinessPodcast #ProgrammingLanguages Keep every episode free: buymeacoffee.com/fexingo

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 Rust and TypeScript. The episode also covers the latest GHC 9.12 release and the growing adoption of Haskell in fintech and blockchain. A concrete look at a language that refuses to fade away. #Haskell #FunctionalProgramming #PureFunctional #GHC #HaskellInProduction #SoftwareCraft #Technology #FexingoBusiness #BusinessPodcast #PodcastEpisode #ProgrammingLanguages2026 #Fintech #Blockchain #Cardano #Facebook #GitHub #DSL #GHC912 Keep every episode free: buymeacoffee.com/fexingo

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 type system that catches errors at compile time to its runtime performance that rivals C++. They dig into real numbers: how OCaml's pattern matching speeds up financial instrument modeling by 30-40% compared to object-oriented alternatives, and why its garbage collector matters less when the real bottleneck is algorithm expressiveness. You'll learn how OCaml's multi-core architecture, released in its 5.x series since 2023, has made it even more viable for modern high-throughput trading systems. If you think functional programming is just for academia, this episode will change your mind. #OCaml #FunctionalProgramming #QuantitativeFinance #JaneStreet #CitadelSecurities #TradingSystems #FinanceTech #WallStreet #TypeSafety #PatternMatching #MultiCore #ProgrammingLanguages #Technology #SoftwareEngineering #AlgoTrading #FexingoBusiness #BusinessPodcast #PythonVsOCaml Keep every episode free: buymeacoffee.com/fexingo

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 unique 'write once, compile native' approach, contrast it with React Native and Kotlin Multiplatform, and discuss how Dart's just-in-time compilation during development and ahead-of-time compilation in production gives it a speed advantage that competitors struggle to match. They also examine the impact of Google's $50 million investment in Flutter tooling in 2025 and the launch of Dart 4.0 earlier this year, which brought pattern matching and algebraic data types to the language. This episode is essential listening for mobile developers evaluating their framework choices and for anyone curious about how a language few predicted would succeed is now reshaping the app development landscape. #Dart #Flutter #CrossPlatform #AppDevelopment #MobileDevelopment #Google #ReactNative #KotlinMultiplatform #SensorTower #Dart4.0 #PatternMatching #AlgebraicDataTypes #Technology #ProgrammingLanguages #FexingoBusiness #BusinessPodcast #SoftwareEngineering #TechTrends Keep every episode free: buymeacoffee.com/fexingo

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 latency by 40 percent by migrating a payment-microservice from Node.js to WebAssembly on Cloudflare Workers. They also unpack the broader shift, including Fastly’s Compute@Edge platform and the rise of Wasm component model. Along the way, Lucas shares why Rust and WebAssembly are a natural pairing, and Luna asks the critical question: does this replace containers, or just complement them? A focused, numbers-driven look at one of the most quietly transformative infrastructure shifts of 2026. #WebAssembly #Wasm #EdgeComputing #CloudflareWorkers #ComputeAtEdge #Serverless #Rust #ColdStarts #Latency #Microservices #Fastly #WasmComponentModel #Technology #Programming #Infrastructure #CloudComputing #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 with zero downtime, why the Phoenix framework's Channels handle millions of WebSocket connections, and how companies like Pinterest and Toyota use Elixir for mission-critical infrastructure. They also discuss the language's growing ecosystem, including Nx for numerical computing and LiveView for real-time UIs without JavaScript fatigue. No hype—just a concrete look at a language that quietly powers modern backend systems. #Elixir #JoséValim #PhoenixFramework #BEAM #ErlangVM #ActorModel #Concurrency #FaultTolerance #OTP #LiveView #Nx #Discord #Pinterest #Toyota #RealTimeSystems #Technology #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 approach and examines whether the language can achieve its goal of gradual adoption at scale. Specific examples include Carbon's generic programming model, its interoperability with C++, and the timeline for a production-ready 0.1 release. The episode also touches on the broader trend of languages trying to modernize systems programming without a rewrite-everything mandate. #CarbonLanguage #Google #CPlusPlus #SystemsProgramming #ProgrammingLanguages #Rust #OpenSource #MemorySafety #Generics #Interop #Technology #FexingoBusiness #BusinessPodcast #SoftwareEngineering #Compilers #LanguageDesign #CPlusPlusSuccessor #TechTrends Keep every episode free: buymeacoffee.com/fexingo

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. They walk through a real case: how a robotics startup replaced Python with Lua to cut memory usage by 80% on a microcontroller. By the end, you'll understand Lua's unique trade-offs and where it still wins today in 2026. #Lua #EmbeddedProgramming #GameDevelopment #IoT #Robotics #ScriptingLanguage #Redis #WorldOfWarcraft #Microcontroller #Python #CAPI #Technology #FexingoBusiness #BusinessPodcast #ProgrammingLanguages #Lightweight #Performant #MemoryFootprint Keep every episode free: buymeacoffee.com/fexingo

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 developers entering the field. With 15 million developers now using AI assistants, the conversation tackles whether these tools are making us faster or just more dependent. #AICoding #GitHubCopilot #CodeWhisperer #GeminiForCode #DeveloperProductivity #SoftwareEngineering #TechPodcast #Programming #AIinTech #CodeQuality #JuniorDevelopers #PromptEngineering #CodeReview #MachineLearning #DevTools #FexingoBusiness #BusinessPodcast #Technology Keep every episode free: buymeacoffee.com/fexingo

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 standardized JSON parsing rules, and they debate whether newer contenders like MessagePack or Protobuf will ever dethrone it. If you've ever copied JSON between services, you'll see it differently after this one. #JSON #RESTfulAPIs #DataFormats #SoftwareEngineering #Technology #FexingoBusiness #BusinessPodcast #IETF #RFC9427 #MessagePack #Protobuf #XML #API #WebDevelopment #Ecosystem #DouglasCrockford #RFC4627 #Serialization Keep every episode free: buymeacoffee.com/fexingo