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

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

By FexingoBusiness
Download on the App Store

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

  • 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 explore how it balances performance, reliability, and a zero-maintenance ethos that challenges assumptions about when you really need a full RDBMS. The hosts also discuss SQLite's surprising role in edge computing and what its design philosophy means for developers building for resource-constrained environments.

    #SQLite #Database #EmbeddedDatabase #EdgeComputing #IoT #Datomic #Technology #Programming #SoftwareEngineering #DataStorage #OpenSource #RichardHipp #SQLiteConsortium #Serverless #MobileDevelopment #FexingoBusiness #BusinessPodcast #TheProgrammingLanguagesPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    9 min
  • 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 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

    8 min
  • 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 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

    12 min
  • 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 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

    10 min
  • 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 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

    9 min
  • 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 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

    10 min
  • 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 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

    9 min
  • 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 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

    6 min
  • 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 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

    11 min
  • 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, 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

    13 min

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

From the publisher's feed

Every line of code is a decision, and every programming language encodes a philosophy. In The Programming Languages Podcast, Lucas and Luna move past syntax flame wars to examine the actual trade-offs behind Python, Rust, JavaScript, and the modern coding stack. Each episode dissects a specific language feature, framework choice, or ecosystem shift — from Rust's borrow checker and memory safety guarantees to JavaScript's type system evolution with TypeScript, and Python's dominance in machine learning versus its performance bottlenecks. They ground every discussion in real-world benchmarks, open-source projects like Deno and PyPy, and case studies from companies that bet on one language over another. Lucas brings the reporter's instinct for clarity and hard numbers; Luna tests those findings with the engineer's skepticism and hands-on experience. You will walk away understanding not just what a language does, but why it was designed that way, and when you should — or shouldn't — use it. What does Rust's ownership model teach us about concurrency? Is JavaScript's flexibility a feature or a bug for large-scale systems? Can Python ever overcome the GIL? This is the podcast for developers who are tired of cargo-culting and want to think critically about the tools they use every day.