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

Fexingo

Lucas and Luna examine the Linux ecosystem as it powers everything from cloud servers to embedded devices. They trace the evolution of major distributions — Fedora's upstream-first philosophy, Debian's stability-first governance, and the commercial strategies behind Ubuntu and RHEL — without rehashing release notes. Each episode picks one layer of the stack: the container runtime that changed deployment (Docker, Podman), the systemd debate, or why Wayland still hasn't fully replaced X11 on the desktop. They also cover real-world migrations: a startup moving from CentOS to Rocky Linux, a government agency choosing OpenSUSE Leap for long-term support, and the kernel patching workflow at a FAANG-scale datacenter. Lucas brings the command-line fluency — package managers, filesystem hierarchy, SELinux contexts — while Luna asks the questions that matter to sysadmins and developers: What breaks when you upgrade? How do you audit a distro's supply chain? Can Linux ever win the desktop without OEM deals? No fanboy evangelism, no terminal-porn demos. Listeners come for the technical depth — kernel config options, Wayland protocols, cgroups v2 — but stay for the operational judgment: which distro for a Kubernetes node, which init system for an embedded device. What does it take to run Linux at scale without burning out your ops team? #Linux #OpenSource #Technology #FexingoBusiness #BusinessPodcast #Distro #Kernel #Containerization #Docker #Podman #Systemd #Wayland #RHEL #Ubuntu #Fedora #Debian #Sysadmin #DevOps Keep every episode free: buymeacoffee.com/fexingo

Play

Open in

20 episodes
daily
Avg 9 min
English

Support the show

Goes straight to the publisher. podnod takes nothing.

Keep every episode free: buymeacoffee.com/fexingo

Episodes 20

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

