Skip to content
Artwork for The Linux Podcast with Fexingo: Open Source Operating Systems, Distros, and Server Stack

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
  • 48 episodes
  • daily
  • Avg 9 min
  • English

Support the show

Goes straight to the publisher. podnod takes nothing.

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • S4 · E200
    Today · 10 min

    Linux Kernel Live Migration for Zero Downtime

    We examine how Linux kernel live migration allows servers to move between physical hosts without a single dropped packet or rebooted process. This episode breaks down the technical mechanics of memory page transfer, network state preservation, and the...

    • Transcript
  • S4 · E199
    Yesterday · 9 min

    How Linux Kernel Locking Prevents Server Crashes

    We break down the hidden cost of contention in high-concurrency Linux servers. Using a specific example from a major fintech platform’s migration to lockless data structures, we explore how reducing kernel-level locking overhead cut latency by thirty...

    • Transcript
  • S4 · E198
    Monday · 8 min

    How Linux Kernel Memory Management Cuts Cloud Costs

    We dive into the often-overlooked world of Linux memory management and its direct impact on cloud infrastructure costs. Focusing on the page cache, swap space, and memory reclaim mechanisms, we explore how small configuration tweaks can lead to...

    • Transcript
  • S4 · E197
    Sunday · 8 min

    How Linux Kernel Kthreads Prevent Server Deadlocks

    Most server crashes happen not because the code is wrong, but because the kernel got stuck waiting for itself. In this episode of The Linux Podcast with Fexingo, Lucas and Luna break down how kernel threads solve one of the most elusive problems in...

    • Transcript
  • S4 · E196
    Friday · 7 min

    How Linux Kernel Preemption Fixes Server Latency

    Server latency isn't just about CPU speed; it's about how the kernel handles interruption. In this episode, we explore Linux kernel preemption, specifically the difference between voluntary and full preemption models. We look at why a financial trading...

    • Transcript
  • S4 · E195
    Friday · 10 min

    How Linux Kernel Scheduler Ticks Solve Server Latency

    We drill into the CFS (Completely Fair Scheduler) in the Linux kernel, specifically how its tickless design and load-balancing algorithms impact enterprise server performance. Lucas and Luna explore why reducing scheduler overhead matters for...

    • Transcript
  • S4 · E194
    Thursday · 9 min

    How Linux Kernel Namespaces Isolate Cloud Workloads

    Cloud providers run millions of containers on shared hardware, but how do they prevent one tenant from seeing another's data? This episode explores Linux kernel namespaces as the foundational isolation layer for modern server stacks. We examine how...

    • Transcript
  • S4 · E193
    September 23 · 11 min

    How Linux Userspace Drives Enterprise Performance

    Most IT leaders focus on the kernel when optimizing server performance, but this episode shifts the lens to userspace utilities and system libraries. Lucas and Luna explore how tools like strace, perf, and glibc interact with hardware to create...

    • Transcript
  • 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
Showing 1–20 of 48 episodes