The Backend Engineering Show with Hussein Nasser
The Backend Engineering Show with Hussein Nasser covers software engineering topics with a focus on backend technologies. The host discusses news, trends, and concepts in the field, often repurposing content from his YouTube channel. The podcast is aimed at software engineers and enthusiasts interested in backend development.
Episodes
AI will not replace elite engineers
This is a conversation with Rashed Hasan, a PhD Candidate from the University of Nebraska. We chatted about databases, ORMs and how to use AI without losing yourself. Rashed pagehttps://www.mdrashedulhasan.me/homepage
Engineers will be out of the 'Loops'
I discuss loops engineering and how it will numb creative thinking and critical system design for engineers.
SQL was a mistake
I like SQL but the standard should have included ways to hint instead of the abstraction of "let me do it for you"
Caching is a cop-out
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
How open ai agents "hacked" hugging face
How a query optimization gave birth to infinite scroll
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
Postgres is half as fast in Linux 7.0
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 Bu
Don't let AI rob you
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..
New Book: Root cause
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 h
5 Backend Design Patterns for Managing Threads and Sockets
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
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 Intro2:00 Virtual Memory ⁃ ⁃ 8:00 MMU10:00 Page Tables ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ 11:30 Single Table Byte Addressability ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ ⁃ 16:00 Single Table Page addressability
CPU and Kernel Page Faults
Page faults occurs when the process tries to access a memory that isn’t backed by a physical page kernel raises a fault which loads a page. It happens on first access, stack expansion, COW, swap and much more. However it comes with a cost. In this episode of the backend engineering show I dissect the need and the cost page faults in the kernel. 0:00 Intro 4:00 Virtual memoryAbstraction of physical
Amazon US-EAST-1 Outage in Details
On October 19 2025 AWS experienced an outage that lasted over a day, 10 days later we finally got the root cause analysis and we know exactly what caused the DNS to fail0:00 Summary 5:30 How did Dynamo lost its DNS?13:41 EC2 Errors 16:16 Network Load Balancer ErrorsRCA here https://aws.amazon.com/message/101925/
Graceful shutdown in HTTP
There are cases where the backend may need to close the connection to prevent unexpected situations, prevent bad actors or simply just free up resources. Closing a connection gracefully allows clients and backends to clean up and finish any pending requests. In this episode of the backend engineering show I discuss graceful connections in both HTTP/1.1 via the connection header and HTTP/2 via the
Postgres 18 gets Async IO
Postgres 18 has been released with many exciting features such as UUIDv7, Over explain module, composite index skip scans, and the most anticipated asynchronous IO with worker and io_uring mode which I uncover in this show. Hope you enjoy it0:00 Intro1:30 Synchronous vs Asynchronous calls3:00 Synchronous IO6:30 Asynchronous IO10:00 Postgres 17 synchronous io 17:20 The challenge of Async IO in Post
Kernel level TLS
Fundamentals of Operating Systems Course https://oscourse.winktls is brilliant.TLS encryption/decryption often happens in userland. While TCP lives in the kernel. With ktls, userland can hand the keys to the kernel and the kernel does crypto. When calling write, the kernel encrypts the packet and send it to the NIC.When calling read, the kernel decrypts the packet and handed it to the userspace. T
The beauty of the CPU
If you are bored of contemporary topics of AI and need a breather, I invite you to join me to explore a mundane, fundamental and earthy topic.The CPU.A reading of my substack article https://hnasr.substack.com/p/the-beauty-of-the-cpu
Sequential Scans in Postgres just got faster
This new PostgreSQL 17 feature is game changer. They know can combine IOs when performing sequential scan. Grab my database coursehttps://courses.husseinnasser.com
Does discipline work?
No technical video today, just talking about the idea of discipline and consistency.
Socket management and Kernel Data structures
Fundamentals of Operating Systems Course This video is an overview of how the operating system kernel does socket management and the different data structures it utilizes to achieve that.timestamps0:00 Intro1:38 Socket vs Connections7:50 SYN and Accept Queue18:56 Socket Sharding23:14 Receive and Send buffers27:00 Summary
The genius of long polling
Polling is the ability to interrogate a backend to see if a piece of information is ready. It can introduce a chatty system and as a result long polling was born. In this video I explain the beauty of this design pattern and how we can push it to its limit.
0:00 Intro
0:45 Polling
2:30 Problem with Polling
3:50 Long Polling
8:18 Timeouts
10:00 Long Polling Benefits
12:00 Make requests into Long
Six stages of a good software engineer
You get better as a software engineer when you go through these stages.
0:00 Intro
1:15 Understand a technology
7:07 Articulate how it works
15:30 Understand its’ limitations
19:48 Try to build something better
27:45 Realize what you built also has limitations
32:48 Appreciate the original tech as is
Understand a technology
We use technologies all the time without knowing how it works.
This new Linux patch can speed up Reading Requests
Fundamentals of Operating Systems Course
https://oscourse.win
Very clever! We often call read/rcv system call to read requests from a connection, this copies data from kernel receive buffer to user space which has a cost.
This new patch changes this to allow zero copy with notification.
“Reading' data out of a socket instead becomes a “notification” mechanism, where the kernel tells userspa
Cloudflare's 150ms global cache purge | Deep Dive
Cloudflare built a global cache purge system that runs under 150 ms.
This is how they did it.
Using RockDB to maintain local CDN cache, and a peer-to-peer data center distributed system and clever engineering, they went from 1.5 second purge, down to 150 ms.
However, this isn’t full picture, because that 150 ms is just actually the P50. In this video I explore Clouldflare CDN work, how the old
MySQL is having a bumpy journey
Fundamentals of Database Engineering udemy course https://databases.win
MySQL has been having bumpy journey since 2018 with the release of the version 8.0. Critical crashes that made to the final product, significant performance regressions, and tons of stability and bugs issues. In this video I explore what happened to MySql, are these issues getting fixed? And what is the current state of MySQ
How many kernel calls in NodeJS vs Bun vs Python vs native C
Fundamentals of Operating Systems Course
https://oscourse.win
In this video I use strace a performance tool that measures how many system calls does a process makes. We compare a simple task of reading from a file, and we run the program in different runtimes, namely nodejs, buns , python and native C.
We discuss the cost of kernel mode switches, system calls and pe
0:00 Intro
5:00 Code Expla
When do you use threads?
Fundamentals of Operating Systems Course
https://os.husseinnasser.com
When do you use threads?
I would say in scenarios where the task is either
1) IO blocking task
2) CPU heavy
3) Large volume of small tasks
In any of the cases above, it is favorable to offload the task to a thread.
1) IO blocking task
When you read from or write to disk, depending on how you do it and the kernel interfa
Frontend and Backends Timeouts
I am fascinated by how timeouts affect backend and frontend programming.
When a party is waiting on something you can place a timeout to break the wait. This is useful for freeing resources to more critical processes, detecting slow operations and even avoiding DOS attacks.
Contrary to common beliefs, timeouts are not exclusive to request processing, they can be applied to other parts of the fron
Postgres is combining IO in version 17
Learn more about database and OS internals, check out my courses
Fundamentals of database engineering https://databases.win
Fundamentals of operating systems https://oscourse.win
This new PostgreSQL 17 feature is game changer.
You see, postgres like most databases work with fixed size pages. Pretty much everything is in this format, indexes, table data, etc. Those pages are 8K in size, each
Windows vs Linux Kernel
Fundamentals of Operating Systems Course
https://os.husseinnasser.com
Why Windows Kernel connects slower than Linux
I explore the behavior of TCP/IP stack in Windows kernel when it receives a RST from the backend server especially when the host is available but the port we are trying to connect to is not. This behavior is exacerbated by having both IPv6 and IPv4 and if the happy eye ball proto
Running out of TCP ephemeral source ports
In this episode of the backend engineering show I describe an interesting bug I ran into where the web server ran out of ephemeral ports causing the system to halt.
0:00 Intro
0:30 System architecture
2:20 The behavior of the bug
4:00 Backend Troubleshooting
7:00 The cause
15:30 Ephemeral ports on loopback
io uring gets even faster
Fundamentals of Operating Systems Course
https://os.husseinnasser.com
Linux I/O expert and subsystem maintainer Jens Axboe has submitted all of the IO_uring feature updates ahead of the imminent Linux 6.10 merge window.
In this video I explore this with a focus on what zerocopy.
0:00 Intro
0:30 IO_uring gets faster
2:00 What is io_uring
7:00 How Normal Copying Work
12:00 How Zero Copy Works
They made Python faster with this compiler option
Fundamentals of Operating Systems Course
https://oscourse.win
Looks like fedora is compiling cpython with the -o3 flag, which does aggressive function inlining among other optimizations.
This seems to improve python benchmarks performance by at most 1.16x at a cost of an extra 3MB in binary size (text segment). Although it does seem to slow down some benchmarks as well though not significantly.
How Apache Kafka got faster by switching ext4 to XFS
https://oscourse.win
Allegro improved their Kafka produce tail latency by over 80% when they switched from ext4 to xfs. What I enjoyed most about this article is the detailed analysis and tweaking the team made to ext4 before considering switching to xfs. This is a classic case of how a good tech blog looks like in my opinion.
0:00 Intro
0:30 Summary
2:35 How Kafka Works?
5:00 Producers Writes
Google Patches Linux kernel with 40% TCP performance
Get my backend course https://backend.win
Google submitted a patch to Linux Kernel 6.8 to improve TCP performance by 40%, this is done via rearranging the tcp structures for better cpu cache lines, I explore this here.
0:00 Intro
0:30 Google improves Linux Kernel TCP by 40%
1:40 How CPU Cache Line Works
6:45 Reviewing the Google Patch
https://www.phoronix.com/news/Linux-6.8-Networking
https://l
Database Torn pages
0:00 Intro
2:00 File System Block vs Database Pages
4:00 Torn pages or partial page
7:40 How Oracle Solves torn pages
8:40 MySQL InnoDB Doublewrite buffer
10:45 Postgres Full page writes
Cloudflare Open sources Pingora (NGINX replacement)
Get my backend course https://backend.win
Cloudflare has announced they are opening sources Pingora as a networking framework! Big news, let us discuss
0:00 Intro
0:30 Reasons why Cloudflare built Pingora?
3:00 It is a framework!
7:30 What in Pingora?
11:50 Security in Pingora
13:45 Multi-threading in Pingora
21:00 Customization vs Configuration
25:00 Summary
https://blog.cloudflare.com/pi
The Internals of MongoDB
https://backend.win
https://databases.win
I’m a big believer that database systems share similar core fundamentals at their storage layer and understanding them allows one to compare different DBMS objectively. For example, How documents are stored in MongoDB is no different from how MySQL or PostgreSQL store rows.
Everything goes to pages of fixed size and those pages are flushed to disk.
Eac
The Beauty of Programming Languages
In this video I explore the type of languages, compiled, garbage collected, interpreted, JIT and more.
The Danger of Defaults - A PostgreSQL Story
I talk about default values and how PostgreSQL 14 got slower when a default parameter has changed.
Mike's blog
https://smalldatum.blogspot.com/2024/02/it-wasnt-performance-regression-in.html
Database Background writing
Background writing is a process that writes dirty pages in shared buffer to the disk (well goes to the OS file cache then get flushed to disk by the OS) I go into this process in this video
The Cost of Memory Fragmentation
Fragmentation is a very interesting topic to me, especially when it comes to memory.
While virtually memory does solve external fragmentation (you can still allocate logically contiguous memory in non-contiguous physical memory) it does however introduce performance delays as we jump all over the physical memory to read what appears to us for example as contiguous array in virtual memory.
You
The Real Hidden Cost of a Request
In this video I explore the hidden costs of sending a request from the frontend to the backend
Heard
https://medium.com/@hnasr/the-journey-of-a-request-to-the-backend-c3de704de223
Why create Index blocks writes
Fundamentals of Database Engineering udemy course (link redirects to udemy with coupon)
https://database.husseinnasser.com
Why create Index blocks writes
In this video I explore how create index, why does it block writes and how create index concurrently work and allow writes.
0:00 Intro
1:28 How Create Index works
4:45 Create Index blocking Writes
5:00 Create Index Concurrently
The Problems of an HTTP/3 Backend
HTTP/3 is getting popular in the cloud scene but before you migrate to HTTP/3 consider its cost. I explore it here.
0:00 Intro HTTP/3 is getting popular
3:40 HTTP/1.1 Cost
5:18 HTTP/2 Cost
6:30 HTTP/3 Cost
https://blog.apnic.net/2023/09/25/why-http-3-is-eating-the-world/
Encrypted Client Hello - The Pros & Cons
The Encrypted Client Hello or ECH is a new RFC that encrypts the TLS client hello to hide sensitive information like the SNI. In this video I go through pros and cons of this new rfc.
0:00 Intro
2:00 SNI
4:00 Client Hello
8:40 Encrypted Client Hello
11:30 Inner Client Hello Encryption
18:00 Client-Facing Outer SNI
21:20 Decrypting Inner Client Hello
23:30 Disadvantages
26:00 Censorship vs Priva
The Journey of a Request to the Backend
From the frontend through the kernel to the backend processWhen we send a request to a backend most of us focus on the processing aspect of the request which is really just the last step.
There is so much more happening before a request is ready to be processed, most of this step happens in the Kernel. I break this into 6 steps, each step can theoretically be executed by a dedicated thread or proc
They Enabled Postgres Partitioning and their Backend fell apart
In a wonderful blog, Kyle explores the pains he faced managing a Postgres instance for a startup he works for and how enabling partitioning sigintfically created wait events causing the backend and subsequently NGINX to through 500 errors.
We discuss this in this video/podcast
https://www.kylehailey.com/post/postgres-partition-pains-lockmanager-waits
WebTransport - A Backend Game Changer
WebTransport is a cutting-edge protocol framework designed to support multiplexed and secure transport over HTTP/2 and HTTP/3. It brings together the best of web and transport technologies, providing an all-in-one solution for real-time, bidirectional communication on the web.
Watch full episode (subscribers only) https://spotifyanchor-web.app.link/e/cTSGkq5XuAb
Your SSD lies but that's ok | Postgres fsync
fsync is a linux system call that flushes all pages and metadata for a given file to the disk. It is indeed an expensive operation but required for durability especially for database systems. Regular writes that make it to the disk controller are often placed in the SSD local cache to accumulate more writes before getting flushed to the NAND cells.
However when the disk controller receives this f
The problem with software engineering
ego is the main problem to a defective software product. the ego of the engineer or the tech lead seeps into the quality of the product.
Fundamentals of Backend Engineering Design patterns udemy course (link redirects to udemy with coupon)
https://backend.husseinnasser.com
2x Faster Reads and Writes with this MongoDB feature | Clustered Collections
Fundamentals of Database Engineering udemy course (link redirects to udemy with coupon)
https://database.husseinnasser.com
In version 5.3, MongoDB introduced a feature called clustered collection which stores documents in the _id index as oppose to the hidden wiredTiger hidden index. This eliminates an entire b+tree seek for reads using the _id index and also removes the additional write to the
Prime Video Swaps Microservices for Monolith: 90% Cost Reduction
Prime video engineering team has posted a blog detailing how they moved their live stream monitoring service from microservices to a monolith reducing their cost by 90%, let us discuss this
0:00 Intro
2:00 Overview
10:35 Distributed System Overhead
21:30 From Microservices to Monolith
29:00 Scaling the Monolith
32:30 Takeaways
https://www.primevideotech.com/video-streaming/scaling-up-the-prime-
A Deep Dive in How Slow SELECT * is
Fundamentals of Database Engineering udemy course (link redirects to udemy with coupon)
https://database.husseinnasser.com
In a row-store database engine, rows are stored in units called pages. Each page has a fixed header and contains multiple rows, with each row having a record header followed by its respective columns. When the database fetches a page and places it in the shared buffer pool, w
AWS Serverless Lambda Supports Response Streaming
Lambda now supports Response payload streaming, now you can flush changes to the network socket as soon as it is available and it will be written to the client socket. I think this is a game changing feature
0:00 Intro
1:00 Traditional Lambda
3:00 Server Sent Events & Chunk-Encoding
5:00 What happens to clients?
6:00 Supported Regions
7:00 My thoughts
Fundamentals of Backend Engineering D
The Cloudflare mTLS vulnerability - A Deep Dive Analysis
Cloudflare released a blog detailing a vulnerability that has been in their system for nearly two years. it is related to mTLS or mutual TLS and specifically client certificate revocation. I explore this in details
0:00 Intro
3:00 The Vulnerability
7:00 What happened?
8:50 Certificate Revocation
12:30 Rejecting certain endpoints
17:00 Certificate Authentication
20:30 Certificate serial number
2
The Virgin Media ISP outage - What happened?
BGP (Border gateway protocol) withdrawals caused the Virgin media ISP customers to lose their Internet connection. I go into details on this video.
0:00 Intro
2:00 What happened?
4:11 How BGP works?
11:50 Version media withdrawals
15:00 Deep dive
Fundamentals of Backend Engineering Design patterns udemy course (link redirects to udemy with coupon)
https://backend.husseinnasser.com
GitHub SSH key is Leaked - How bad is this?
GitHub Accidentally Exposed their SSH RSA Private key, this is the message you will get .
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
Someone could be eavesdropping on you right now (man-in-the-middle attack)!
It i
Cookie Hijacking - How Linus Tech Tips got Hacked
How Linus Tech Tips channel got Hacked
In this short video we explain how was it possible for Linux to get hacked with cookies hijacking.
0:00 Intro
0:47 TLDR what happened
5:10 Cookies in Chrome
7:30 Cookies Hijacking
8:46 Session Tokens (Access/Refresh)
10:00 Remedies
All Postgres Locks Explained | A Deep Dive
Get my database engineering course https://database.husseinnasser.com
In this video I do a deep dive in all locks obtained by postgres, I learned a lot while making this video and hope you enjoy it.
0:00 Intro
2:30 What are Locks?
5:30 Overview of Postgres Locks
9:10 Table-Level Locks
11:40 ACCESS EXCLUSIVE
17:40 ACCESS SHARE
19:00 ROW SHARE
20:15 ROW EXCLUSIVE
21:15 SHARE UPDATE EXCLUSIVE
23
Pinterest moves to HTTP/3
Pinterest moves to HTTP/3 on all their clients and edge CDNs this year. They witnessed interesting gains but not without good lesson learned. The main one was the mismatch of alt-svc vs DNS ttls.
I cover this on the next episode of the backend engineering course.
0:00 Intro
2:00 Moving h2 to h3 through alt-svc
5:00 Why HTTP/3
6:00 HTTP/1 vs HTTP/2
9:00 TCP Head of Line blocking in HTTP/2
11:00 How
Why Loom Users got each others’ sessions on March 7th 2023
On March 7 2023, Loom users started seeing each others data as a result of cookies getting leaked from the CDN. This loom security breach is really critical. Let us discuss 0:00 Intro 1:00 Why Cookies 2:00 How this happens 5:50 What caused it? 7:30 How Loom solved it? 8:20 Reading the RCA 10:30 Remedies
How Discord Stores Trillions of Messages - A deep dive
Discord engineering goes into details of how they migrated from Cassandra to ScyllaDB, improved the performance of their reads and writes and rearchitected their backend to support the new load. It is an interesting episode lets get into it
0:00 Intro
1:50 Relational vs Distributed
7:00 The Cassandra Troubles
11:00 SnowFlake vs UUID
14:30 B+Tree
19:20 B+Tree and SSDs
25:30 LSM Trees
31:00 Hot part
Postgres Architecture | The Backend Engineering Show
Creating a listener on the backend application that accepts connections is simple. You listen on an address-port pair, connection attempts to that address and port will get added to an accept queue; The application accepts connections from the queue and start reading the data stream sent on the connection.
However, what part of your application does the accepting and what part does the reading and
How Alt-Svc switches HTTP/2 clients to use HTTP/3 | The Backend Engineering Show
The Alt-Svc header/frame is a capability that allows the server to adverse alternative services to the connected application available in protocols, ports or domains. It is available as a response header alt-svc and also as an HTTP/2 frame. Let us discuss this capability.
0:00 Intro
1:38 what is alt-svc?
5:30 uses of h3 in alt-svc
8:00 alt-svc header
10:00 Alt-svc header with 103 early hints
14:48
Your DNS queries will eventually look like this (0x20 DNS encoding)
Correction: Google is implementing the proposal originally submitted by researchers from Georgia institute of tech. I incorrectly said in the video that google is proposing this .
Google is finally implementing a proposal from 2008 by researchers from Georgia institute of technology to make DNS cache poisoning .
https://astrolavos.gatech.edu/articles/increased_dns_resistance.pdf
https://datatracke
DropBox Removed their SSDs, got 20% faster writes
https://dropbox.tech/infrastructure/increasing-magic-pocket-write-throughput-by-removing-our-ssd-cache-disks
In this episode of the backend engineering show I’ll discuss how Dropbox improved their write through put by 20% by removing all their SSDs (yes I was surprised too). DropBox uses an SSD layer as a write-back cache with SMR drives as their backend persistent storage. They changed their mode
MySQL on HTTP/3 | The Backend Engineering Show
The communication between backend applications and database systems always fascinated me. The protocols keep evolving and we are in constant search for an efficient protocol that best fit the workload of Backend-DB communication.
In this episode of the backend engineering show I go through a blog written by @PlanetScale doing an experimentation of using HTTP/3 and HTTP/2 comparing it w
How Shopify’s engineering improved writes by 50% with ULID | The Backend Engineering Show
Fundamentals of Database Engineering udemy course (link redirects to udemy with coupon)
https://database.husseinnasser.com
Shopify posted a blog on tips to for scalable payment system, one tip peeked my interest related to switching from UUID to ULID. I explore the reasoning behind this in this video.
https://shopify.engineering/building-resilient-payment-systems
0:00 Intro
1:30 idempotency
6:30 U
MongoDB Internal Architecture | The Backend Engineering Show
I’m a big believer that database systems share similar core fundamentals at their storage layer and understanding them allows one to compare different DBMS objectively. For example, How documents are stored in MongoDB is no different from how MySQL or PostgreSQL store rows. Everything goes to disk, the trick is to fetch what you need from disk efficiently with as fewer I/Os as possible, the rest i
How UI/UX can break the backend
The User Interface/User Experience has great impact on the backend architecture and scalability. In this podcast I discuss three UI/UX that affected backend design and scalability.
0:00 Intro
1:40 UI vs UX
4:30 Google Chrome OmniBox
12:30 1 out of X Page
20:00 YouTube Notification
Resources
https://blog.apnic.net/2020/08/21/chromiums-impact-on-root-dns-traffic/
Fundamentals of Backend Engineering
Do DHCP and DNS Servers Communicate?
In this video I explain how DHCP work and how it updates DNS entries for new hosts joining the network. I'll also mention Zero Config
0:00 Intro
1:00 the Network configuration
6:00 Showing DHCP in Wireshark
6:30 DHCP Discover
14:40 DHCP Offer
19:00 DHCP Request
21:30 DHCP ACK
22:00 How DHCP Updates DNS
26:15 Zero Configuration (mDNS, Link-local)
Resources
Dhcp https://datatracker.ietf.org/doc/html
Compressing Certificates in TLS | The Backend Engineering Show
Fundamentals of Backend Engineering Design patterns udemy course (link redirects to udemy with coupon)
https://backend.husseinnasser.com
Certificates provide a way to authenticate both the server and the client and are included as part of the TLS handshake. However, the certificates can be large because the full certificate chain is included in the handshake. The large certificates can go up to 1
OpenSSL new vulnerability
Two new vulnerabilities in openssl were discovered, we discuss them in this video
https://www.openssl.org/news/secadv/20221101.txt
TCP Protective Load Balancing coming to Linux Kernel 6.2
Google recent paper on protective load balancing in TCP attempts to improve packet drops and latency by making the host change the flow path using the IPv6 Flow label. The Linux kernels gets the PLB support in Linux 6.2 this December, let us discuss with this is.
When NodeJS I/O Blocks | The Backend Engineering Show
In this episode of the backend engineering show I go through an article I wrote discussing NodeJS Asynchronous I/O
https://medium.com/@hnasr/when-nodejs-i-o-blocks-327f8a36fbd4
Learn the fundamentals of network engineering, get my udemy course
https://network.husseinnasser.com
Buy me a coffee if you liked this
https://www.buymeacoffee.com/hnasr
0:00
3:00 Part 1 Socket/IO
9:48 Part 2 File
NGINX Internal Architecture - Workers | The Backend Engineering Show
Buy me a coffee if you liked this https://www.buymeacoffee.com/hnasr
In this podcast I explain the NGINX internal process architecture, how NGINX spins up multiple processes per core, how each process is pinned to a CPU core for minimum context switching, how NGINX accepts connections , parses requests and talks to the backend. Get my introduction to NGINX udemy course http
Cloudflare is moving away from NGINX | The Backend Engineering Show
Cloudflare identified several limitations in NGINX architecture and decided to write their own reverse proxy.
0:00 Intro
1:53 What NGINX is used for
3:37 NGINX Architecture
7:52 NGINX Limitations
17:12 Cloudflare Pingora
Buy me a coffee if you liked this
https://www.buymeacoffee.com/hnasr
Fundamentals of Networking for Effective Backends udemy course (link redirects to udemy with coupon)
https:
Threads and Connections | The Backend Engineering Show
In this episode of the backend engineering show I discuss the evolution of multi-threading apps, their pros and cons and then I go through 5 threading model and how they interleave with backend connection management between the threads and requests handlings. Enjoy
To learn more about networking fundamentals check out my udemy course Fundamentals of Networking for Effective Backends Head to https
Memcached Architecture | The Backend Engineering Show
Memcached is an in memory cache with one major feature be a transient cache. Memcached has a very simple design. It was originally designed to help with database load by storing the query result in memory to avoid further querying the database. By default it has no authentication, a simple text protocols, servers don’t talk to each other. This video discuss the architecture of the cache, design ch
Recommended
Solved Murders - True Crime Stories
紐約鳥｜New York Aperture
The Swerve Podcast: Obscure Topics | Conspiracy Theories
The Bread and Banter Podcast
The Church of What's Happening Now: The New Testament
Busted Open
Deadline: White House
Panda Show - Picante
Crickets Corner
History of the Earthquake and Fire in San Francisco
Fox news
K-Drama Obsessed Mamas | Beyond “Just One More Episode!”
