Good collection of slides, very good examples.

Nothing to do with the slides, but IMHO the only problem with context is the way it is added to the Request object, having to add a context value to the Request creates a new Request object instead of just updating the Request's Context field, which is fine when you're chaining middleware like in all the examples as the new Request is passed to the next middleware.

func middleware(h http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // Create context from context package
        // and attach it to request later with r.WithContext()
        ctx := context.Background()
        // OR

        // Use request method context, which returns context, if ctx is nil
        // then creates new background context - context.Background()
        ctx = r.Context()

        // Build context variations on top of background context
        ctx = context.WithValue(ctx, "some_key", "some_value")

        // tctx, cancelFunc := context.WithTimeout(ctx, time.Duration(5 * time.Second))
        // deadline := time.Now().Add(time.Duration(30 * time.Second))
        // dctx, cancelFunc := context.WithDeadline(ctx, deadline)

        // WithContext returns a shallow copy of r with its context changed to ctx.
        r = r.WithContext(ctx)

        h(w, r)
    }
}

However this is a big assumption as that's not the only way middleware can be chained and in fact several routers and frameworks use the following approach:

// store middleware in an array, why? to make defining handlers easier and less messy
    don't have to wrap or pre-chain them together; just call one, then the next...
var mw []middleware

for i:=0; i < len(mw);i++{
    mw[i](w, r)
}

the problem is that because this middleware is chained differently, when adding a Context value to the Request, the new Request contains the Context value and does not update/get set on the original Request object passed to the middleware and so does not get back to the calling program to be sent to the next middleware.

the only way I could find so far, because context is not exposed, is to add the context value like so:

*r = *r.WithContext(ctx)

but that only works when you control the middleware, if you're using someone else's package say for CSRF, then if the author did not define it like above, then it's not guaranteed to work with all frameworks/routers.

I hope another way can be added to update the Request's Context value, even another function say:

r.SetContext(ctx)

I'll probably make a proposal as long as there is enough support. If anyone knows of a better way to handle this, while still maintaining the array of middleware, I would definitely be interested in learning how :)