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

In this episode, Lucas and Luna explore Fanotify, the Linux kernel's file change notification system that is replacing tools like inotify for modern workloads. They break down how Fanotify monitors entire filesystems at once instead of individual files, making it ideal for antivirus scanners, backup tools, real-time replication, and systemd-journald. Lucas explains the key difference from inotify—...

Episode 78 dives into the biggest programming language shift in Linux history: Rust code inside the kernel. Lucas explains why the C language's memory-safety bugs have caused decades of security patches, and how Rust's compile-time guarantees eliminate entire classes of vulnerabilities at the source. He walks through the key milestones: the 2022 merge of initial Rust support, the first Rust networ...

Lucas and Luna explore how Flatpak is changing the way Linux users install and run desktop applications. They trace the project's origins at Red Hat, its use of bubblewrap for sandboxing, and the controversial relationship with Flathub as a centralized store. The episode explains why Flatpak appeals to developers seeking a stable runtime target and to users wanting newer apps without distro upgrad...

Lucas and Luna dive into Linux control groups (cgroups) — the kernel feature that underlies container resource limits, systemd service isolation, and cloud cost optimization. They trace cgroups from Google engineer Paul Menage's 2006 patch to today's v2 unified hierarchy, using Netflix's 2024 migration to cgroupsv2 as a case study. You'll learn how cgroups prevent noisy-neighbor problems in shared...

In this episode of The Linux Podcast, Lucas and Luna explore VFIO (Virtual Function I/O), the Linux kernel framework enabling near-native GPU passthrough to virtual machines. They break down how VFIO uses IOMMU groups to isolate devices, explain the difference between mediated and direct passthrough, and discuss real-world use cases from gaming VFIO setups to cloud GPU instances. Specific numbers:...

Episode 74 of The Linux Podcast dives into auditd, the Linux audit framework that's quietly becoming essential for compliance teams. Lucas and Luna explore how auditd records system calls, file accesses, and authentication events to meet standards like PCI DSS and SOC 2. They break down a real-world example: a mid-sized SaaS company that used auditd to detect a compromised SSH key within minutes,...

Lucas and Luna dive into how the io_uring asynchronous I/O framework is transforming database performance on Linux. They use the concrete example of PostgreSQL 17, which saw a 30% latency reduction on high-throughput workloads after adopting io_uring for WAL writes. The conversation explores how io_uring eliminates the syscall overhead that plagued traditional AIO and libaio, what this means for N...

Episode 72 of The Linux Podcast explores why eBPF is displacing traditional kernel modules in modern Linux systems. Lucas and Luna break down how eBPF allows safe, dynamic code execution inside the kernel without the crash risk of loadable modules. They discuss real-world use cases like Facebook's Katran load balancer and Cilium for networking, plus the performance impact of eBPF vs. kernel module...

Episode 71 of The Linux Podcast explores how ARM-based servers are challenging x86 dominance in the data center. Lucas and Luna break down the real-world impact of AWS Graviton and Ampere Altra, citing a 34% cost reduction for compute-intensive workloads at a major cloud provider. They discuss the Linux kernel's role in ARM server optimization, the current state of software compatibility, and what...

In Episode 70 of The Linux Podcast with Fexingo, Lucas and Luna dive into kexec — the Linux kernel mechanism that bypasses the BIOS and bootloader to perform near-instantaneous reboots. They trace its origins in the mainline kernel, explain how it works under the hood, and explore its real-world impact: from reducing server downtime in large data centers to enabling faster kernel updates on deskto...

Episode 69 of The Linux Podcast with Fexingo dives into systemd, the init system that has become the backbone of modern Linux distributions. Lucas and Luna unpack how systemd replaced SysVinit and Upstart, standardizing service management, logging with journald, and dependency handling. They discuss the controversy around its adoption, the benefits for system administrators, and real-world example...

In this episode of The Linux Podcast, Lucas and Luna dive into how the Linux intel_pstate and amd_pstate drivers are changing the way CPUs manage power and performance. They break down why frequency scaling matters for modern workloads—from laptops to servers—and how the newer EPP (Energy Performance Preference) and HWP (Hardware P-State) controls give users fine-grained tuning. Lucas shares a con...

In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into Kernel Same-page Merging (KSM), a memory-saving feature that deduplicates identical pages across virtual machines. They explore how KSM works, its performance trade-offs, and real-world use cases like large-scale cloud deployments and embedded systems. With specific numbers—like how KSM can reduce memory usage by up to 90%...

