The more clever your code, the harder it is to read. The easier it is for Bugs to infest it

The elegant design of separating concerns in Apache Kafka creates tons of potential scalability improvements. But also comes with tradeoffs. Publisher, Consumer and a Broker

m1- Fundamentals of Operating Systems 2- Fundamentals of Network Engineering 3- Fundamentals of Backend Engineering OS Course coupon: OS-FALL25 www.udemy.com/course/funda... Network Course: NT-FALL25 www.udemy.com/course/funda... Backend Course: BK-FALL25 www.udemy.com/course/funda...

Memorizing trick programming questions and answering interviews flawlessly as you may know isn’t productive. Coming up with your own solution on the fly, no matter how inefficient or bad you think it is 100 times better.

Postgres runs on port 5432, this is the responsibility of the Post master process. However did you know that listening socket isn’t created until another process finish running first? That is startup process (ST), responsible for WAL redo when the database crashes.

Probably nothing symbolizes tradeoffs than RAID in software engineering In RAID1 we wanted redundancy in case of disk failure In RAID0 we wanted performance, so we would stripe the block and “smear” it across multiple devices

Free performance for full table scans in Postgres 17 The enhancement in Postgres 17 is to combine I/Os you can specify how much IO to combine, so technically while possible you can scan that entire table in one system call doesn’t mean its always a good idea of course and Ill talk about that.

Uber reduced their database locks by 94% when they upgraded to MySQL 8.0, thanks to this performance rearchitecture. Watch my full deep dive coverage here Advanced MySQL Index Locking Explained youtu.be/MK24y7AmKTc

You level-up as a software engineer when you do things your own way and then naturally find a way to do them better.

Feels great when you help a customer. You see, 80% of your customers will use 20% of features in your software. Try to Invest in making the 20 as efficient as possible. Fixing performance and scalability in the 20 so customers enjoy an effective experience.

The Anatomy of a WebSockets frame With a maximum header size of 14 bytes makes more efficient for bidirectional use cases (eg chatting, gaming) compared to using long polling which has the overhead of HTTP headers. Of course being on top of TCP we suffer the head of line blocking.

memory allocation is an interesting dilemma. You can allocate exactly what you need making allocations compact and efficient. But once you start deallocating, you are left with too many tiny non-uniform gaps and fragments that cannot be reused effectively (left image).

WebSockets, a protocol designed in 2010 perhaps earlier was optimized to keep the header size is small as possible. Which is something I like very much. Instead of using a fixed size header for the payload length, the designer used a 7bit indicator to indicate how much bytes will be used.

Sometimes we get torn in software decisions between lazy loading vs eager loading, both has their pros and cons. But we forget that there is a third option: To not load anything at all. Do you absolutely need what you are loading?

NGINX is a powerful proxy and lots of the Internet runs this powerhouse. Like any technology it has its pros and cons, and in this course I walk you through the power of NGINX and shed light on its drawbacks. Grab your copy at nginx.husseinnasser.com

There are two types of people. Those who you give a destination, a desired outcome and they run and get it done. And those who you need to give clear step by step instructions to get there. And they get you there. I think a company needs both.

There is tremendous joy that can be extracted from breaking down technology to its fundamental first principles. At first it is blurry, confusing and filled with vague abstraction. Once understood, it is clear as day. Only then an engineer can use the technology effectively.

If you truly know what you need you will build a good product. The challenge is not to stray out of that path.

The upcoming Postgres 18 is set to include some nice improvements to EXPLAIN: * BUFFERS on by default with ANALYZE 🎉 * Fractional "actual rows" (huge in some cases) * Quite a few new fields (including the very cool Index Searches) We've now added support for all of them. 💛

It feels good to understand what goes on behind the scenes in the database. It boils down to the fundamentals that I compiled in this course. I get messages from people who passed interviews, got hired, promoted and improved their apps. Grab your copy databases.win

March 2000

When we were children we used to freely express. As we grow up and build identity we start to impress. To impress comes with expectations and expectations leads to disappointment. Going back to free express is liberating.

March 2000

Troubleshooting a challenging bug can be rewarding. When you can consistently reproduce the bug you are close to understanding it. When the bug is fully understood the solution emerges. The bug is just a behavior, it just happens to be an undesirable one.

New Course .. Scalable Realtime Backends Head to realtime.husseinnasser.com Use code REALTIME

