The Linux Podcast with Fexingo: Open Source Operating Systems, Distros, and Server Stack

Episode 54 of The Linux Podcast with Fexingo dives into the quiet but dramatic evolution happening in Linux network filesystems. Lucas and Luna explore why NFS, SMB, and even newer protocols like CephFS are being re-engineered for modern workloads — from AI training clusters to remote desktop rendering. The episode centers on the Linux 6.5 kernel's NFS v4.2 multi-queue improvements, which boosted...

Episode 53 of The Linux Podcast with Fexingo dives into Linux Access Control Lists (ACLs) — the overlooked permission system that goes beyond traditional Unix chmod for multi-tenant servers. Lucas explains how ACLs let you grant specific users read, write, or execute permissions on a per-file basis, using examples like a shared log directory where a DevOps team needs write access while auditors ge...

Episode 52 of The Linux Podcast digs into Control Groups v2, the kernel feature quietly reshaping how containers use CPU and memory. Lucas and Luna break down the specific change that made Cgroups v2 production-ready in 2024 and 2025: the unified hierarchy. They walk through a real example from Meta's 2024 paper showing a 12% reduction in CPU tail latency after migrating to Cgroups v2, and explain...

In this episode, Lucas and Luna explore how eBPF is transforming network observability on Linux, moving beyond traditional tools like tcpdump and iptables. They dive into the technical mechanics of eBPF programs attached to network sockets, how it enables real-time packet-level monitoring with minimal overhead, and why companies like Netflix and Cloudflare use it for production traffic analysis. T...

Episode 50 of The Linux Podcast dives into FWUPD, the open-source framework that turned Linux firmware updates from a risky manual chore into a reliable, automated process. Lucas and Luna explore how LVFS (Linux Vendor Firmware Service) enables secure UEFI capsule updates across distros, the role of the UEFI firmware update protocol, and why Dell and Lenovo now push BIOS updates through fwupdmgr....

In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into the evolution of Linux process scheduling—from the O(n) scheduler of the early kernel to the Completely Fair Scheduler (CFS) and its successor, the EEVDF scheduler introduced in Linux 6.6. They explain how the scheduler handles CPU contention in mixed workloads, why latency-sensitive and throughput-heavy processes conflict...

Episode 48 of The Linux Podcast explores how Paragon Software's NTFS3 driver, now in the Linux kernel, gives Linux native read-write access to Windows NTFS drives without the performance penalties of the older FUSE-based ntfs-3g. Lucas and Luna dive into the history of Linux filesystem interoperability, why the VFS layer makes driver integration possible, and how NTFS3's direct kernel implementati...

In this episode of The Linux Podcast with Fexingo, Lucas and Luna explore why systemd timers are quietly taking over cron's job-scheduling duties on modern Linux systems. Using practical examples and a real-world migration at a mid-sized SaaS company, they break down the syntax, flexibility, and logging advantages that make systemd timers a more robust choice for everything from daily backups to c...

Episode 46 of The Linux Podcast with Fexingo dives into the unsung heroes of container file systems: SquashFS and OverlayFS. Lucas and Luna explain how these two Linux kernel features work together to minimize disk usage, accelerate container startup, and reduce memory footprint in production environments. The hosts walk through a concrete example of a large Rails application container — from imag...

Lucas and Luna dive into the quiet takeover of Linux in embedded systems — from smart thermostats to industrial controllers. They focus on the case of the Raspberry Pi Compute Module 4 powering a million-plus digital signage units at a major European retailer, and why Yocto Project is the build system behind it. They break down the economics: how a $35 Linux module replaces a $200 proprietary RTOS...

Lucas and Luna dive into the Linux kernel's new extensible scheduler framework, sched_ext, which lets developers write scheduling policies as BPF programs without patching the kernel. They explore how Google and Meta use it to reduce tail latency on production servers, the story of the 2024 kernel summit that accelerated its merge, and why this matters for cloud workloads running on June 11, 2026....

In this episode of The Linux Podcast, Lucas and Luna explore the Linux kernel's Read-Copy-Update (RCU) synchronization mechanism, a fundamental but often overlooked component that powers everything from filesystems to networking stacks. They break down how RCU allows lock-free reads while safely updating shared data, using the concrete example of the kernel's dentry cache — the data structure that...

Episode 42 of The Linux Podcast with Fexingo unpacks Linux namespaces — the kernel feature that makes containers possible. Lucas and Luna trace the history from the original seven namespaces (mount, PID, net, IPC, UTS, user, cgroup) to newer additions like time and cgroup2. They explain how namespaces isolate processes without a hypervisor, why they differ from virtualization, and what the new tim...

