The Backend Engineering Show with Hussein Nasser

I discuss loops engineering and how it will numb creative thinking and critical system design for engineers.

I like SQL but the standard should have included ways to hint instead of the abstraction of "let me do it for you"

In this episode I explore why you should take some time to examine the operation you are caching before doing so. And why caching is a cop-out

How open ai agents "hacked" hugging face

The infinite scroll in social media as we know it today is despised by all. But it always start as a bad idea. It originated as a result of UI change to relief the backend database from inefficient queries. I explore this in this episode of the backend engineering. 0:00 Intro1:00 Classic Paged results 6:23 Limitations of paging9:00 The scroll interface 12:00 How TikTok to infinite scroll 14:00 The current state

An aws engineer discovered a 50% regression in postgres throughput while testing the new Linux 7.0 kernel. The cause turns out to be massive TLB and page faults exacerbated by Postgres process-based design. In this backend engineering show episode I dive deep into how this was discovered, the root cause and the possible fixes and workarounds. Intermediate and Advanced Backend Engineering Course Bundlehttps://courses.husseinnasser.com/bundleMy Book, Root Cause: Stories and Lessons from Two Decades of Backend Engineering Bugs https://amzn.to/4cKfZhe 0:00 Intro2:30 The Discovery6:30 Spinlocks9:25 Preemption 13:00 Root Cause17:00 How Postgres Processes exacerbated the problem 22:30 Is the fix easy?25:50 Summary

A discussion about why many engineers still love the struggle, the mistakes, and the process of figuring things out themselves. This is how we grow and get better and stronger. Letting AI do everything (even though it can’t) robs us this feeling.. 

I wrote a new book that has been in the works for years. It is called Root Cause, and it is for those who enjoy the art of backend engineering.

Early in my career, 20 years ago, I built backend and database applications without fully grasping their inner mechanics. Performance issues, race conditions, bugs, and even data corruption often left me lost.

Since that day, I resolved to truly understand how systems work. From networking protocols and intermediary proxies to backend services and various database engines. I made it a habit to follow every request on its journey through the dark alleys of the network, down to the bowels of the database engine, meanwhile interacting with various kernel data structures in the process at every hop, and back.

I became obsessed with understanding what happens behind the scenes in software. Not just what breaks, and how but also why and what was the source of the bleed. 

Root Cause is a collection of the most interesting bugs I encountered, ranging from performance bottlenecks and non-deterministic crashes to subtle data inconsistencies and incorrect results.

This book is for anyone curious about how production backend systems really behave under pressure, and how to debug them when they don’t. Even when you don’t have access to the source code.

Root cause consists of 15 chapters, each is a story about a backend bug, with investigation, diagrams, a section of a fundamental concept until the root cause is revealed.

Grab your copy here paperback or kindle ebook

paperback

https://amzn.to/4cKfZhe

ebook

https://amzn.to/4cfQjJj

In this video I introduce 5 different design patterns for building backend applications. Each mode explains how a socket listener is established, a connections are established and how threads and connections are managed to read, write and process requests.

Page tables provide the mapping between virtual memory and physical memory for each process. This means it needs to be as efficient and as fast as possible. I explore the inner workings of page tables in this episode.

• 0:00 Intro
• 2:00 Virtual Memory

⁃ ⁃ 8:00 MMU

• 10:00 Page Tables

⁃ ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ 11:30 Single Table Byte Addressability  

⁃ ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ 16:00 Single Table Page addressability 

⁃ ⁃ ⁃ ⁃ ⁃ 19:00 Multi-level Paging (Radix tree)

⁃ ⁃ 31:00 Huge Tables

⁃ ⁃ 33:00 TLB

⁃ ⁃ Summary