Fundamentals of Backend Engineering

Fundamentals of Backend Engineering

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 50 lectures (15h 34m) | 12.92 GB

Understand backend communication design patterns, protocols, execution and proxying

Backend engineering is an art. During my 18 years career working with and building backend applications, I discovered that certain communication design patterns keep emerging. There are only handful of ways clients communicate with backend applications, although they might be more, I believe the patterns I discuss in this course are the most common. Examples of these patterns are request-response, publish-subscribe, short and long and push.

Based on these communication design patterns, engineers may use a number of protocols for concrete communication. While core transport vehicles are limited to either TCP or UDP, tons of industry specific protocols are built on top of these two to address certain problems and use cases. Examples of these high level protocols are HTTP/1.1, HTTP/2, HTTP/3, gRPC, WebRTC and many more. Other transport protocols like QUIC was built on top of UDP to bring HTTP/2 streaming down at the transport level. Each protocol has its pros and cons and fits certain use cases. In the course, I discuss the top common protocols and provide examples and demos where applicable.

Before the client can send a request, it has to establish a connection to the backend. Understanding how the connection is established, and what parts of connection establishment is done at kernel and what parts are done at the backend application process is critical. How the connection is then accepted by the backend application and how it can accept connections as fast as possible so the kernel queue doesn’t get full otherwise clients can no longer connect.

After the connection is established the client sends the request, but what happens exactly in the backend application to read the request? What exactly is a request? Understanding the cost of parsing a request based on the protocol makes the engineer appreciate the work done and equip her with better tools to troubleshoot performance problems or bugs.

Once the request reaches the backend, the application has to execute the request. The backend has a buffet of design choices when it comes to the style of execution it can choose. Understanding the difference between a process and a thread, multi-process, multi-threaded and the correlation to the number of CPU cores or hardware threads is crucial to pick the right execution pattern. One does not have to stick with these patterns but can invent new ones that suits their needs.

This course is designed for engineers who have built backend applications, it is an intermediate — advance level course, certain programming and networking knowledge is required so I recommend taking my fundamentals of network engineering course before taking this course if you don’t have the networking skills. I hope you enjoy this course, and thank you so much for considering it.

What you’ll learn

  • Learn the fundamentals of backend engineering
  • Backend communication design patterns
  • Understand how backend communication protocols work
  • Comprehend how OS Kernel communicate with Backend Applications
  • Operating System fundamentals (Thread, Process, async IO in linux)
  • Learn HTTP/1.1, HTTP/2, HTTP/3
  • Learn gRPC, WebRTC, WebSockets
  • Learn TLS 1.2, TLS 1.3, QUIC 0RTT
Table of Contents

1 Welcome
2 Who is this course for
3 Course Outline
4 Download all slides source code and references

Backend Communication Design Patterns
5 Backend Communication Design Patterns Intro
6 Request Response
7 Synchronous vs Asynchronous workloads
8 Push
9 Polling
10 Long Polling
11 Server Sent Events
12 Publish Subscribe PubSub
13 Multiplexing vs Demultiplexing h2 proxying vs Connection Pooling
14 Stateful vs Stateless
15 Sidecar Pattern

16 Protocols Intro
17 Protocol Properties
18 OSI Model
19 Internet Protocol
20 UDP
21 TCP
22 TLS
23 HTTP11
24 WebSockets
25 HTTP2
26 HTTP3
27 gRPC
28 WebRTC

Many ways to HTTPS
29 HTTPS Communication Basics Intro
30 HTTPS over TCP with TLS 12
31 HTTPS over TCP with TLS 13
33 HTTPS over TFO with TLS 13
34 HTTPS over TCP with TLS 13 and 0RTT
35 HTTPS over QUIC with 0RTT

Backend Execution Patterns
36 Backend Execution Patterns Intro
37 The Process and The Thread and how they compete for CPU time
38 How The Backend Accepts Connections
39 Reading and Sending Socket Data
40 The Listener The Acceptor and the Reader
41 Single Listener Acceptor and Reader Thread Execution Pattern
42 Single Listener Acceptor and Multiple Readers Thread Execution Pattern
43 Single Listener Acceptor Reader with Message Load Balancing Execution Pattern
44 Multiple Accepter Threads on a Single Socket Execution Pattern
45 Multiple Listeners Acceptors and Readers with Socket Sharding Execution Pattern
46 Backend Idempotency
47 Nagles Algorithm

Proxying and Load Balancing
48 Proxy vs Reverse Proxy
49 Layer 4 vs Layer 7 Load Balancers

50 How ChatGPT uses Server Sent Events