Episode 41 of The Linux Podcast breaks down the growing trend among Linux distributions to decouple the display server from the desktop environment. Lucas and Luna explore why Fedora, Ubuntu, and Arch are moving toward compositor-agnostic setups, the role of Wayland extensions like ext-session-lock-v1, and what this means for desktop stability and GPU vendor support. They drill into a specific cas...

Episode 40 of The Linux Podcast with Fexingo dives into immutable Linux distributions—a paradigm shift where the root filesystem is read-only, enforced by tools like ostree and composefs. Lucas explains why Fedora Silverblue, openSUSE MicroOS, and Vanilla OS are betting on atomic updates and rollback safety, and how this changes package management, desktop customization, and server reliability. Lu...

Episode 39 of The Linux Podcast with Fexingo dives into live patching for Linux servers—a technique that applies critical security updates without rebooting. Lucas and Luna break down how major cloud providers and enterprise distros use live patching, the kernel mechanisms that make it possible (ftrace, jump labels), and the real-world impact on uptime. They also explore the trade-offs: performanc...

For decades, Linux audio was a mess: ALSA, PulseAudio, JACK — a tangle of competing stacks that broke on every other update. But PipeWire, originally created by Wim Taymans at Red Hat in 2017, has quietly solved the problem. By the time Fedora 34 shipped it as default in 2021, the path was clear. Today, major DAWs like Bitwig Studio and Ardour run natively with sub-5-millisecond latency. Even Appl...

Episode 37 dives into a boring-yet-catastrophic Linux failure: file descriptor limits. Lucas walks through the exact moment a Node.js microservice hit the default 1024 soft limit, stalled a payment pipeline, and cost a fintech startup six figures in a single afternoon. Luna brings data on why ulimit defaults haven't changed in 30 years despite modern workloads. They explore kernel internals, the t...

Episode 36 of The Linux Podcast dives into memory fragmentation, a silent performance killer on long-running Linux servers. Lucas explains how the kernel's buddy allocator causes external fragmentation over time, and how newer features like THP compaction, proactive compaction via khugepaged, and the 'compact_memory' sysfs interface help. Luna shares a real-world case where a Redis instance on a 1...

Container images are huge, duplicative, and a security headache. Lucas and Luna dig into Composefs — a new Linux filesystem layer developed by Red Hat's Alexander Larsson — that uses content-addressable storage to deduplicate image data across the entire host. They walk through how it works, why it slashes disk usage by up to 90 percent for common image stacks, and what it means for container runt...

Episode 34 dives into Linux memory tiering — a kernel feature that treats fast and slow memory as a single pool with automatic hot-page migration. Lucas explains how the kernel's memory-management subsystem can now move frequently accessed pages to high-bandwidth memory (like Intel Optane or CXL-attached RAM) while relegating cold data to cheaper DRAM tiers. Using concrete examples from Meta's pro...

Episode 33 of The Linux Podcast explores why carmakers from Toyota to Mercedes are ditching proprietary OSes for Linux-based infotainment systems. Lucas breaks down the Automotive Grade Linux (AGL) consortium, how the shared platform cuts development costs by 40%, and why real-time kernel patches are essential for in-car safety. Luna asks whether drivers actually care what OS runs their dashboard,...

Episode 32 of The Linux Podcast with Fexingo dives into a growing tension in the Linux ecosystem: AI inference at the edge and in data centers demands deterministic latency, but standard Linux kernels prioritize throughput over real-time guarantees. Lucas and Luna explore why the PREEMPT_RT patch set, merged into the mainline kernel in 2024, is suddenly getting serious attention from NVIDIA, Canon...

Episode 31 of The Linux Podcast with Fexingo dives into BPF, the Linux kernel's secret weapon for observability, security, and performance tuning. Lucas and Luna break down how BPF—originally the Berkeley Packet Filter—has evolved into a virtual machine inside the kernel, letting administrators run sandboxed programs to trace system calls, monitor network packets, and even patch running kernels wi...

Episode 30 of The Linux Podcast with Fexingo: Open Source Operating Systems, Distros, and Server Stack. Lucas and Luna dig into the quiet but consequential fragmentation of Linux container runtimes. For years, Docker's containerd and Red Hat's CRI-O served as the two main options, but a new wave of lightweight, purpose-built runtimes like youki, crun, and gVisor are challenging the status quo. The...