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

33 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 33

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.

S4 · E185
Monday · 9 min
How Linux Kernel BPF Transformed Network Performance
We dig into eBPF, the technology that lets you run sandboxed programs in the kernel without changing source code or loading modules. Lucas and Luna break down how companies like Cloudflare use eBPF to drop millions of malicious packets before they hit...
- Transcript
S4 · E184
Sunday · 9 min
Linux Kernel Cgroup V2 Hierarchical CPU Shares
On today’s episode, we drill into how Linux cgroup v2 hierarchical CPU shares actually work in production. Lucas and Luna break down the specific mechanics of fair scheduling when you have mixed workloads—like a database and a web server—competing for...
- Transcript
S4 · E183
Saturday · 9 min
How Linux Cgroups Control Server Costs
We break down how Linux cgroup v2 lets teams enforce strict CPU and memory limits on individual containers. Using a specific example from a mid-sized SaaS provider, we show how this kernel feature prevents noisy neighbors from crashing production systems...
- Transcript
S4 · E182
Friday · 9 min
How Linux Kernel Live Patching Keeps Servers Running
Lucas and Luna explore the mechanics of live patching in the Linux kernel, a technique that allows security updates to be applied without rebooting production servers. They break down how kpatch and kgraft work, the role of function graph hooks, and why...
- Transcript
S4 · E181
Friday · 8 min
How Linux Cgroups Manage Server Costs
We examine how Linux control groups, or cgroups, transform abstract resource limits into tangible financial savings for cloud infrastructure. Using a specific case of a containerized web service that reduced its monthly bill by twenty-two percent after...
- Transcript
S4 · E180
September 9 · 12 min
How Linux Kernel BPF Transforms Network Security
We look at how eBPF has moved from a niche debugging tool to the backbone of modern cloud networking, using Cilium and Envoy as primary examples. With over two hundred thousand contributors now interacting with the kernel through this interface, we...
- Transcript
S4 · E179
September 8 · 10 min
How Linux Containers Solve the Dependency Nightmare
Most developers treat containerization as a deployment tool, but the real value lies in dependency isolation. We explore how modern distroless images and build-time pinning eliminate the 'it works on my machine' problem. Using Ubuntu Jammy and Alpine as...
- Transcript
S4 · E178
September 8 · 9 min
Linux Kernel Watchdog: How OOM Killer Saves Systems
We dig into the Linux Out-Of-Memory killer, the kernel feature that makes hard decisions when RAM runs dry. Lucas and Luna break down how the OOM score works, why it sometimes targets the wrong process, and what system administrators can do to protect...
- Transcript
S4 · E177
September 6 · 12 min
How Linux Kernel Lockdown Hardens Enterprise Security
We examine the practical implications of Linux kernel lockdown mode for enterprise security. With modern deployments increasingly reliant on immutable infrastructure, understanding how this feature restricts user-space access to kernel memory and device...
- Transcript
S4 · E176
September 5 · 10 min
Linux Kernel Cgroup v2 Memory Pressure Explained
We break down how Linux cgroup v2 memory pressure controls work in practice, using a real-world scenario where a misconfigured container triggers throttling before OOM kills. Lucas and Luna explore the difference between soft limits and hard limits, why...
- Transcript
S4 · E175
September 4 · 10 min
How Linux Kernel Selftests Prevent Broken Deployments
We explore the often-overlooked world of Linux kernel selftests, specifically focusing on how tools like Kselftest and LTP prevent regressions in modern server stacks. With the September 2026 release cycle bringing significant changes to memory...
- Transcript
S4 · E174
September 3 · 12 min
Linux Kernel Live Patching in Production
We examine how Linux kernel live patching actually works in high-uptime environments, using Canonical’s Ksplice and Red Hat’s kpatch as primary case studies. Lucas breaks down the technical mechanism of hot-patching memory while processes run, and Luna...
- Transcript
S4 · E173
September 2 · 11 min
How Linux Kernel Live Patching Keeps Servers Running
We dive into kpatch and kGraft, the technologies that let system administrators apply critical security fixes to a running Linux kernel without a single reboot. In an era where uptime is currency and maintenance windows are vanishing, understanding how...
- Transcript
S4 · E172
September 1 · 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
August 31 · 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
August 30 · 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
August 29 · 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
August 28 · 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
August 27 · 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

Showing 1–20 of 33 episodes