CourseFlix

Redis Internals

9h 6m 41s
English
Paid

This is a self-paced course where you will explore the internal workings of Redis by reimplementing its key features in Golang. Together, we will recreate mechanisms such as the event loop, serialization protocol, persistence, pipelining, eviction, and transactions.

Redis is one of the most versatile modern databases. Although it is often used as a cache, it can also function as a message broker, streaming engine, and much more. This course will answer your main questions about Redis: why is it so fast? and how does it handle a huge number of TCP connections while remaining single-threaded?

Throughout the course, we will deconstruct Redis step by step, and in the process, we will write its full implementation in Go. The implementation will be compatible with any Redis client in the world - you will be able to connect to our database just like with the real Redis! All the code is available in open access on GitHub (DiceDB/dice).

Why enroll?

  • Understand the architecture from the inside
    • You will learn how databases are created from scratch and understand the key architectural decisions that make Redis so unique.
  • Explore the "unknown"
    • Master the most intriguing concepts and "tricky" algorithms that underlie the high speed and flexibility of Redis.
  • Become a better engineer
    • You will grow as a developer and be able to call yourself a true "Asli Engineer."

Participant Requirements

We will be implementing the main mechanisms of Redis, such as the event loop, serialization protocol, persistence, pipelining, and eviction. Therefore, it is important to have:

  • basic knowledge of Go
  • a development environment on Linux
  • a Google account (as only Google sign-in is supported)

Additional

https://github.com/dicedb/dice

About the Author: Arpit Bhayani

Arpit Bhayani thumbnail

Arpit Bhayani is a US-based software engineer (formerly at Amazon, Practo, and now an independent educator) who runs asliengineering.com and the Arpit Bhayani YouTube channel, both focused on system design and database internals. His material is unusually deep for the system-design-interview market — taking serious detours into the actual implementation of Redis, Postgres, and the data structures behind them.

His CourseFlix listing carries three Arpit Bhayani courses: The System Design Masterclass, Redis Internals (an end-to-end study of how Redis is implemented in C), and System Design for Beginners. Material is paid and aimed at engineers preparing for system-design interviews or doing infrastructure work on production data systems.

Watch Online 28 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 28 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Course Introduction
All Course Lessons (28)
#Lesson TitleDurationAccess
1
Course Introduction Demo
10:55
2
What makes Redis special?
22:04
3
Writing a Simple TCP Echo Server
16:25
4
Speaking the Redis' Language
15:50
5
Implementing RESP
14:38
6
Implementing PING
19:29
7
IO Multiplexing and Event Loops
21:15
8
Handling multiple concurrent clients
26:29
9
Implementing GET, SET, and TTL
22:09
10
Implementing DEL, EXPIRE and auto-deletion
27:23
11
Eviction strategies and implementing simple-first
20:24
12
Implementing Command Pipelining
22:00
13
Implementing AOF Persistence
21:05
14
Object, Encodings, and Implementing INCR
24:48
15
Implementing INFO and allkeys-random eviction
19:37
16
The Approximated LRU Algorithm
23:15
17
Implementing the Approximated LRU Algorithm
25:27
18
Understanding how Redis caps memory
13:20
19
Overriding malloc for better performance
06:11
20
Implementing Graceful Shutdown
37:18
21
Implementing Transactions
22:00
22
List Internals - Ziplist and Quicklist
28:16
23
Set Internals - Intset
13:25
24
Geospatial Queries and Geohash
21:39
25
String Internals - Simple Dynamic Strings
15:56
26
Hyperloglog and Cardinality Estimation
13:22
27
LFU and Approximate Counting
20:49
28
What next?
01:12
Unlock unlimited learning

Get instant access to all 27 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Course content

28 lessons · 9h 6m 41s
Show all 28 lessons
  1. 1 Course Introduction 10:55
  2. 2 What makes Redis special? 22:04
  3. 3 Writing a Simple TCP Echo Server 16:25
  4. 4 Speaking the Redis' Language 15:50
  5. 5 Implementing RESP 14:38
  6. 6 Implementing PING 19:29
  7. 7 IO Multiplexing and Event Loops 21:15
  8. 8 Handling multiple concurrent clients 26:29
  9. 9 Implementing GET, SET, and TTL 22:09
  10. 10 Implementing DEL, EXPIRE and auto-deletion 27:23
  11. 11 Eviction strategies and implementing simple-first 20:24
  12. 12 Implementing Command Pipelining 22:00
  13. 13 Implementing AOF Persistence 21:05
  14. 14 Object, Encodings, and Implementing INCR 24:48
  15. 15 Implementing INFO and allkeys-random eviction 19:37
  16. 16 The Approximated LRU Algorithm 23:15
  17. 17 Implementing the Approximated LRU Algorithm 25:27
  18. 18 Understanding how Redis caps memory 13:20
  19. 19 Overriding malloc for better performance 06:11
  20. 20 Implementing Graceful Shutdown 37:18
  21. 21 Implementing Transactions 22:00
  22. 22 List Internals - Ziplist and Quicklist 28:16
  23. 23 Set Internals - Intset 13:25
  24. 24 Geospatial Queries and Geohash 21:39
  25. 25 String Internals - Simple Dynamic Strings 15:56
  26. 26 Hyperloglog and Cardinality Estimation 13:22
  27. 27 LFU and Approximate Counting 20:49
  28. 28 What next? 01:12

Related courses

  • Go in Practice, Second Edition thumbnail

    Go in Practice, Second Edition

    By: Matt Butcher, Matt Farina, Nathan Kozyra
    "Go in Practice: Second Edition" is a collection of recipes containing techniques and best practices for creating industrial-grade applications in Go.
  • Design Patterns in Go thumbnail

    Design Patterns in Go

    By: Udemy
    This course provides an overview of all the Gang of Four (GoF) design patterns as outlined in their seminal book, together with modern-day variations.
    9 hours 47 minutes 37 seconds
  • Build a Google Analytics in Go thumbnail

    Build a Google Analytics in Go

    By: Dominic St-Pierre
    This course assumes you've taken my Build SaaS apps in Go course or are familiar with Go's standard library for building web applications.
    7 hours 18 minutes 48 seconds 5 / 5

Frequently asked questions

What is Redis Internals about?
This is a self-paced course where you will explore the internal workings of Redis by reimplementing its key features in Golang. Together, we will recreate mechanisms such as the event loop, serialization protocol, persistence, pipelining…
Who teaches Redis Internals?
Redis Internals is taught by Arpit Bhayani. You can find more courses by this instructor on the corresponding source page.
How long is Redis Internals?
Redis Internals contains 28 lessons with a total runtime of 9 hours 6 minutes. All lessons are available to watch online at your own pace.
Is Redis Internals free to watch?
Redis Internals is part of CourseFlix's premium catalog. A CourseFlix subscription unlocks the full video player; the course description, table of contents, and preview information are available to everyone.
Where can I watch Redis Internals online?
Redis Internals is available to watch online on CourseFlix at https://courseflix.net/course/redis-internals. The page hosts every lesson with the integrated video player; no download is required.