S4 · E172
Yesterday · 11 min
Linux Kernel Security Through Lockdown Mode
We explore how the Linux kernel's lockdown feature protects system integrity against root-level attacks. Lucas and Luna break down the three security levels, the role of Secure Boot in enabling this protection, and why modern enterprise servers should...
- Transcript
S4 · E171
Monday · 9 min
How Linux BPF Iterators Make Kernel Data Accessible
In this episode of The Linux Podcast with Fexingo, Lucas and Luna explore how Linux BPF iterators simplify kernel data access. They trace a concrete example: using BPF iterators to dump all open files across the system, something that traditionally...
- Transcript
S4 · E170
Sunday · 7 min
How Linux Namespaces Isolate Processes Beyond Containers
In episode 170 of The Linux Podcast, Lucas and Luna drill into Linux namespaces — the kernel feature that underpins containers but also powering systemd services, user sessions, and even Flatpak apps. They walk through the seven main namespace types...
- Transcript
S4 · E169
Saturday · 11 min
How Linux SLUB Allocator Reduces Memory Fragmentation
In this episode, Lucas and Luna dive into the SLUB allocator, the default memory allocator in the Linux kernel since 2.6.23. They explain how SLUB reduces fragmentation compared to its predecessor SLAB, using the concept of per-CPU partial lists and...
- Transcript
S4 · E168
Friday · 8 min
How Linux Swap Space Evolved Into Modern Memory Management
Lucas and Luna explore the unsung journey of Linux swap space from its early days as a simple disk extension to today's sophisticated memory management tool. They dig into the mechanics of swap, how the kernel decides what to swap out, and why modern...
- Transcript
S4 · E167
Thursday · 9 min
How Linux BPF Ring Buffers Deliver High-Throughput Data
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into the BPF ring buffer, a high-performance data structure introduced in Linux kernel 5.8 that lets eBPF programs pass events to user space with minimal overhead. They explain how it...
- Transcript
S4 · E166
August 26 · 10 min
How Linux BPF Iterators Make Kernel Data Accessible
Lucas and Luna explore BPF iterators, the Linux kernel feature that lets you traverse kernel data structures safely from user space. They unpack how iterators differ from traditional BPF programs, why they were introduced, and how tools like bpftool use...
- Transcript
S4 · E165
August 25 · 10 min
How Linux Kernel Samepage Merging Cuts Memory Waste in Containers
In this episode, Lucas and Luna dig into Linux Kernel Samepage Merging (KSM) — the memory-saving technique that deduplicates identical pages across processes and containers. With KSM, a host running hundreds of duplicate container images can cut memory...
- Transcript
S4 · E164
August 24 · 9 min
How Linux Memory Hotplug Adds RAM While Running
Memory hotplug lets you add or remove RAM from a running Linux system without a reboot. It’s a niche but powerful capability used in cloud fleets, big databases, and high-availability setups. Lucas and Luna dig into the mechanism — from sysfs entries to...
- Transcript
S4 · E163
August 23 · 8 min
How Linux Perf Traces Performance Without Heavy Overhead
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into the Linux 'perf' tool, the built-in profiler that many sysadmins overlook. They explore how perf uses hardware counters and kernel tracepoints to pinpoint CPU bottlenecks, cache...
- Transcript
S4 · E162
August 22 · 8 min
How Linux Btrfs Snapshots Save Your Data
In this episode, Lucas and Luna dive into Btrfs snapshots, a feature that lets you roll back your system or files in seconds. They explain the copy-on-write magic behind snapshots, how to create and manage them with btrfs subvolume snapshot, and why...
- Transcript
S4 · E161
August 21 · 8 min
How Linux Kernel Memory Reclaim Keeps Servers Stable
In Episode 161, Lucas and Luna dive into Linux kernel memory reclaim — the behind-the-scenes mechanism that keeps servers from falling over when memory runs out. They explore how the kernel's reclaim algorithms decide which pages to evict, the role of...
- Transcript
S4 · E160
August 20 · 7 min
How Linux F2FS Optimises Flash Storage for Modern Devices
In this episode, Lucas and Luna explore F2FS, the flash-friendly file system designed by Samsung for NAND storage. They explain why traditional file systems like ext4 struggle with SSDs, how F2FS uses a log-structured design to reduce write...
- Transcript
S4 · E159
August 19 · 8 min
How Linux Kernel Samepage Merging Reduces Memory Waste
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dig into Kernel Samepage Merging (KSM) — the Linux kernel feature that deduplicates identical memory pages across processes. They explain how KSM works, why it matters for virtualization...
- Transcript
S4 · E158
August 18 · 8 min
How Linux io_uring and eBPF Transform Network Performance
In episode 158 of The Linux Podcast with Fexingo, Lucas and Luna dig into the real-world impact of combining io_uring with eBPF for high-speed networking. They unpack how these two kernel technologies work together to slash latency and boost throughput...
- Transcript
S4 · E157
August 17 · 7 min
How Linux eBPF Observes Every Packet in Real Time
Lucas and Luna dive into eBPF, the kernel technology that lets you trace network packets and system calls without adding any overhead. They start with a concrete example: using bpftrace to answer a question that would normally take hours of digging...
- Transcript
S4 · E156
August 16 · 12 min
How Linux io_uring and XDP Combine for High-Speed Networking
Episode 156 of Fexingo's Linux podcast dives into the rare but powerful pairing of io_uring and XDP for high-speed networking. Lucas and Luna explain how io_uring's asynchronous I/O model meets eXpress Data Path's early packet processing, cutting latency...
- Transcript
S4 · E155
August 15 · 8 min
How Linux Bcache Caches Block Devices for Speed
Episode 155 of The Linux Podcast dives into Bcache, the Linux kernel block-layer caching that lets you put a fast SSD in front of slow spinning disks. Lucas and Luna walk through how Bcache works at the block level, why it's different from...
- Transcript
S4 · E154
August 15 · 8 min
How Linux Control Groups Handle Thousands of Containers
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dig into the inner workings of Linux Control Groups, or cgroups, and how they keep modern containerized systems stable. Using a real-world example of a platform running ten thousand...
- Transcript
S4 · E153
August 13 · 9 min
How Linux Control Groups Manage Container Resources
In this episode, Lucas and Luna dive into cgroups v2, the kernel feature that underpins container resource management. They explain how cgroups limit CPU, memory, and I/O for individual processes, and how systemd integrates with cgroups to manage...
- Transcript

Showing 1–20 of 20 episodes