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 Pony Is Bringing Safe Concurrency to Production Systems

    Pony is an open-source programming language that brings the actor model and reference capabilities together for provably safe concurrency without a garbage collector pause. In this episode, Lucas and Luna explore how Pony's type system eliminates data races at compile time, why it's gaining traction in high-frequency trading and IoT, and how it compares to Rust, Erlang, and Go for concurrent 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

    11 min
  • Why Developers Are Choosing Elixir for Real-Time Systems in 2026

    In this episode, Lucas and Luna explore why Elixir, built on the Erlang VM, has become the language of choice for real-time, fault-tolerant systems in 2026. They dive into a specific case: Discord's move to Elixir for its messaging infrastructure, handling 400 million concurrent events daily with 99.999% uptime. The discussion covers the Actor model, OTP's supervision trees, and how Elixir's 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

    9 min
  • Why Developers Are Choosing Kotlin for Server-Side in 2026

    Episode 49 of The Programming Languages Podcast explores the rise of Kotlin on the server side. Lucas and Luna discuss why developers are increasingly choosing Kotlin over Java for backend systems, citing Kotlin's concise syntax, null safety, and seamless Java interop. They examine real-world adoption at companies like Netflix and Uber, and analyze how Kotlin's features like coroutines and data 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

    8 min
  • Why Go Is the Language for Cloud Infrastructure in 2026

    Lucas and Luna dive into why Go (Golang) has become the dominant language for cloud infrastructure in 2026. They break down how Go's concurrency model, fast compilation, and built-in tooling make it the default choice for Docker, Kubernetes, Terraform, and countless other cloud-native projects. Specific numbers: Go now powers over 75% of CNCF projects. The episode explores the technical decisions 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

    10 min
  • Why Developers Are Coding on iPads and Tablets in 2026

    Lucas and Luna dig into the surprising rise of tablet-based coding. With Apple's iPad Pro M4 pushing 120 fps in Xcode and Samsung's DeX mode running full VS Code, more developers are ditching laptops for slates. They break down the hardware specs, the software gaps (no Docker on iPad, limited local emulation), and the real-world workflow of a mobile developer who codes entirely on an iPad. Plus: 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

    10 min
  • Why TypeScript Is Eating JavaScript in 2026

    In this episode of The Programming Languages Podcast with Fexingo, hosts Lucas and Luna explore the meteoric rise of TypeScript in 2026. They dive into how TypeScript's adoption has surged past 80% among professional JavaScript developers, driven by the rise of AI-generated code and the need for type safety in large codebases. Lucas breaks down the key numbers from the State of JS 2025 survey, 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

    9 min
  • Why Developers Are Rewriting Everything in Rust in 2026

    Rust is no longer just for systems programmers. In 2026, its ownership model and safety guarantees are driving adoption across web services, embedded devices, and even frontend tooling. Lucas and Luna unpack the data: GitHub's Octoverse shows Rust grew 50% year-over-year in contributors, while the Linux kernel and Android now mandate Rust for new code. They examine why companies like Meta, Amazon, 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

    10 min
  • How Dart and Flutter Are Winning Cross-Platform in 2026

    Lucas and Luna dive into why Dart and Flutter have become the dominant cross-platform framework in 2026, overtaking React Native and other competitors. They examine the technical decisions that made Flutter fast—like the Skia graphics engine and the Dart virtual machine—and discuss how Google's bet on Fuchsia OS and ambient computing is driving investment. Lucas walks through the key metrics: over 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

    12 min
  • How AWK Is Still the Best Command-Line Data Tool in 2026

    Lucas and Luna explore why AWK, a text-processing language from 1977, remains irreplaceable for one-liner data analysis on the command line. They walk through a specific example: extracting and summing top seller data from a 50,000-line CSV in a single line of AWK, comparing it to Python and SQL. The episode covers AWK's pattern-action model, associative arrays, and why it beats modern tools for 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

    10 min
  • Why the JVM Is Still Dominant in Production in 2026

    Lucas and Luna dig into why the Java Virtual Machine, despite being over three decades old, remains the runtime of choice for mission-critical backend systems in 2026. They examine Project Loom's virtual threads, which have slashed latency for concurrent applications, and compare GraalVM's native-image compilation against Go's compiled binaries. The conversation cites real numbers: how a major 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

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