Build your own Redis: RESP over raw TCP

+OK\r\n                    simple string
-ERR unknown command\r\n   error
:42\r\n                    integer
$5\r\nhello\r\n            bulk string: length, then bytes
$-1\r\n                    null bulk string
*2\r\n$4\r\nECHO\r\n$2\r\nhi\r\n   array of two bulk strings

*3\r\n$3\r\nSET\r\n$4\r\nname\r\n$3\r\nAda\r\n

func Serve(ln net.Listener, db *Store) error {
    for {
        conn, err := ln.Accept()
        if err != nil {
            return err
        }
        go handle(conn, db)
    }
}

func handle(conn net.Conn, db *Store) {
    defer conn.Close()
    r := bufio.NewReader(conn)
    w := bufio.NewWriter(conn)

    for {
        args, err := readCommand(r)
        if err != nil {
            if err != io.EOF {
                writeError(w, "ERR "+err.Error())
                w.Flush()
            }
            return
        }
        execute(db, args, w)

        // Flush only when nothing more is buffered: that is what
        // makes pipelining fast rather than chatty.
        if r.Buffered() == 0 {
            w.Flush()
        }
    }
}

func readCommand(r *bufio.Reader) ([]string, error) {
    line, err := readLine(r)
    if err != nil {
        return nil, err
    }
    if len(line) == 0 {
        return nil, errors.New("protocol error: empty line")
    }
    if line[0] != '*' {
        // Inline command, what you get from telnet.
        return strings.Fields(string(line)), nil
    }

    n, err := strconv.Atoi(string(line[1:]))
    if err != nil || n < 0 {
        return nil, errors.New("protocol error: bad multibulk")
    }
    args := make([]string, 0, n)
    for i := 0; i < n; i++ {
        s, err := readBulk(r)
        if err != nil {
            return nil, err
        }
        args = append(args, s)
    }
    return args, nil
}

func readBulk(r *bufio.Reader) (string, error) {
    line, err := readLine(r)
    if err != nil {
        return "", err
    }
    if len(line) == 0 || line[0] != '$' {
        return "", errors.New("protocol error: expected $")
    }
    n, err := strconv.Atoi(string(line[1:]))
    if err != nil || n < 0 || n > maxBulk {
        return "", errors.New("protocol error: bad bulk length")
    }
    buf := make([]byte, n+2)          // payload plus CRLF
    if _, err := io.ReadFull(r, buf); err != nil {
        return "", err
    }
    return string(buf[:n]), nil
}

type Store struct {
    mu   sync.RWMutex
    data map[string]entry
}

type entry struct {
    value   string
    expires time.Time         // zero means never
}

func (s *Store) Get(key string) (string, bool) {
    s.mu.RLock()
    e, ok := s.data[key]
    s.mu.RUnlock()

    if !ok {
        return "", false
    }
    if !e.expires.IsZero() && time.Now().After(e.expires) {
        s.Delete(key)              // lazy expiry
        return "", false
    }
    return e.value, true
}

type command struct {
    arity   int               // -N means "at least N"
    handler func(*Store, []string, *bufio.Writer)
}

var commands = map[string]command{
    "ping":   {1, cmdPing},
    "echo":   {2, cmdEcho},
    "set":    {-3, cmdSet},
    "get":    {2, cmdGet},
    "del":    {-2, cmdDel},
    "exists": {-2, cmdExists},
    "incr":   {2, cmdIncr},
    "expire": {3, cmdExpire},
    "ttl":    {2, cmdTTL},
    "keys":   {2, cmdKeys},
    "command": {-1, cmdCommand},
}

func cmdIncr(s *Store, args []string, w *bufio.Writer) {
    s.mu.Lock()
    defer s.mu.Unlock()

    e := s.data[args[1]]
    n, err := strconv.ParseInt(e.value, 10, 64)
    if e.value != "" && err != nil {
        writeError(w, "ERR value is not an integer or out of range")
        return
    }
    n++
    e.value = strconv.FormatInt(n, 10)
    s.data[args[1]] = e
    writeInteger(w, n)
}

go run . &                      # your server on :6380

redis-cli -p 6380 ping
redis-cli -p 6380 set name Ada
redis-cli -p 6380 get name
redis-cli -p 6380 incr counter

redis-benchmark -p 6380 -t set,get -n 100000 -q
redis-benchmark -p 6380 -t set,get -n 100000 -P 100 -q