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

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

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 · E192
September 22 · 9 min
Linux Kernel Slab Allocator Optimization Secrets
We drill into the Linux kernel slab allocator, specifically how modern distributions like Ubuntu and Red Hat tune kmalloc caches to reduce memory fragmentation and improve server density. Lucas and Luna break down why a 16-byte object cache matters more...
- Transcript
S4 · E191
September 20 · 9 min
How Linux Kernel Memory Reclaim Solves OOM Crashes
We dig into the Linux kernel’s aggressive memory reclaim subsystem and why it often triggers out-of-memory kills faster than you’d expect. Using a concrete case of a mid-sized web service hitting swap limits on September twentieth twenty-six, we break...
- Transcript
S4 · E190
September 19 · 10 min
How Linux Cgroups Solve Server Cost Chaos
Cloud bills are spiraling because teams treat server resources like an open bar. This episode dissects how Linux Control Groups, or cgroups, turn that chaos into precise budgeting. We look at the mechanics of CPU shares and memory limits using a...
- Transcript
S4 · E189
September 18 · 9 min
How Linux Kernel Page Cache Cuts Cloud Bills
Most cloud cost-cutting guides focus on instance sizing or reserved capacity. But the real savings often hide in the Linux kernel's page cache, where redundant disk reads inflate I/O costs and latency. This episode examines how the page cache acts as a...
- Transcript
S4 · E188
September 18 · 11 min
How Linux Filesystems Manage Disk I/O Efficiency
In this episode, we drill into the specific mechanics of how Linux handles disk input and output through its filesystem layer. Lucas breaks down the role of the VFS in abstracting storage devices, while Luna explores how modern journaling filesystems...
- Transcript
S4 · E187
September 17 · 8 min
How Linux Cgroups Control Server Costs
In this episode, Lucas and Luna break down the often-overlooked economics of Linux resource management. They explore how CPU shares and memory limits in cgroups directly impact cloud infrastructure bills, using a specific case study of a misconfigured...
- Transcript
S4 · E186
September 15 · 9 min
How Linux Cgroups Control Server Costs
We drill into how Linux cgroup v2 transforms cloud spending by isolating resource pressure. Using a specific case study of a runaway database query, we show how hierarchical CPU shares and memory limits prevent one noisy tenant from crashing the entire...
- Transcript
S4 · E185
September 14 · 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
September 13 · 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
September 12 · 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
September 11 · 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
September 11 · 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

Showing 21–40 of 60 episodes