Fundamentals Of Backend Engineering
Last updated 5/2024
MP4 | Video: h264, 1920x1080 | Audio: AAC, 44.1 KHz
Language: English | Size: 15.29 GB | Duration: 17h 2m
Understand backend communication design patterns, protocols, execution and proxying
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
Requirements
Intermediate programming skills (1-2 years)
Having built a backend application
Basic network fundamentals
Description
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.
Overview
Section 1: Introduction
Lecture 1 Welcome
Lecture 2 Who is this course for?
Lecture 3 Course Outline
Lecture 4 Course Notes
Lecture 5 Download all slides, source code and references
Section 2: Backend Communication Design Patterns
Lecture 6 Backend Communication Design Patterns Intro
Lecture 7 Request Response
Lecture 8 Synchronous vs Asynchronous workloads
Lecture 9 Push
Lecture 10 Polling
Lecture 11 Long Polling
Lecture 12 Server Sent Events
Lecture 13 Publish Subscribe (Pub/Sub)
Lecture 14 Multiplexing vs Demultiplexing (h2 proxying vs Connection Pooling)
Lecture 15 Stateful vs Stateless
Lecture 16 Sidecar Pattern
Section 3: Protocols
Lecture 17 Protocols Intro
Lecture 18 Protocol Properties
Lecture 19 OSI Model
Lecture 20 Internet Protocol
Lecture 21 UDP
Lecture 22 TCP
Lecture 23 TLS
Lecture 24 HTTP/1.1
Lecture 25 WebSockets
Lecture 26 HTTP/2
Lecture 27 HTTP/3
Lecture 28 gRPC
Lecture 29 WebRTC
Section 4: Many ways to HTTPS
Lecture 30 HTTPS Communication Basics Intro
Lecture 31 HTTPS over TCP with TLS 1.2
Lecture 32 HTTPS over TCP with TLS 1.3
Lecture 33 HTTPS over QUIC (HTTP/3)
Lecture 34 HTTPS over TFO with TLS 1.3
Lecture 35 HTTPS over TCP with TLS 1.3 and 0RTT
Lecture 36 HTTPS over QUIC with 0RTT
Section 5: Backend Execution Patterns
Lecture 37 Backend Execution Patterns Intro
Lecture 38 The Process and The Thread and how they compete for CPU time
Lecture 39 How The Backend Accepts Connections
Lecture 40 Reading and Sending Socket Data
Lecture 41 The Listener, The Acceptor and the Reader
Lecture 42 Single Listener, Acceptor and Reader Thread Execution Pattern
Lecture 43 Single Listener, Acceptor and Multiple Readers Thread Execution Pattern
Lecture 44 Single Listener, Acceptor, Reader with Message Load Balancing Execution Pattern
Lecture 45 Multiple Accepter Threads on a Single Socket Execution Pattern
Lecture 46 Multiple Listeners, Acceptors and Readers with Socket Sharding Execution Pattern
Lecture 47 Backend Idempotency
Lecture 48 Nagle's Algorithm
Section 6: Proxying and Load Balancing
Lecture 49 Proxy vs Reverse Proxy
Lecture 50 Layer 4 vs Layer 7 Load Balancers
Section 7: Extras
Lecture 51 How ChatGPT uses Server Sent Events
Lecture 52 How I design software
Lecture 53 The Journey of a Request to the Backend
Lecture 54 The Journey of a Request to the Backend (Video)
Lecture 55 JSON Web Token (JWT), its Pros and Cons
Section 8: Answering Your Questions
Lecture 56 How does the Kernel manage backend connections?
Backend Engineers,FullStack Engineers,Frontend Engineers interested in the Backend (must have built a backend app),Network engineers who want to get better at backend design,Site reliability engineers
Homepage
https://www.udemy.com/course/fundamentals-of-backend-communications-and-protocols/
https://rapidgator.net/file/889f2826739bcd9d793fc9e07fe7099b
https://rapidgator.net/file/8f0a5efe9a1e48dc568fb76f24bfa8eb
https://rapidgator.net/file/0e7cbf0270ae386f3d0b6e91652da5bb
https://rapidgator.net/file/e1e5d3eecafb63e1e43950d85859722e
https://rapidgator.net/file/e226d527e4da9943872d4e8025fe7d6f
https://rapidgator.net/file/6533ce5ffcbaf215bdce8e560d7d6f10
https://rapidgator.net/file/efbe6826913bd6f518e8bac3354d8b48
https://rapidgator.net/file/bf639b10bb263e3401734a07be4b713d
https://rapidgator.net/file/d1e5f26969534c4bff6fd8694dc30631
https://rapidgator.net/file/510d2b8db3a89957bcd607843e6c02bc
https://rapidgator.net/file/3767b8b20559cbe6edf3c317b6477ecb
https://rapidgator.net/file/e1fd48ea7bc5a998ad28268afb72c766
https://rapidgator.net/file/395aef5c6b1695a1af54f46b14cfcf2b
https://rapidgator.net/file/a0c21c37a26aaff6d63cc369aab4b4e8
https://rapidgator.net/file/639c15efd6d34ad433cacc1b26d5408d
https://rapidgator.net/file/e5dda8eae0e3426317e8b38b17515086
https://ddownload.com/rq7faaw4m2fi
https://ddownload.com/dt5n8chhje3z
https://ddownload.com/oad3g87ej8rj
https://ddownload.com/v63kjxdxucou
https://ddownload.com/8nvu9mtc6rsh
https://ddownload.com/oq5ks6k6uh7z
https://ddownload.com/fl1k9iqz05o4
https://ddownload.com/vet0kcjqjahr
https://ddownload.com/sv1p48vrsaqe
https://ddownload.com/7wup7l2xrt52
https://ddownload.com/hvd64tlq9xio
https://ddownload.com/65fidvpbuqjf
https://ddownload.com/icjm438afxh7
https://ddownload.com/16dmxf0z37m5
https://ddownload.com/6nurdy5jdejo
https://ddownload.com/9y8zcvgju3eu