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

We look at how the decision to skip type checking in Python and JavaScript has created a massive, invisible tax on enterprise engineering teams. Using data from recent developer surveys and specific case studies from large-scale infrastructure projects, we break down why the speed of writing code today is costing companies millions in maintenance and bug fixes tomorrow. This episode examines the t...

In this episode of The Programming Languages Podcast, Lucas and Luna examine how the widespread adoption of AI coding assistants has fundamentally altered software engineering hiring. They analyze data from major tech firms showing a shift from evaluating raw syntax knowledge to assessing system architecture and problem decomposition skills. The discussion explores specific metrics on code review...

Most engineering leaders believe code reviews are the primary defense against bugs, but new data suggests they are actually the biggest bottleneck in modern software delivery. In this episode, we look at the specific mechanics of how peer review creates queueing delays that slow deployment frequency by up to forty percent. We examine why high-performing teams prioritize automated testing over huma...

In this episode, Lucas and Luna explore how TypeScript transformed the JavaScript ecosystem by introducing static type checking to a dynamic language. They dive into the specific mechanics of how types are inferred, the debate around explicit versus implicit typing, and why major tech companies like Microsoft and Airbnb made the switch. The discussion covers practical benefits like better autocomp...

Enterprise IT is quietly migrating critical infrastructure workloads from C++ and Go to Rust, driven by memory safety guarantees that eliminate entire classes of bugs. We examine why major cloud providers are adopting Rust for kernel-level networking, how the borrow checker forces better architectural decisions upfront, and what this means for hiring and legacy system maintenance in late 2026. Thi...

We dig into the specific mechanics of PEP 484 and how static type checking has moved from a developer nicety to an enterprise necessity. Lucas and Luna explore why major tech firms are adopting strict typing not just for IDE autocomplete, but to prevent runtime crashes in production. We look at real-world migration patterns, the performance trade-offs of gradual typing, and why JavaScript develope...

WebAssembly, or Wasm, has moved from a browser curiosity to the backbone of serverless edge computing in 2026. Lucas and Luna explore how companies like Cloudflare and Fastly are deploying Wasm modules to replace heavy virtual machines with lightweight, sandboxed processes. We look at the specific performance gains, the security implications of sandboxing code, and why this shift is forcing develo...

Zig is positioning itself as the successor to C for systems programming in 2026. In this episode, Lucas and Luna unpack why Zig's compile-time execution, explicit memory management, and no-hidden-control-flow philosophy are winning over developers building performance-critical software. They trace Zig's rise through its integration with LLVM, its growing role in game engines and operating systems,...

In this episode of The Programming Languages Podcast, Lucas and Luna dig into Elixir, the functional language built on the Erlang VM that's making waves in 2026 for its fault-tolerant, concurrent design. They explore how Elixir's actor model and 'let it crash' philosophy help companies like Discord handle millions of simultaneous users, and why telecom-grade reliability is now a hot commodity in w...

Lucas and Luna explore why OCaml, a 30-year-old functional programming language, has become a quiet powerhouse in financial trading systems. From Jane Street's massive adoption to its role in high-frequency trading, they unpack the language's unique strengths: strong static typing, immutability, and a pragmatic approach that balances safety with performance. This episode dives into how OCaml's typ...

On this episode, Lucas and Luna take a close look at Vala, the language that has quietly been powering GNOME apps for years, and why it's seeing renewed interest in 2026. With the rise of system programming alternatives and the push for faster, more memory-safe code, Vala offers a unique middle ground: it compiles to C, integrates natively with GObject, and feels like a higher-level language. The...

In the summer of 2026, Ada—a language many programmers wrote off as a relic of the 1980s—is quietly becoming the backbone of aerospace, defense, and even autonomous rail systems. In this episode, Lucas and Luna explore how Ada's unapologetic focus on safety and correctness is making it the go-to choice for projects where a single bug could cost billions or lives. They dig into the upcoming Ada 202...

