Fexingo
The Linux Podcast with Fexingo: Open Source Operating Systems, Distros, and Server Stack
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 govern...
Be sure to visit the podcast's website and support the creator: www.fexingo.com
Where to listen?
Podcasts in the app Replaio Radio Coming soonPodcasts are coming to the app soon. Install now and be the first to see a whole new take on podcasts
Episodes
How Linux Kernel Self-Healing Fixes Cloud Outages 02.11.2026 9:03
In this episode of The Linux Podcast, Lucas and Luna explore the emerging landscape of kernel self-healing mechanisms that are quietly transforming cloud infrastructure reliability. Rather than relying on traditional watchdogs or external monitoring tools to detect and restart crashed services, modern Linux distributions are integrating deeper diagnostic capabilities directly into the kernel space...
How Linux Cgroup V3 Reshapes Cloud Economics 01.11.2026 10:59
Linux cgroups v2 introduced a unified hierarchy that simplifies resource isolation, but the industry is now looking at the conceptual next step often referred to as cgroups v3 or the unified memory controller approach. This episode explores how this architectural shift impacts cloud cost management by reducing overhead and improving predictability for multi-tenant workloads. We examine specific ca...
How Linux Cgroups v2 Simplified Cloud Cost Management 31.10.2026 8:27
The shift from cgroups v1 to v2 wasn't just a technical upgrade—it was a financial one. In this episode, we look at how the unified hierarchy of cgroups v2 forced cloud providers and enterprise teams to rethink resource isolation. We break down the specific overhead savings from removing nested controllers, how it simplified billing granularity for container orchestration platforms, and why the tr...
How Linux Cgroups v3 Simplifies Cloud Cost Management 25.10.2026 9:01
The Linux kernel is evolving its resource management layer, and the transition from cgroups v2 to the experimental cgroups v3 brings a radical simplification to how servers handle memory and CPU limits. We look at the specific architectural shifts in the new control group hierarchy, why the removal of nested hierarchies reduces scheduling overhead, and what this means for cloud infrastructure cost...
How Linux Cgroups v2 Simplifies Cloud Cost Management 24.10.2026 9:30
We break down the shift from cgroups v1 to v2 in Linux, focusing on how unified hierarchy control reduces complexity for cloud operators. Using a real-world case study of a mid-sized SaaS provider, we show how consolidating CPU and memory limits into a single tree structure cut operational overhead by forty percent. We explore the practical implications for container orchestration, cost allocation...
Linux Ceph Storage Clusters Scale Without The Headache 23.10.2026 10:16
We break down how distributed storage systems like Ceph use CRUSH algorithms to manage petabytes of data without central bottlenecks. Lucas walks through the mechanics of object placement and fault tolerance, while Luna asks how this architecture impacts latency in high-frequency trading environments. We look at real-world scaling limits, the trade-offs between performance and durability, and why...
How Linux Kernel CFS Solves CPU Bottlenecks 19.10.2026 11:52
On this episode of The Linux Podcast, we drill into the Completely Fair Scheduler and why it matters for modern cloud infrastructure. Lucas and Luna explore how the scheduler balances thousands of processes across multi-core systems, using real-world examples from high-frequency trading platforms and large-scale web servers. We break down the O(1) complexity problem, the evolution from legacy sche...
Linux Kernel BPF Security Enforcement at Scale 18.10.2026 10:36
Lucas and Luna explore how Linux Berkeley Packet Filter transforms network security from a reactive firewall into a proactive, programmable enforcement layer. They break down the mechanics of eBPF-based service mesh policies, using a specific case study of a major cloud provider reducing latency by twenty percent while blocking zero-day exploits. The conversation covers the shift from legacy iptab...
How Linux Filesystem Encryption Secures Cloud Data 17.10.2026 10:02
Most cloud providers default to unencrypted block storage, leaving data vulnerable at rest. This episode explores how eCryptfs and dm-crypt transform Linux servers into secure vaults without sacrificing performance. We examine the specific mechanics of file-level versus volume-level encryption, why enterprise teams often skip it until a breach happens, and the real-world trade-offs between securit...
Linux Cgroups v2 Resource Management 13.10.2026 8:15
The shift from cgroup v1 to v2 represents a fundamental restructuring of how Linux manages system resources, moving from fragmented controllers to a unified hierarchy. This episode explores the practical implications of this change for modern server stacks, focusing on how hierarchical resource limits prevent noisy neighbor problems in multi-tenant environments. We examine the specific mechanics o...
Linux Kernel Live Patching for Zero Downtime 13.10.2026 8:08
Lucas and Luna explore how enterprise Linux servers maintain availability without rebooting. They examine the mechanics of live kernel patching, specifically looking at systems like kpatch and kgraft that allow security fixes to be applied in memory. The discussion covers the risks of memory consistency, the role of the ftrace infrastructure, and why major cloud providers prefer this method over s...
How Linux Cgroups Control Cloud Infrastructure Costs 12.10.2026 9:12
In this episode, we explore how Linux control groups, or cgroups, act as the invisible gatekeepers of cloud spending. While many engineers focus on code efficiency, the real savings often come from resource isolation. We break down a specific case where a mid-sized fintech startup reduced its monthly AWS bill by forty percent simply by tightening cgroup limits for non-critical batch processing job...
How Linux Cgroups Manage Cloud Resource Limits 11.10.2026 9:46
We explore how Linux control groups enforce strict resource boundaries in multi-tenant cloud environments. Using a real-world case of a runaway process consuming CPU and memory, we examine the mechanics of cgroup v2. Lucas breaks down the hierarchy and delegation model, while Luna questions the security implications of namespace isolation. We look at specific configuration files and the trade-offs...
How Linux Kernel Live Migration Saves Enterprise Downtime 10.10.2026 11:15
In this episode, Lucas and Luna break down the mechanics of live migration in modern Linux data centers. They explore how pre-copy algorithms and dirty page tracking allow virtual machines to move between physical hosts without stopping services. Using a concrete example of a high-frequency trading platform reducing maintenance windows from hours to seconds, they explain why this technology is cri...
How Linux Kernel BPF Rewrote Cloud Networking Rules 09.10.2026 12:01
We break down how eBPF transformed cloud networking by letting developers hook into the kernel without modifying source code or restarting services. Lucas and Luna explore the shift from complex iptables rules to high-performance packet processing, using a specific case study of a major fintech platform that reduced latency by forty percent while cutting engineering overhead. We look at why this m...
How Linux Containers Save Cloud Infrastructure Costs 08.10.2026 9:53
We look at how containerization reshapes server efficiency, focusing on the shift from virtual machines to lightweight containers. With October 2026 cloud spending data showing significant overhead in legacy VM architectures, we examine why organizations are migrating workloads. We discuss the technical trade-offs of isolation versus density and what that means for infrastructure budgets today. #F...
How Linux eBPF Transforms Cloud Networking Performance 07.10.2026 10:35
We explore how the eBPF framework is rewriting the rules of cloud networking and security, moving logic from the kernel to userspace without sacrificing speed. With major tech firms like Google and Cloudflare deploying eBPF for real-time traffic inspection and DDoS mitigation, we break down why this technology is becoming the invisible backbone of modern infrastructure. We examine specific use cas...
How Linux Kernel Live Patching Prevents Downtime 06.10.2026 9:16
In this episode of The Linux Podcast with Fexingo, Lucas and Luna explore the mechanics of live kernel patching. They examine how major infrastructure providers maintain uptime without rebooting servers during critical security updates. The conversation drills into the technical challenges of code hot-swapping in the Linux kernel, focusing on specific tools like kpatch and kgraft. Listeners will l...
Linux Kernel Hardening Against Spectre Vulnerabilities 05.10.2026 6:57
We dive into how Linux kernel mitigations for Spectre and Meltdown vulnerabilities reshaped server architecture and cloud economics. With the October 2026 market still adjusting to performance trade-offs, we examine specific techniques like Indirect Branch Prediction Barrier and how they impact enterprise latency. Lucas and Luna break down the engineering decisions behind these security patches an...
How Linux Kernel Namespaces Enable Secure Multi-Tenancy 04.10.2026 11:29
We explore how Linux kernel namespaces isolate processes, creating secure boundaries for cloud workloads. Lucas and Luna break down PID, network, and mount namespaces with real-world examples from container orchestration. Learn how this technology underpins modern server efficiency without adding complexity. #LinuxKernel #NamespaceIsolation #CloudComputing #ServerSecurity #Containerization #TechIn...
How Linux Zero Copy Shaves Milliseconds From Data Pipelines 03.10.2026 8:48
We explore how zero-copy techniques like splice and sendfile bypass the kernel user-space buffer copy to reduce CPU overhead in high-throughput server stacks. With today’s October third, two thousand twenty-six data centers focusing on latency, understanding this kernel-level optimization is key for engineers managing heavy I/O workloads. #LinuxKernel #ZeroCopy #SystemProgramming #ServerStack #IOL...
How Linux Kernel Scheduler Fixes Server Latency 02.10.2026 11:28
We drill into the specific mechanics of the Linux Completely Fair Scheduler and how its recent updates to cgroup interaction are solving the 'noisy neighbor' problem in multi-tenant cloud environments. Using a concrete example from a major logistics platform, we break down how tuning CPU shares and idle states can reduce tail latency by over forty percent without adding hardware. This is Episode 2...
How Linux BPF Accelerated Cloud Networking 01.10.2026 10:24
In this episode of The Linux Podcast with Fexingo, Lucas and Luna explore how Berkeley Packet Filter technology revolutionized high-performance cloud networking. We examine the shift from traditional kernel-based packet processing to userspace acceleration via eBPF, using a specific case study of a major fintech firm reducing latency by forty percent. You will learn how XDP programs allow network...
Linux Kernel Live Migration for Zero Downtime 30.09.2026 10:59
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 recent improvements in latency that make it viable for high-frequency trading and enterprise databases. We look at why this matters for infrastructu...
How Linux Kernel Locking Prevents Server Crashes 29.09.2026 9:45
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 percent. Lucas and Luna discuss spinlocks, read-write locks, and why your cloud bill might be paying for CPU cycles wasted on waiting. #LinuxKernel #...
Similar podcasts
Replaio is not a podcast publisher; show names, artwork and audio belong to their authors and are distributed through public RSS feeds.