Operating systems orchestrate many processes, allow access to memory, disk, network and execute processes by scheduling them to the CPU. I built this course to demystify what I believe are the fundamentals operating systems to software engineers. Grab it here oscourse.win

Understanding HTTP/1.1 and HTTP/2 will make statements like this in MDN more clear. Server sent events or SSE is essentially a request with a very long response trickling “events”. This means if this was an h1 connection, that connection will be in use. With h1 browsers limit to 6 per domain

Bugs can level up a software engineer if they are truly sincere in arriving at the fundamental cause and thus getting over the bug for good.

A true database problem in the networking world. The BPG routers have close to 1 million rows in their routing tables. Receiving a packet must lookup IP address, find all matching subnets, pick the lowest cost route to find the next hop. It has to do this in fraction of a second.

My favorite thing about software engineering is making it transparent. Node is one of the most popular runtimes used on backend engineering yet I feel it is the least understood. I surely ran into this way at times.

When you realize that most memory copy operations use the CPU your perspective to software engineering changes. You will begin to look at programs differently, you will see the hotspots, understand the reasoning behind senior devs pull requests.

The following two SQL queries are different for the planner. select * from emp where id = 7 select * from emp where id = 9 The planner needs to parse, compile and produce a query plan for each one.

ktls 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.

To architect performant backend applications, it is better to start from first principles. Depending on the use case and the workflow, the engineer asks questions such as: What protocols should be used? What web servers, proxies, and communication patterns should be considered?

Retrying a request may look benign when writing a single client. However if that client scales, or worse if that logic is embedded in a library and referenced in other clients (abstracted), it can take down backends, databases and even cause congestion in network devices.

This new PostgreSQL 17 feature is game changer. The enhancement in Postgres 17 is to combine I/Os you can specify how much IO to combine, so technically while possible you can scan that entire table in one system call doesn’t mean its always a good idea of course and Ill talk about that.

In a volatile engineering climate, navigating rapid change in IT becomes challenging. I had the pleasure to be part of a panel discussion with Kelsey Hightower, Hussein Nasser, Andjelko Iharos, and Baptiste Assmann. I hope you enjoy the discussion, link here www.haproxy.com/user-spotlig...

a Java app won’t detect database drivers. Works on Windows, fails on Linux. Despite setting the PATH env variable. I later learned that there is an env variable in linux LD_LIBRARY_PATH where the linker uses to lookup shared libraries which the Java needs for dynamic linking.

My talk at the HAProxy conf 2025 hosted in San Fransisco. Had a blast speaking and met great people. The title of the talk: Anatomy of a request - Beyond Backend processing www.haproxy.com/user-spotlig...

An interesting case of the CORS Backend returned the allow-origin header but so did the load balancer. Browser gets two headers with the same name, different values and throw this error. header contains multiple values but only one is allowed.

A good engineer understands the limitations of the software they use (database, proxy, etc.) and build their workflows to flow with them as opposed of against them.

Each TCP connection provides a single ordered stream of bytes.

Postgres builds a list of active transactions to represent a snapshot. That list is checked against rows to determine visibility and MVCC. This can get large Do we do O(N)? or sort the array and do bubble sort? Utilize modern hardware SIMD ? or better yet, spend more memory and make it a hash table

This is probably the most error I encountered in my career. What was yours?

I wonder whatever happened to the term “service pack”? I used to see it commonly used in the 2010s, but not anymore. Patch is preferred now. I think Microsoft might still uses it though

I believe much of the excess in current applications arises from their creation on powerful computers, which hide coding inefficiencies. Unfortunately, modern integrated development environments (IDEs) and tools also demand top-tier machines since they consume significant resources.

I enjoy asking this question during interviews, as it opens the door to a wide array of engaging technical discussions. It also shines light at the parts of the system that were assumed to be understood. How would you handle canceling an HTTP request that started a lengthy database transaction?

In HTTP/1.1, the URL includeing query parameters, is part of the request line. The larger the URL, the larger the request, which increases network transmission cost, kernel userspace copy, and thus CPU. In HTTP/2, the URL gets placed as a pseudo header called colon path, which is then compressed.

Machines have disks attached. Each disk is visualized as an array of fixed size logical blocks( Historically referred to as sectors). Disks can be logically partitioned. Where each partition takes a start block and an end block. With that knowledge, everything above it starts to make sense.

Databases have tables and indexes stored in files and cached in memory aka as buffer pool. As you create rows, the database system writes the rows to data pages on memory first which is then eventually written to data files on disk.