In this episode, Lucas and Luna explore why Julia, the dynamic language born at MIT, has become the unexpected powerhouse in scientific computing by 2026. They dive into Julia's unique multiple dispatch system, which lets you write generic code that runs as fast as C, and how it's replacing Python in fields like climate modeling and genomics. They also discuss the recent surge in Julia's adoption...

In this episode, Lucas and Luna explore Janet, the Lisp-like language that's quietly becoming a favorite for scripting, systems, and AI glue code. They discuss its minimalist core, its powerful macro system, its built-in support for parallel processing and networking, and why it's gaining traction among developers who want the expressiveness of Lisp without the parentheses baggage. With concrete e...

In this episode, Lucas and Luna dive into Mojo, the programming language designed to combine Python's ease with C-level performance for AI workloads. They discuss how Mojo's ownership system and 'fn' functions eliminate the Global Interpreter Lock, enabling true parallelism, and why its compatibility with the Python ecosystem makes it a practical choice for developers. The conversation covers real...

In this episode, Lucas and Luna explore Futhark, the functional language designed to make GPU programming fast and safe. They break down how Futhark's array-centric approach and aggressive optimizations let you write high-level code that compiles to near-optimized CUDA. They compare it to CUDA, OpenCL, and even Python's Numba, and look at real-world use cases in machine learning and scientific com...

In this episode of The Programming Languages Podcast, Lucas and Luna explore why Go has become the definitive language for cloud-native development in 2026. They trace its rise from a niche systems language to the backbone of Kubernetes, Docker, and countless microservices, and explain how its simplicity, concurrency model, and fast compilation make it the default choice for infrastructure and bac...

In this episode, Lucas and Luna explore why Neovim has become the go-to editor for a new generation of developers in 2026, moving beyond the legendary status of Vim to offer a modern, extensible foundation. They break down the technical evolution from Vim to Neovim, highlighting the embedded Lua runtime, the async plugin architecture, and the built-in LSP client that have made it a favorite for fa...

In this episode, Lucas and Luna explore Odin, the systems programming language that's quietly gaining traction for game development and low-level tooling. They discuss its concise syntax, manual memory management, and the 'data-oriented' design philosophy that sets it apart from Rust and Zig. The conversation centers on Odin's growing use in indie game studios and its potential in performance-crit...

In this episode of The Programming Languages Podcast, Lucas and Luna explore Carbon, Google's experimental language designed as a successor to C++. They break down why Carbon emerged from the challenges of C++'s legacy, how it aims to offer modern safety and tooling while maintaining interoperability with existing C++ codebases, and what the current state of the project is in 2026. With an eye on...

In this episode of The Programming Languages Podcast, Lucas and Luna explore why D, the systems programming language that's been around for over two decades, is quietly becoming the go-to choice for performance-critical applications in 2026. They dive into D's unique blend of C-like performance with modern productivity features, from its powerful metaprogramming to its garbage collector that can b...

In this episode, Lucas and Luna explore how RISC-V, the open-source instruction set architecture, is moving from hobbyist curiosity to a serious contender in data centers and embedded systems. They trace its journey from a 2010 Berkeley project to a 2026 landscape where hyperscalers are designing custom RISC-V silicon, and start-ups like Ventana Microsystems are pushing high-performance implementa...

In this episode of The Programming Languages Podcast, Lucas and Luna explore a surprising twist in the AI world: R, the decades-old statistical language, is making a comeback. They trace R's origins at Bell Labs, its dominance in academic statistics, and its recent resurgence fueled by the need for robust statistical modeling alongside machine learning. With the rise of large language models, deve...

In this episode, Lucas and Luna dive into Gleam, a statically typed functional language that's been quietly gaining traction among developers building reliable, concurrent systems. They explore how Gleam's Erlang heritage brings battle-tested fault tolerance to modern web backends, why its type system catches bugs before they reach production, and how its approach to pattern matching and immutabil...

In this episode, Lucas and Luna explore why Haskell, a language often dismissed as academic, is quietly powering critical financial software. They start with a concrete anchor: the 2013 Knight Capital incident, where a flawed software deployment caused a $440 million loss in 45 minutes — a failure that Haskell's type system could have prevented. They discuss how hedge funds and banks use Haskell f...