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

Fexingo
  • 1.0 (1)
  • Business
  • Updated Daily

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. #PythonProgramming #RustLang #JavaScript #TypeScript #ModernCoding #MemorySafety #ProgrammingLanguages #SoftwareEngineering #TechDebate #OpenSource #CodeBenchmarks #Deno #PyPy #GIL #BorrowChecker #Business #FexingoBusiness #Technology Keep every episode free: buymeacoffee.com/fexingo

  1. 4h ago

    Why TypeScript Is Winning the Modern Web in 2026

    In this episode, Lucas and Luna explore why TypeScript has become the default choice for modern web development, even as JavaScript evolves and new contenders like Python's PyScript and Go's WASM support emerge. Centered on the massive 2026 npm registry milestone of 3 billion weekly downloads, they break down TypeScript's structural typing, its role in large-scale refactors at companies like Airbnb and Stripe, and the growing adoption in backend Node.js projects. They also discuss the trade-offs: the complexity of type gymnastics, the compile step, and how TypeScript's design philosophy contrasts with Rust's memory safety or Go's simplicity. With a focus on practical takeaways for developers, the episode examines why TypeScript's gradual typing and ecosystem integration make it the pragmatic bridge between developer experience and runtime performance. A must-listen for anyone coding in 2026, from frontend to full-stack. #TypeScript #JavaScript #WebDevelopment #ProgrammingLanguages #DeveloperTools #TechPodcast #SoftwareEngineering #NodeJS #npm #Airbnb #Stripe #PyScript #WASM #BackendDev #FrontendDev #Coding #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

    Why TypeScript Is Winning the Modern Web in 2026

  2. 1d ago

    Why Kotlin Is the Pragmatic Choice for Server-Side Development

    In this episode, Lucas and Luna explore why Kotlin has become the go-to language for server-side development in 2026, moving beyond its Android fame. They start with a surprising stat: Kotlin now powers over 30 percent of new backend services at major tech firms. Lucas breaks down how Kotlin's concise syntax, null safety, and seamless Java interop let teams cut boilerplate by half while keeping JVM performance. They discuss Spring Boot's evolution with Kotlin coroutines, which make asynchronous code readable and efficient, and compare it to Java's verbosity and the complexity of JavaScript's ecosystem. Luna brings up a real-world example: a fintech startup that migrated from Java to Kotlin and saw a 40 percent drop in null pointer exceptions in production. They also touch on the growing Kotlin Multiplatform, which lets teams share business logic across mobile and backend. The hosts weigh Kotlin's learning curve for Java developers and its long-term viability. They end on a forward-looking note, asking whether Kotlin could eventually rival Java in enterprise adoption. Tune in for a concrete look at why Kotlin is the pragmatic choice for modern backend systems in 2026. #Kotlin #ServerSideDevelopment #JVM #BackendDevelopment #ProgrammingLanguages #Technology #SoftwareDevelopment #SpringBoot #Coroutines #NullSafety #JavaInterop #KotlinMultiplatform #Fintech #DeveloperProductivity #FexingoBusiness #BusinessPodcast #TechTalk #Coding Keep every episode free: buymeacoffee.com/fexingo

    Why Kotlin Is the Pragmatic Choice for Server-Side Development

  3. 2d ago

    Why Lua Is the Hidden Scripting Powerhouse in 2026

    Lua is everywhere, hiding inside games, embedded systems, and even Adobe products, yet most developers barely notice it. In this episode, Lucas and Luna explore why Lua, a 30-year-old language, is still the go-to choice for embedding scripting into larger applications. They trace its origins at a Brazilian university, explain its tiny footprint and C-API design, and highlight its modern revival through LuaJIT and the new Lua 5.4. With a concrete example about how game studios use Lua to ship content updates without recompiling engine code, they make a case for adding Lua to your toolkit. Plus, a quick look at how the language's simplicity enables AI-assisted coding and why that might be its next superpower. Whether you're a game developer, a system administrator, or just curious about the building blocks of software, this episode will change how you see the invisible glue of the digital world. #Lua #LuaJIT #EmbeddedScripting #GameDevelopment #ProgrammingLanguages #Technology #SoftwareEngineering #CAPI #Lua54 #AIProgramming #TechPodcast #FexingoBusiness #BusinessPodcast #Coding #DeveloperTools #Scripting #OpenSource #LanguageDesign Keep every episode free: buymeacoffee.com/fexingo

    Why Lua Is the Hidden Scripting Powerhouse in 2026

  4. 3d ago

    Why Elixir Is the Secret to Fault-Tolerant Backends

    In this milestone 150th episode, Lucas and Luna explore why Elixir, a language born from the Erlang ecosystem, is quietly becoming the go-to choice for fault-tolerant backend systems in 2026. They trace its origins to Ericsson's 1980s telecom switches, where the requirement for 99.9999999 percent uptime shaped a programming philosophy that now powers modern chat apps, payment gateways, and real-time dashboards. Lucas breaks down the actor model, lightweight processes, and the Let It Crash philosophy, while Luna challenges the notion that Elixir is hard to learn, pointing to its Ruby-like syntax and the Phoenix framework. They reference real-world adoption at companies like Discord and Pinterest, and discuss the trade-offs, including performance limitations and a smaller ecosystem. The episode walks through a concrete example of a stock ticker processing millions of messages without breaking a sweat, illustrating how supervision trees and hot code reloading make Elixir ideal for mission-critical infrastructure. The hosts also share practical advice for developers considering Elixir and reflect on why the language remains misunderstood despite its power. The conversation closes with a reflection on how Elixir's design principles might influence the next generation of programming. #Elixir #Erlang #FaultTolerance #ActorModel #PhoenixFramework #FunctionalProgramming #BackendDevelopment #Concurrency #OTP #TelecomHistory #Scalability #RealTimeApps #Discord #Pinterest #ProgrammingLanguages #Technology #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

    Why Elixir Is the Secret to Fault-Tolerant Backends

  5. 4d ago

    Crystal Lang Is the Fastest Way to Write Fast Code

    In this episode of The Programming Languages Podcast, Lucas and Luna explore Crystal, the compiled language with Ruby-like syntax and C-like performance. They break down its unique compiled approach, its built-in concurrency model, and why it's gaining traction for building fast command-line tools and web backends in 2026. With a quick look at how Crystal's type inference and macro system deliver both developer happiness and runtime efficiency, they compare it to Ruby, Go, and Rust to help you decide if it deserves a spot in your toolbox. If you've ever felt the tension between readable code and raw speed, this episode gives you a new option to consider. #CrystalLang #LanguageDesign #CompiledLanguages #RubyLike #FastCode #Concurrency #StaticTyping #DeveloperTools #OpenSource #ProgrammingLanguages #BackendDevelopment #CLI #WebFrameworks #TechPodcast #SoftwareEngineering #FexingoBusiness #BusinessPodcast #Programming Keep every episode free: buymeacoffee.com/fexingo

    Crystal Lang Is the Fastest Way to Write Fast Code

  6. 5d ago

    Zig's Zero-Dependency Takeover of Systems Programming

    In this episode, Lucas and Luna explore Zig, the systems programming language that's quietly becoming a favorite for performance-critical projects in 2026. They trace its rise from a niche language to a serious contender alongside C and Rust, focusing on its zero-dependency philosophy, compile-time code execution, and explicit memory handling. The conversation centers on Zig's unique approach to build systems and cross-compilation — a major pain point for C developers — and how it's being adopted in game engines, embedded systems, and even the Linux kernel community. With concrete examples like Bun and the recent Linux kernel discussions, they unpack why Zig's simplicity and transparency are winning over developers who feel bogged down by C's legacy baggage or Rust's steep learning curve. If you've ever wondered whether there's a middle path between C's raw power and Rust's safety guarantees, this episode makes the case for Zig's pragmatic compromise. Lucas and Luna also touch on the trade-offs — from missing features to the risk of relying on a language still under development — and what that means for developers thinking about making the leap. #ZigLanguage #SystemsProgramming #CProgramming #RustLanguage #CompileTime #CrossCompilation #BuildSystem #Bun #LinuxKernel #GameEngines #EmbeddedSystems #ZeroDependency #ProgrammingLanguages #TechPodcast #DeveloperTools #FexingoBusiness #BusinessPodcast #LearningToCode Keep every episode free: buymeacoffee.com/fexingo

    Zig's Zero-Dependency Takeover of Systems Programming

  7. 6d ago

    How GraalVM Is Redefining Polyglot Performance in 2026

    Lucas and Luna dig into GraalVM, the high-performance runtime that's quietly changing how enterprises run polyglot code. In 2026, as microservices and serverless become the default, GraalVM's native images and Truffle framework are delivering startup times measured in milliseconds and memory footprints cut by half. The episode centers on a real-world case: a major European bank that migrated its Java-based trading platform to GraalVM native images, slashing cold-start latency from four seconds to under a hundred milliseconds. Lucas walks through how GraalVM's ahead-of-time compilation works, why it's not just a Java trick, and how its Truffle language implementation framework lets JavaScript, Python, and R run on the same JVM with near-native speed. Luna pushes on the trade-offs—longer build times, reflection limits, and the learning curve—and they debate whether GraalVM is the future or a niche tool. If you're a developer weighing polyglot performance in your stack, this episode gives you the concrete numbers and honest trade-offs to decide. #GraalVM #PolyglotProgramming #NativeImage #Java #TruffleFramework #AheadOfTimeCompilation #StartupLatency #Microservices #Serverless #JVM #TradingPlatform #Fintech #Technology #SoftwareDevelopment #ProgrammingLanguages #FexingoBusiness #BusinessPodcast #TechPodcast Keep every episode free: buymeacoffee.com/fexingo

    How GraalVM Is Redefining Polyglot Performance in 2026

  8. Aug 5

    Why WebAssembly Is the Compiler Target of 2026

    In this episode of The Programming Languages Podcast, Lucas and Luna dive into WebAssembly's rise as the universal compiler target in 2026. They trace its journey from a browser-only novelty to a cornerstone of edge computing, serverless platforms, and even blockchain smart contracts. With major cloud providers now supporting WebAssembly runtimes, and frameworks like wasmtime and Wasmer maturing, the hosts explore why developers are increasingly compiling Rust, Go, and even Python to WebAssembly for performance and portability. They discuss concrete examples like Cloudflare Workers processing millions of requests, and how WebAssembly's sandboxing model offers a safer alternative to containers. The conversation also touches on the challenges, such as debugging complexity and the gap between promises and tooling maturity. By the end, listeners understand why WebAssembly might be the next big thing for backend and edge development, and what it means for the future of language interoperability. Perfect for developers curious about the next wave of cloud-native technology. #WebAssembly #Wasm2026 #EdgeComputing #CloudflareWorkers #Rust #CompilerTarget #Serverless #Sandboxing #Wasmtime #Wasmer #Portability #Performance #Technology #ProgrammingLanguages #FexingoBusiness #BusinessPodcast #DeveloperPodcast #CodeCraft Keep every episode free: buymeacoffee.com/fexingo

    Why WebAssembly Is the Compiler Target of 2026
See All (153)

Ratings & Reviews

About

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. #PythonProgramming #RustLang #JavaScript #TypeScript #ModernCoding #MemorySafety #ProgrammingLanguages #SoftwareEngineering #TechDebate #OpenSource #CodeBenchmarks #Deno #PyPy #GIL #BorrowChecker #Business #FexingoBusiness #Technology Keep every episode free: buymeacoffee.com/fexingo

Information

You Might Also Like