In this episode of The Linux Podcast, Lucas and Luna dive into Btrfs copy-on-write snapshots, a feature that's quietly transforming how system administrators handle backups, rollbacks, and disk efficiency. Lucas explains the mechanics of CoW—how it avoids duplicating data by referencing extents—and contrasts it with traditional snapshot approaches like LVM. Luna brings up real-world scenarios: rol...

Episode 65 of The Linux Podcast with Fexingo dives into Kernel Same-page Merging (KSM), a memory deduplication feature that quietly saves gigabytes in virtualized and containerized Linux environments. Lucas and Luna explain how KSM works, where it shines—like in high-density VDI deployments—and where it falls short, such as on latency-sensitive workloads. They walk through a real-world case from a...

In this episode, Lucas and Luna dive into Linux Unified Key Setup (LUKS) and how it's transforming full-disk encryption from an enterprise-only tool into something any Linux user can adopt. They explore LUKS2's argon2 key derivation, the shift toward hardware-backed encryption with TPMs and systemd-cryptenroll, and real-world numbers — like how LUKS2 cuts decryption overhead to under 5 percent on...

In this episode of The Linux Podcast with Fexingo, Lucas and Luna unpack how Linux namespaces — not Docker or Kubernetes — are the actual kernel feature that makes containers possible. They walk through the seven namespace types (mount, PID, network, user, UTS, IPC, cgroup), explain what happens when you run 'unshare' in a terminal, and discuss why user namespaces are the most security-critical pi...

Episode 62 of The Linux Podcast dives into Bcache, the Linux kernel block-layer caching that lets you pair a small, fast SSD with a large, slow HDD to create a hybrid volume that performs almost like an all-SSD array. Hosts Lucas and Luna explain how Bcache works at the device-mapper level, how it manages hot and cold data with its writeback and writethrough modes, and why it matters for cost-cons...

Lucas and Luna unpack io_uring, the Linux kernel's new asynchronous I/O interface that's dramatically reducing system call overhead for databases, storage engines, and network servers. They walk through how io_uring uses shared submission and completion queues to bypass traditional read/write bottlenecks, why it's up to 3x faster than epoll for high-throughput workloads, and how projects like Rock...

Episode 60 of The Linux Podcast. Lucas and Luna explore how ZRAM, a Linux kernel module that creates a compressed block device in RAM, is changing memory management on everything from Android phones to enterprise servers. They break down the trade-offs between ZRAM and traditional swap, explain why it delivers up to 50 percent more effective memory under load, and discuss how modern kernels handle...

In episode 59 of The Linux Podcast with Fexingo, Lucas and Luna dive into PipeWire, the open-source multimedia framework that's quietly replacing PulseAudio and JACK across Linux desktops. They unpack how PipeWire handles low-latency professional audio, screen sharing under Wayland, and sandboxed audio for Flatpak apps — all with a single daemon. With real-world benchmarks from Fedora and Arch Lin...

Lucas and Luna explore Linux kernel live dump — a technique that captures a running kernel's memory state without rebooting. They explain how it differs from traditional crash dumps, why it's a game-changer for production debugging, and walk through a real-world case where a major social media company used live dump to diagnose a memory corruption bug in under an hour. The episode also covers the...

In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into the long-awaited transition from the X11 display server to Wayland on Linux desktops. They explore why this shift has taken over a decade, starting with the key architectural differences — like Wayland's simpler, more secure model that eliminates many of X11's legacy problems. The conversation focuses on a concrete milesto...

Episode 56 of The Linux Podcast with Fexingo dives into Flatpak's approach to software distribution on Linux. Lucas and Luna discuss how Flatpak breaks the decades-old dependency cycle by bundling runtimes and sandboxing applications. They compare it to Snap and AppImage, examine real-world use cases like Steam and Blender, and look at the performance tradeoffs including larger download sizes and...

On episode 55 of The Linux Podcast, Lucas and Luna explore how BPF (Berkeley Packet Filter) has evolved from a packet filtering tool into a powerful security monitoring framework. They dive into real-world use cases like detecting container breakouts, auditing system calls, and tracing network anomalies without modifying kernel code. The discussion highlights tools like Falco, Tracee, and Cilium,...