Backend Engineering (Advanced)
This collection of videos covers major system design concepts and fundamentals that every backend engineer needs to understand. This will help you in your design interviews. The videos are ordered in the way they should be consumed. This playlist is designed for advanced viewers
List of all Backend Engineering Playlists
👨💻Backend Engineering (Beginner) https://www.youtube.com/playlist?list=PLQnljOFTspQUNnO4p00ua_C5mKTfldiYT
👩💻Backend Engineering (Intermediate) https://www.youtube.com/playlist?list=PLQnljOFTspQWGuRmwojJ6LiV0ejm6eOcs
👨🏻💻Backend Engineering (Advanced) https://www.youtube.com/playlist?list=PLQnljOFTspQUybacGRk1b_p13dgI-SmcZ
Curated by: Hussein Nasser (79 videos)
Currently Playing: The IPFS Protocol Explained with Examples - Welcome to the Decentralized Web
The InterPlanetary File System (IPFS) is a protocol and peer-to-peer network for storing and sharing data in a distributed file system. IPFS uses content-addressing to uniquely identify each file in a global namespace connecting all computing devices.
Download Slides here https://payhip.com/b/R1Mu
Intro 0:00
Why IPFS? 2:00
Explain the original web model and the limitation
* Content addressing instead of location addressing
* decentralized content distributed among peers
Content 3:30
* Content is hashed as CID
* Content is immutable each update generates new CID
* Content addressing
Routing 4:30
* Distributed Hash Table (DHTs) maps CID / Peer IP address
* DHT server hosts content and DHT
Publishing Content 6:30
* New Content that you want to share on ipfs
* hash the content creating new CID
* Update your local DHT CID / your ip address
* DHT will be updated to all the content peer (NOT the CONTENT)
* People searching for your CID will be connected to you and only you.
Consuming Content 8:48
* ipfs client (dht client) want to consume Ipfs://cid/
* ipfs client consults its local DHT table to see where this CID is located, gets back a collection of IP addresses
* client connects to some or all the peers found hosting that CID
* client downloads chunks of the content from each peer so it speeds up
* Once the client has the content it is now also updating its local DHT table that it now also hosts that CID (if it supports being a DHT server)
* New updated DHT is propogated across peer
IPFS Overview (Digrams) 11:30
Demo 13:45
More Information 18:30
Immutable Content
* if Content gets updated changes URI how do I inform the user?
* hash the public key of the user instead and share that
Brand new Client/server
* I know nothing about the network (Bootstraping)
* you will be bootstrapped with a collection of ip addresses to start you up.
More
* IPFS gateway
* IP Name server
* Solve content
* Deleting Content( once other node hosts it no way to delete it from their network)
NAT traversal
Resources
https://datatracker.ietf.org/meeting/interim-2020-dinrg-01/materials/slides-interim-2020-dinrg-01-sessa-an-overview-of-the-interplanetary-file-system-ipfs.pdf
https://www.youtube.com/watch?v=K4Usud4g4iY&feature=youtu.be&t=1008
https://twitter.com/hnasr/status/1353548949945163776?s=21
https://docs.ipfs.io/concepts
🎙️Listen to the Backend Engineering Podcast
https://husseinnasser.com/podcast
🏭 Backend Engineering Videos
https://backend.husseinnasser.com
💾 Database Engineering Videos
https://www.youtube.com/playlist?list=PLQnljOFTspQXjD0HOzN7P2tgzu7scWpl2
🏰 Load Balancing and Proxies Videos
https://www.youtube.com/playlist?list=PLQnljOFTspQVMeBmWI2AhxULWEeo7AaMC
🏛️ Software Archtiecture Videos
https://www.youtube.com/playlist?list=PLQnljOFTspQXNP6mQchJVP3S-3oKGEuw9
📩 Messaging Systems
https://www.youtube.com/playlist?list=PLQnljOFTspQVcumYRWE2w9kVxxIXy_AMo
Become a Member
https://www.youtube.com/channel/UC_ML5xP23TOWKUcc-oAE_Eg/join
Support me on PayPal
https://bit.ly/33ENps4
Join our Thriving Backend Community on Discord
https://discord.com/invite/CsFbFce
Stay Awesome,
Hussein
Tracks in this Playlist
- Database Replication Crash Course ( with Postgres 13 )
- How Database Cursors Help in Fetching Large Result sets from your SQL
- How much can you learn about the Backend from its API?
- A Database User for each REST Route - Best Practices for Backend Application with Postgres
- Best Practices Building Backend Application With Node JS Express and Postgres
- Multi-player System Game Design - Pros & Cons of Proposed Designs & System Design Interviews Advice
- What is a Distributed Transaction in Microservices?
- When to use UDP vs TCP in Building a Backend Application?
- Doordash moves their Backend to Apache Kafka from RabbitMQ, VERY interesting! Let us discuss it!
- Is there a Limit to Number of Connections a Backend can handle?
- Create Index Blocking Production Database Writes? Postgres Solves this with this trick
- Identify good software documentation from bad ones
- HTTP/2 Critical Limitation that led to HTTP/3 & QUIC (Explained by Example)
- Should RabbitMQ Implement QUIC Protocol for their Channels Message Queue?
- Can the QUIC Protocol improve Database Performance in Web Applications?
- Explaining Key vs Non-Key Column Database Indexing and How it can Improve Performance
- WebRTC Crash Course
- Facebook Moves their Backend and Frontend to QUIC, Wasn’t smooth but it Paid Off, let us discuss
- Opening Old Wounds - Why Uber Engineering Switched from Postgres to MySQL
- How HTTP Tunneling works, The CONNECT method, Pros & Cons and more
- Discord Backend Architecture Discussion
- Why Discord Moved from MongoDB to Apache Cassandra, Let us Discuss
- A Detailed Analysis of The Amazon Kinesis US East-1 Outage - AWS Outage Explained
- The 2020 Google Outage (Detailed Analysis)
- cURL Verbose Mode Explained (and how I use it to Troubleshoot my Backend)
- The IPFS Protocol Explained with Examples - Welcome to the Decentralized Web
- iptables Demystified - Port Redirection and Forwarding HTTP Traffic to another machine (part 1)
- iptables Demystified - Load Balancing without a Load Balancer (no software installation) (part 2)
- Can you Max-out the Connections between Load Balancer and Backend Servers?
- Why WebSockets over HTTP/2 (RFC8441) is Critical for Effective Load Balancing and Backend Scaling
- Following an HTTP GET / through Switches, Routers, Gateways, and Proxies (Detailed Examples)
- Slack's Migrating Millions of Websockets from HAProxy to Envoy, lets discuss
- The TLS Handshake Explained with Example (the Math)
- What happens when your Web Server Private Key is Leaked?
- Avoid premature Database Sharding
- Write Amplification Explained in Backend Apps, Database Systems and SSDs
- Securing Backend Applications (OWASP recommendations)
- Can NULLs Improve your Database Queries Performance?
- Why are APIs suddenly so slow?
- HTTP Code 502 Bad Gateway Explained (All its Possible Causes on the Backend)
- The New Postgres 14 Looks Promising - The Backend Engineering Show with Hussein Nasser
- Scaling CPU-intensive Backends - The Backend Engineering Show
- gRPC over HTTP/3 is finally a thing | Backend Engineering Show
- Turns out MySQL Statement-based Replication might not be a good idea, Lets discuss why
- Partial Indexing | The Backend Engineering Show
- Microsoft IIS as a Backend - CPU Throttling in the Application Pool
- The Anatomy of a Proxy Server | The Backend Engineering Show
- KeepAlive | The Backend Engineering Show
- Identifying backend connection latencies with chrome devtools
- SSL Certificate Revocation | The Backend Engineering Show
- TLS and HTTPS Options in Microsoft IIS
- Is ULTRARAM a game changer? | The Backend Engineering Show
- Database page splits | The Backend Engineering Show
- What does it take to break Bitcoin’s encryption? | The Backend Engineering Show
- Accessing SSDs through TCP - NVMe over TCP
- Denial of Service Explained (all types)
- Understanding Aggregate Functions Performance | The Backend Engineering Show
- The limitations of today’s SSDs | The Backend Engineering Show
- Caching is hard
- Why this query is fast
- The Lifecycle of an HTTP Request in NodeJS
- NGINX Internal Architecture - Workers
- django Architecture - Connection Management
- Pinterest moves to HTTP/3
- WebTransport is a Game Changer Protocol
- How does the Kernel manage backend Connections?
- Deep dive on how static files are served with HTTP (kernel, sockets, file system, memory, zero copy)
- Running out of TCP ports
- The Beauty of Assembly
- How many kernel system calls do runtimes make?
- Advanced MySQL Index Locking Explained
- Spin an HTTP/3 Reverse Proxy (using mitmproxy)
- Cloudflare's 150ms global cache purge | Deep Dive
- Backends can now process requests faster now in Linux
- New Course - Node Internals and Architecture
- New Course Alert - Scalable Real-Time Backends with WebSockets
- Load balancing WebSockets Streams efficeintly
- How HTTP/2 frees connections
- Socket Management in Backend System Design