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

  • Why JSON Is the Glue Holding Modern Software Together

    In episode 11 of The Programming Languages Podcast, Lucas and Luna dive into JSON — the unglamorous data format that quietly powers everything from REST APIs to machine learning pipelines. They unpack why JSON won the format wars, how it broke XML's grip, and where its limits start to show (no types, no comments, no streaming). Lucas digs into the recent IETF RFC 9427 updates that finally 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

    10 min
  • Why SQL Is Making a Comeback in 2026

    Episode 10 of The Programming Languages Podcast with Fexingo explores the surprising resurgence of SQL in 2026. Lucas and Luna dive into why SQL—often dismissed as a legacy language—is now being embraced by data engineers, ML practitioners, and even frontend developers. They discuss the rise of DuckDB, the adoption of SQL-based transformations in tools like dbt, and how new SQL extensions for vector search and ML inference are making the language relevant again. The episode also covers the shift toward declarative data pipelines and why modern databases like PostgreSQL and MotherDuck are driving SQL's revival. If you've ever wondered whether SQL is worth learning in the age of Python and Rust, this episode gives you a concrete, numbers-driven answer.

    #SQL #Database #DuckDB #PostgreSQL #DataEngineering #ProgrammingLanguages #Technology #FexingoBusiness #BusinessPodcast #DataScience #MachineLearning #VectorSearch #dbt #MotherDuck #DeclarativeProgramming #OpenSource #BigData #Analytics

    Keep every episode free: buymeacoffee.com/fexingo

    6 min
  • How a 17000 Line Python Codebase Broke in Production

    A SaaS company's 17,000-line Python monolith crashed under 400 concurrent users on a Tuesday morning. Lucas and Luna walk through the real root cause: a single mutable default argument in a request handler that silently corrupted session state for hours before cascading into a full database connection pool exhaustion. They trace the bug from stack trace to fix, compare how Rust and Go would have caught it at compile time, and debate whether modern Python tooling like Pydantic v2 and mypy strict mode could have prevented the outage. The episode closes with a practical checklist for teams running Python in production today.

    #Python #Debugging #ProductionOutage #MutableDefaultArguments #SaaS #Pydantic #Mypy #TypeSafety #Rust #Go #SoftwareEngineering #CodeReview #TechOps #Backend #Programming #FexingoBusiness #BusinessPodcast #Technology

    Keep every episode free: buymeacoffee.com/fexingo

    11 min
  • Why SQLite Is the Most Deployed Database in the World

    In this episode of The Programming Languages Podcast with Fexingo, Lucas and Luna explore why SQLite—a tiny, embedded database engine—is the most deployed database on the planet. They trace its origins with D. Richard Hipp back in 2000, unpack how it powers everything from smartphones to airplanes to web browsers, and discuss the surprising trade-offs that make it a go-to choice for millions of developers. With over one trillion SQLite databases in active use, this episode reveals the quiet revolution of a library that prioritizes simplicity, portability, and reliability over scale. Lucas and Luna also touch on its role in edge computing and how it competes with cloud-native databases like DuckDB. A must-listen for any developer curious about the invisible infrastructure under modern applications.

    #SQLite #EmbeddedDatabase #D.RichardHipp #Database #Technology #OpenSource #EdgeComputing #DuckDB #Smartphone #Browser #SQL #FexingoBusiness #BusinessPodcast #ProgrammingLanguages #TechPodcast #DatabaseEngine #ACID #PublicDomain

    Keep every episode free: buymeacoffee.com/fexingo

    8 min
  • Why Kotlin Is Winning the Android World

    In this episode of The Programming Languages Podcast, Lucas and Luna explore why Kotlin has become the dominant language for Android development. They trace its rise from a niche JVM language to Google's preferred choice, citing concrete numbers: 85% of the top 10,000 Android apps now use Kotlin, and the language's adoption is growing 30% year over year. They discuss how JetBrains designed Kotlin to solve Java's pain points while maintaining full interoperability, and how features like null safety and coroutines reduce bugs and boost developer productivity. The hosts also touch on Kotlin Multiplatform, which lets developers share code between Android, iOS, and web. With examples like Trello and Evernote making the switch, this episode shows why Kotlin is not just a Java alternative but a strategic advantage for modern mobile development. No prior Kotlin experience needed — just curiosity about what's next in programming languages.

    #Kotlin #Android #JetBrains #Google #JVM #NullSafety #Coroutines #KotlinMultiplatform #MobileDevelopment #Trello #Evernote #ProgrammingLanguages #Technology #Java #DeveloperProductivity #ModernCoding #FexingoBusiness #BusinessPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    7 min
  • Zig Is the Language That Rust Left Behind

    Lucas and Luna explore why Zig is gaining traction as a simpler alternative to Rust for systems programming. They break down Zig's compile-time execution model, its approach to memory safety without a borrow checker, and why startups like TigerBeetle and Uber are experimenting with it. The conversation covers a specific benchmark where Zig outperformed Rust in a financial database workload, and why some developers find Zig easier to learn. They also discuss the trade-offs: no garbage collector, no runtime, but also no guarantees against segfaults. A focused look at a language that's carving out its own niche in 2026.

    #ZigLanguage #SystemsProgramming #RustAlternative #TigerBeetle #CompileTimeExecution #MemorySafety #ProgrammingLanguages #Technology #OpenSource #SoftwareDevelopment #Coding #ZeroCostAbstraction #NoRuntime #ManualMemoryManagement #UberEngineering #FexingoBusiness #BusinessPodcast #TheProgrammingLanguagesPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    8 min
  • Why Go Is Winning the Cloud Infrastructure Wars

    Episode 5 of The Programming Languages Podcast shifts focus to Go — the language Google built for scale. Lucas and Luna break down why Go, not Rust or Python, dominates cloud-native infrastructure in 2026. They trace Go's rise from Docker and Kubernetes to the CNCF ecosystem, crunch concrete adoption numbers: 82 percent of all cloud-native projects on GitHub are written in Go. Luna pushes back on Go's limitations — lack of generics maturity, no real GUI story — but Lucas counters with Go's killer feature: a 2.7-second compile time on a 100,000-line codebase versus Rust's 18 seconds. They discuss Go's goroutine memory model, why startups choose it for API microservices, and whether the language's simplicity is actually its long-term moat. No hype, just the numbers and tradeoffs that matter if you're choosing a stack for infrastructure in 2026.

    #GoLanguage #CloudNative #Kubernetes #Docker #CNCF #Microservices #Infrastructure #Programming #Technology #FexingoBusiness #BusinessPodcast #SoftwareDevelopment #Concurrency #Goroutines #Google #CompileTime #TechStack #SystemsProgramming

    Keep every episode free: buymeacoffee.com/fexingo

    12 min
  • How Wasm Is Changing Serverless Computing

    In this episode of The Programming Languages Podcast, Lucas and Luna explore WebAssembly's growing role in serverless computing. They break down how Wasm is being used to run lightweight, secure functions on the edge, comparing it to traditional container-based serverless platforms. The discussion focuses on a specific case: Fastly's Compute@Edge platform, which processes over 10 billion requests per day using Wasm modules. Lucas explains why Wasm's sandboxed architecture makes it ideal for multi-tenant environments, while Luna challenges him on cold-start times and the lack of a standard runtime. They also touch on recent standardization efforts around the WebAssembly System Interface (WASI) and what it means for developers. By the end, listeners will understand why major cloud providers are investing in Wasm and how it could reshape the serverless landscape.

    #WebAssembly #ServerlessComputing #Fastly #ComputeAtEdge #WASI #EdgeComputing #CloudComputing #ColdStart #Rust #JavaScript #Performance #Scalability #TechPodcast #Technology #FexingoBusiness #BusinessPodcast #ProgrammingLanguages #ModernCoding

    Keep every episode free: buymeacoffee.com/fexingo

    10 min
  • TypeScript in 2026 The Type Safety Wave

    Lucas and Luna explore how TypeScript has gone from a Microsoft experiment to the default choice for serious JavaScript development. They break down the numbers: npm downloads, job postings, and the 2026 State of JS survey showing TypeScript adoption at 89% among professional developers. Lucas walks through two concrete examples of type safety preventing production bugs, and they discuss whether TypeScript is now a skill requirement or a differentiator. They also touch on the tension between TypeScript's safety guarantees and the compile step that adds complexity to modern toolchains. A focused look at one language's quiet takeover of the web development ecosystem.

    #TypeScript #JavaScript #TypeSafety #WebDevelopment #ProgrammingLanguages #SoftwareEngineering #Microsoft #npm #StateOfJS #Deno #Bun #NodeJS #TechStack #DeveloperTools #Coding #Technology #FexingoBusiness #BusinessPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    11 min
  • Why Rust Is Eating the Systems Programming World

    In episode two of The Programming Languages Podcast, Lucas and Luna explore why Rust is rapidly displacing C and C++ in systems programming. They examine the 2026 TIOBE index showing Rust entering the top 15, Google's decision to write Android firmware components in Rust, and Microsoft's claim that 70 percent of its security patches stem from memory safety bugs that Rust eliminates. The conversation covers Rust's learning curve, its adoption in Linux kernel development, and what this means for developers considering a career move. Lucas breaks down the concrete numbers — including a 2025 survey showing 85 percent of Rust developers use it at work — while Luna raises the practical barriers to adoption. This episode is essential listening for any engineer wondering whether Rust is hype or the genuine future of infrastructure programming.

    #Rust #SystemsProgramming #MemorySafety #CPlusPlus #CProgramming #LinuxKernel #Android #Microsoft #Google #TIOBEIndex #ProgrammingLanguages #SoftwareEngineering #Technology #FexingoBusiness #BusinessPodcast #Podcast #TechCareers #Infrastructure

    Keep every episode free: buymeacoffee.com/fexingo

    12 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.