Build Your Own Redis Server (Go Edition)

$150

Build Your Own Redis Server (Go Edition)

Course
59 Lessons

This course is still in development, it will be similar in structure to the Python version, but in Go.

Build Your Own Redis in Go is a self-paced online course that teaches you what you need to know to build high-performance servers like Redis using Go, while saving you months (if not years) of learning along the way.

You'll learn network programming, concurrency, test-driven development and performance optimisation.

🎯 No filler content. Concise lessons with practical advice.

🐣No experience writing a server is necessary.

🧑🏽‍💻 Guided coding exercises along the way.

⏳Purchase once, access forever.

🚀 Always up to date.

Buy now

Introduction

Welcome to Become a Better Software Developer by Building Your Own Redis Server!

This course guides you through the steps involved in solving the Redis Coding Challenge from https://codingchallenges.fyi/challenges/challenge-redis in Go.

To get the most out of the course, I suggest you follow through the introductory material in each step then write your own solution.

Once you have done that, you can refer to the model solution if you get stuck or want an example to compare your solution to.

Introduction

How To Use This Course

Learn About Redis

Step 0 - Setting Up

This is software engineering so we’re zero-indexed and for this step you’re going to set your environment up ready to begin developing and testing your solution.

Step Goals

Installing Redis

Setting Up Go

Learn To Use Redis, Redis CLI And Redis Benchmark

Create A GitHub Repo For Your Project.

Step 1 - Introduction to RESP, Building a Protocol Handler Using Test-Driven Development

Introduction to RESP

Introduction to Test Driven Development

Using Test Driven Development to Build a Protocol Handler

Step 1 - Challenge: Protocol Handling

Preview

Step 1 - Solution: Protocol Handling

Step 2 - Creating a Network Client and Server

Introduction To Creating A Network Client And Server

Serialising the RESP Data Types

Building a Simple Redis CLI

Testing the CLI Against Redis

Sample Solution for a Simple Redis CLI

Step 2 - Challenge: Handling PING and ECHO Commands

Preview

Building a Simple Server To Handle Incoming Connections

Responding To The PING And ECHO Commands

Step 2 - Solution: Handling PING And ECHO Commands

Step 3 - Data Structures, Set and Get

Set Up Continuous integration

Step 3 - Challenge: SET and GET

Preview

Adding The Core Data Structure

Handling The Set Command

Handling the Get command

Using the Redis CLI to test Set and Get

Step 3 - Solution: SET and GET

Step 4 - Handling Concurrency

Step 4 - Challenge: Handling Concurrent Clients

Preview

Making The Data Store Thread-Safe

Handling Concurrent Clients With Goroutines

Using The Redis CLI And Redis Benchmark To Test Concurrency

Step 4 - Solution: Handling Concurrent Clients

Step 5 - Implementing Expiry

Introducing The Two Methods Of Expiry

Step 5 - Challenge: Implementing Key Expiry

Updating The Data Store And Set Command Handler Ready For Expiry

Implementing Expire On Read

Implementing Background Expiry

Step 5 - Solution: Implementing Key Expiry

Step 6 - Implementing More Commands

Step 6 - Challenge: Adding More Commands

Preview

Implementing EXISTS and DEL

Implementing INCR and DECR

Implementing LPUSH, RPUSH And LRANGE

Step 6 - Solution: Adding More Commands

Step 7 - Performance

Step 7 - Challenge: Performance Optimisation and Benchmarking

Benchmarking Your Server

How To Optimise For Performance

Preparing To Profile The Server

Profiling The Go Code

Performance Tuning The Server

Step 8 - Persistence

Step 8 - Challenge: Persistence

Persisting The Database

Loading The Database

Step 8 - Solution: Persistence

Closing Remarks

The Complete Final Solution

Going Further

Wrapping Up