A building block for concurrent programming based on Go's
context (https://golang.org/pkg/context/) solves two important problems
for concurrent programming. First, it provides a mechanism for sharing a safe
cancellation mechanism. Second, it provides a safe abstraction for sharing
values between concurrent execution contexts.
Consider a program which spawns workers concurrently but then wants to terminate
them. The Context package provides a standard building block for providing this.
Now assume the same program encodes values into some protocol mechanism such
as HTTP headers or query parameters for spawned workers to access. The problem
with this is it results in brittleness; if a developer wishes to move some
value from a query parameter to a header, they must chase down every piece
of code that works thusly and edit it. The better approach is to eliminate
protocol details as early in the process of spawning workers entirely, and to
use a protocol-agnostic mechanism like a Context instance to communicate these
values safely to spawned workers.
It is often good practice to not make assumptions about the concurrent environment
library code will be used in, but the Context package only makes sense as a
building block for concurrent development, so it is enabled for safe use
in concurrent environments by default. Context is not recommended as a way
of passing persistent references like DB connection handles etc, instead
it is recommended that Context only be used for request-scope values.
Like the Go equivalent, this library doesn't reduce keystrokes. Indeed, it
increases keystrokes as it implies adopting a new pattern for concurrent