System Design Course

Name: System Design Course
Price: 9 USD
Availability: InStock

92h 26m 21s

English

Paid

March 28, 2024

In this course, you’ll get a deep understanding of system design concepts. Full guide. Architectural schemes, capacity planning, API list, tests, Faq.

On the course

Design a gmail-like mail system
- routing client to server
- We’re looking at services
- authorized queries
- Caching
- decapling
Design an algorithm for an audio search engine like Shazam
- mapping audio in key-values
- pruning, transformation and chanking
- Combinator’s hashes
- Saving and Finding Heshovs
Rate-limiting algorithms
- short-term fixes
- distributed rate limiting
- algorithms – sliding window, timer wheel
- separating queues
- Real optimization
Designing a call system. as whatsapp
- PSTN and VOIP
- Sip
- charging users for a call
- recommendation engine

Watch Online System Design Course

Join premium to watch

Go to premium

#	Title	Duration
1	What do we offer?	03:15
2	What are Databases?	04:40
3	Storage and Retrieval	04:25
4	What is a NoSQL database?	02:25
5	Types of Databases: Graph, TimeSeries and Object	02:16
6	What database should you choose?	02:13
7	What is Data Consistency?	01:31
8	Linearizable Consistency	03:14
9	Eventual Consistency	01:51
10	Causal Consistency	04:36
11	Quorum	06:30
12	Data Consistency Levels Tradeoffs	02:01
13	Transaction Isolation Levels - Read Uncommitted Data	03:13
14	Read Committed	03:44
15	Repeatable Reads	05:20
16	Serializable Isolation Level	02:01
17	Transaction Level Implementations	03:39
18	Conclusion - Transaction Isolation	00:52
19	Caching: Basics	06:29
20	Caching: Global vs. Local Cache	03:03
21	Global Cache Internals	06:32
22	Write Policies: Write Back Policy	04:36
23	Write Through Policy	02:34
24	Write Around Policy	03:24
25	Replacement Policies: LRU, LFU and Segmented LRU	11:15
26	Breakdown: The physical layer	02:59
27	Breakdown: The Routing Layer	03:20
28	Breakdown: The behavioral layer	04:40
29	Connecting to the internet: ISPs, DNS and everything in between	07:29
30	Internal routing: MAC addresses and NAT	06:53
31	HTTP, WebSockets, TCP and UDP	08:51
32	Communication Standards: REST, GraphQL and GRPC	07:18
33	Head of line blocking	05:16
34	Video transmission: WebRTC and HTTP-DASH	10:09
35	Primary Replica Architectures	03:07
36	WAL and Change Data Capture	04:02
37	Write Amplification and Split Brain	04:04
38	Database Migrations	10:12
39	Migrating the Database	07:50
40	Migration Across Regions	11:24
41	The Oracle and the Timer Wheel	15:54
42	Partitioning and Real-life Optimisations	11:43
43	Security aspects in distributed systems	03:46
44	Token Based Auth	09:11
45	SSO and OAuth	05:02
46	Access Control Lists and Rule Engines	06:21
47	Attack Vectors - Hackers, Developers and Code	04:53
48	How videos are protected inside CDNs	06:32
49	Design an algorithm for an Audio Search Engine	10:36
50	Introduction to design tradeoffs	03:59
51	Pull vs. Push Architectures	12:21
52	Memory vs. Latency	01:44
53	Throughput vs. Latency	08:42
54	Consistency vs. Availability	05:50
55	Latency vs. Accuracy	06:35
56	SQL vs. NoSQL databases	05:49
57	Relations Between Tradeoffs	06:02
58	The Problem of Distributed Consensus	05:29
59	Basic Algorithm	07:47
60	Improving the algorithm	02:58
61	Termination Conditions	07:17
62	Practical Considerations	03:37
63	Introduction to Observability	01:01
64	Logging - Best Practices	02:10
65	Monitoring Metrics	01:27
66	Anomaly Detection: Holt-Winters Algorithm	07:13
67	Root Cause Analysis	04:09
68	Conclusion to Observability	00:37
69	Scope and Requirement setting	00:22
70	Chapter #1: Service Registration and Proxies	14:32
71	Chapter #2: Authentication & Global Caching	09:27
72	Chapter #3: API contracts & Versioning	09:24
73	Chapter #4: Sending, Tagging & Searching Emails	06:05
74	Chapter #5: Contacts & Groups	07:18
75	Requirements of a chess website	11:37
76	Handling connections at scale	13:54
77	Consistent Hashing vs. Sharding	10:14
78	Connection related thundering herds	04:31
79	Request Batching and Conclusion	05:14
80	Live Streaming Requirement Breakdown	05:18
81	Video Ingestion and Transformation	05:09
82	Transferring processed videos to end users	07:55
83	Virtual Advertising for live sports events	07:20
84	Google Docs Requirements	05:53
85	Document Schema	05:42
86	Storing Documents	03:11
87	Version History	05:35
88	Avoiding Thundering Herds in Crons	03:12
89	Compression and Caching	02:48
90	Concurrent Writes with Locks	08:21
91	Operational Transform Overview	07:48
92	Permission Management	06:15
93	Requirements of a cab aggregator	06:43
94	Static Pricing of Rides	08:43
95	Ride Matching	09:05
96	Calculating Estimated Time of Arrival	12:26
97	Matching Drivers with Live Rides	09:53
98	Requirements of a Map application	08:11
99	Routing Challenges in Maps	06:47
100	Partitioning Algorithm: Splitting the graph into regions	05:12
101	Finding the shortest path - A* search	07:39
102	GeoHash and other proximity filters	06:26
103	Detecting traffic jams and broadcasting updates	09:46
104	Calculating an accurate and efficient estimated time of arrival	09:56
105	Calling App Design	14:13
106	Concept #1: Breaking calls into dialogs	06:58
107	Concept #2: The state machine	03:23
108	Concept #3: Charging Users	04:03
109	Concept #4: Consistent Hashing for caching call state	06:19
110	Converting data sources to a lake	06:04
111	The Map Reduce Architecture	03:33
112	Fault tolerance and engineering optimizations	03:04
113	Real time analytics	05:44
114	Ranking restaurants in real time and batch	02:53
115	Introduction to Low Level Design Series	02:22
116	The need for good coding practices	04:08
117	Setting Requirements and Objects	13:05
118	API and Package Structuring	09:51
119	Parent vs. Base class functions	04:09
120	Setting the main method	03:23
121	Debugging the code	09:34
122	Defining responsibilities of AI and Game classes	09:45
123	Unit Tests	05:53
124	Benefits of Single Responsibility Principle	05:01
125	Looking for a Smart AI	05:41
126	The need for stateless move exploration	07:29
127	Prototype Design Pattern	13:30
128	DRY: Dont Repeat Yourself	15:12
129	Iterator Design Pattern	07:23
130	DRY: Extracting Common Pieces	06:56
131	New feature request: Find Forks!	12:10
132	Building a Rule Engine	08:55
133	Builder Design Pattern	06:56
134	Summary: Open-Closed Principle	00:50
135	New feature request: Timers!	08:01
136	Encapsulating responsibilities in objects	10:08
137	Extracting Nested Objects	12:32
138	Having Multiple AI personalities	11:31
139	Singleton and Null Object Design Pattern	09:05
140	Chain of Responsibility Pattern	11:41
141	Interface Segregation Principle	04:20
142	Dependency Inversion Principle	02:58
143	New feature request: Undo Moves with Momento!	10:40
144	Proxy and Flyweight Design Pattern	10:22
145	The Labyrinth: Five Level Deep For-Loops!	10:24
146	State and Strategy Design Pattern	06:43
147	Writing Tests for Timed Games	05:06
148	Factory Design Pattern	09:15
149	Unit Tests and Object Pools	08:34
150	Setting Timed Test Cases	05:23
151	Fixing bugs in Game Logic and Factories	15:46
152	Strategy Design Pattern: Implementation and Benefits	12:44
153	New Feature: Email Notifications	13:03
154	Inheritance vs. Composition	06:36
155	The Publisher Subscriber Model	16:21
156	Problem Statement	03:39
157	Defining objects states and behaviors	10:58
158	Simplified Balances algorithm	05:35
159	APIs and coding requirements	05:32
160	Low Level Design	03:25
161	Coding: Building the service skeleton and defining objects	10:23
162	Coding: Algorithm	04:10
163	Coding: Test cases	06:06
164	Conclusion and Tips	03:03
165	#1: Caching: Engineering requirements	05:24
166	#2: Read your own writes	04:14
167	#3: Defining the core requirements	02:12
168	#4: Asynchronous processing: Keeping threads available	05:16
169	#5: View Consistency through thread assignment	06:14
170	Code #1: Code skeleton for 'Get' and 'Set'	16:59
171	Code #2: Setting up fast evictions	13:27
172	Code #3: Thread Assignment and updating GET + SET	12:59
173	Code #4: Hot loading and Request Collapsing	09:28
174	What is an event bus?	01:23
175	Breaking down engineering requirements	09:56
176	The mechanics of the bus	04:43
177	Why use threads?	04:14
178	Code Skeleton and using an extensible Retry Algorithm	12:20
179	The Keyed Executor	06:14
180	Pull and Push Subscribers	06:56
181	Defining the data structures in the bus	04:00
182	Wrapper Classes	08:26
183	Coding the tests	19:46
184	Conclusion	12:36
185	What will you learn	06:09
186	Rate Limiter Overview	06:51
187	Implementation Details	10:20
188	API Breakdown	09:34
189	Models, Controllers, Packages and ThreadPools	12:01
190	Reading and Writing Data	15:47
191	RateLimiter Client Setup	11:24
192	Sliding Window Algorithm Setup	07:19
193	Dependency Inversion	08:29
194	Sliding Window with Backpressure	10:06
195	Clearing Stale Entries in Sliding Window	05:15
196	January 2022: Datastores and their Tradeoffs	01:15:47
197	March 2022: Threads and Request Collapsing	01:39:28
198	April 2022: Chess Low Level Design	02:00:09
199	May 2022: Message Queues	01:35:28
200	June - Design a Payment System	01:43:41
201	July - Caching, Paxos and Zookeeper	01:23:36
202	Data Corruption and Alerts Monitoring	01:46:47
203	Caching: Doubts and Clarifications	01:40:08
204	August - Database Doubts	01:51:11
205	Design a subscription manager	01:37:45
206	Rule Engines	01:42:15
207	October - Kafka Internals	02:09:44
208	October 2022 - Implementing a File System	01:50:58
209	Pessimistic and Optimistic Locking	01:52:31
210	Producers and Consumers: November Meet	01:00:10
211	IRCTC Algorithm: December	01:07:32
212	Google Docs and Chess Design Queries	01:40:39
213	Jan 2023: DNS, CDNs, and everything in between	01:57:57
214	Jan 2023: API design and other discussions	01:07:09
215	Feb 2023: Permission Management System	01:26:21
216	March 2023: Eventual Consistency Levels	01:27:17
217	March 2023: Fetch top K hits in a distributed system	01:04:07
218	April 2023: Distributed Consensus and Load Balancing	02:01:05
219	April 2023: Graph Databases with Facebook TAO	01:33:43
220	May 2023: The SideCar Pattern	02:10:47
221	May 2023: Permission Management	01:33:49
222	June 2023: Clients, Comments and APIs	01:56:24
223	July 2023: Design an Event Handler	01:37:40
224	July 2023: Highly Scalable Concurrent Booking Systems	02:06:59
225	August 2023 - Google Calendar Low-Level Design	01:44:01
226	August 2023 - Designing IRCTC	01:22:05
227	September - Design Judge Launch	01:47:38
228	September - Tech in a startup	02:15:24
229	October - Live Watch Party Design	02:08:19
230	November - Memcached Reading	01:57:21
231	November - Memcached Revision	02:05:42
232	December: Memcached Paper Reading - 2	02:19:30
233	Monoliths vs Microservices	07:42
234	Horizontal vs Vertical Scaling	07:53
235	Load Balancing	10:14
236	An introduction to distributed systems	08:42
237	Single Point of Failure	06:00
238	Sharding	08:56
239	Service discovery and Heartbeats	05:30
240	Capacity Planning and Estimation: How much data does YouTube store daily?	13:12
241	Content Delivery Networks	11:09
242	API Design Goals	06:22
243	API Design in Practice	08:57
244	The Message Queue: Problem Statement	04:09
245	Asynchronous processing: benefits	05:35
246	Publisher Subscriber Models	11:21
247	Event Driven Architectures	03:36
248	Event Driven Architectures - Advantages	04:57
249	Event Driven Architectures - Disadvantages	05:44
250	Distributed data consistency	05:58
251	Data Consistency across Continents	05:14
252	Leader-follower architectures	04:58
253	Tradeoffs - 2 phase commit protocol	09:31
254	Difference between SQL and NoSQL	09:47
255	Cassandra Internals	07:35
256	Quorom	03:14
257	Write Heavy DB Design	05:29
258	Write Heavy DB Design - Merging Sorted String Tables	05:05
259	Write Heavy DB Design - Query optimisations	06:45
260	Location Representation	08:17
261	Data Structure - Quad Tree	01:51
262	Range Queries and Hilbert Curve	12:00
263	Motivation	06:25
264	Infrastructure Requirements	06:38
265	Practical considerations	05:17
266	Containers: A friendly Introduction	01:49
267	Containers: Usecases	05:36
268	System Requirements	02:49
269	One to one messaging	08:13
270	Last Seen Timestamps	03:39
271	Group Messaging	10:13
272	Requirements	03:57
273	Image Storage: Files vs. Database BLOB	06:49
274	Profile Creation and Authentication	05:48
275	One to One chat messaging	05:08
276	Matching right-swiped users	03:19
277	Serving recommendations to users	08:41
278	Requirements	02:52
279	Designing the Data Schema	06:04
280	Following Users	02:17
281	User Feed Service	05:25
282	Scaling the Instagram news feed	06:15
283	Anomaly Detection	07:26
284	Video Processing	06:11
285	ISP Synergy	04:19
286	System Design Tips	07:37
287	Dos and Don'ts	06:35
288	Online Judge	07:46