Why this is not enough?

package mycontext

import "context"

var Root = context.Background

Use:

mycontext.Root()

Yes, getting rid of Background would be extremely painful, but adding Root and then deprecating Background is straightforward if we think that is a good idea. Retitled the proposal.

CC @Sajmani

@changkun, I appreciate the consideration. There remain two suboptimal points that would need be solved, however:

1. It is at best a local-optimization, which means it cannot be applied to the overall Go ecosystem as a whole. The whole of Go deserves this improvement; and for me personally in my day job, not one project needs this but rather a uncountable panoply of independent projects.
2. It presents a fragmented solution, which means it is not universally discoverable. Users will wonder which to use or know about one and not the other, which is exacerbated by the existence of two construction functions in separate packages for such a intrinsic ecosystem API.

@ianlancetaylor, I had given consideration to exactly what you propose as well. If you folks are OK with it, I would be as well. The deprecation protocol is well enough understood these days to do the change.

This is the first I'm hearing that context.Background is a confusing name. While I appreciate the brevity of context.Root, I expect the confusion that will arise from such a renaming far outweighs the benefit.

"background context" is definitely an idiomatic phrase in American English, meaning basically "how we got to this point". There's no sense that there can only be one of these, whereas Root carries an implication that a programmer should only have a single "root" context from which all other contexts in their application derive, which, while appropriate in some circumstances, seems too prescriptive. I think making this change now would only serve to churn code and tutorials for no real appreciable benefit.

context.Background is already a synonym for context.TODO. Is adding a third alias going to make a meaningful improvement?

context.Background is already a synonym for context.TODO

How do you figure?

context.Background is already a synonym for context.TODO

How do you figure?

Oh dear. Please accept my apologies, I had in my mind that one called the other, perhaps it did at one point in the past, but that is no correct. https://cs.opensource.google/go/go/+/master:src/context/context.go;l=208

I'm very confused about this.
Why would people misuse/overuse Root any less frequently than they misuse/overuse Background?
More generally, there's already a name that people know and that has been used in books, blog posts, and so on.
The bar for just changing to a new name is pretty high. I don't see the evidence for that here.

This proposal has been added to the active column of the proposals project
and will now be reviewed at the weekly proposal review meetings.
— rsc for the proposal review group

Based on the discussion above, this proposal seems like a likely decline.
— rsc for the proposal review group

In terms of broad strokes, my ideal preference would be to rename the API in the so-called Go 2 (in other words, removing the name Background from package context). That said, there may be a few incremental improvements that can be made in the intervening time, inexhaustively:

• alias API (duplication) — as Ian mentions, which can be done before a Go 2.
• documentation improvements — we could make the package's documentation more concrete.

I think the temporal aspect of when what should be done is confounding the discussion.

In terms of measuring confusion and misuse, I did some examination of our monorepo and comments that were made in code review. We've internally had guidance about avoiding extraneous background context usage in non-roots for about 18 months. In that time, code reviewers flagged about 2,500 instances erroneous context.Background usages.

Why would people misuse/overuse Root any less frequently than they misuse/overuse Background?

Everything's in the name. As I outlined in the opening description, "background" doesn't have a particularly clear meaning nor implication nor insinuation that it is — well — the root from which all things are derived (the very beginning). For better or for worse, in the domain of computing, root is an unambiguous and established term. My expectation is that with a better name developers would think twice: is this place (where I am using the context API) really the root of the operation?

What was the erroneous use? That they should have been using a context that had been passed to them? I don't see how renaming it helps that case.

There are numerous problem classes in descending order of frequency:

1. Defining greenfield functions where instead of accepting a context parameter, the function locally defines a context inside of it. Most of these new functions would be called in a place where the caller would already have a context and want to control deadline and interruption semantics in addition to using the context for side-channel data passing (e.g., tracing).

   // being added right now
   func greenfield() (*T, error) {
     ctx := context.Background()
     ...
   }
   
   // old code
   func brownfield(ctx context.Context) {
     t, err := greenfield()
     ...
   }

   Instead this code should look like this:

   // being added right now
   func greenfield(ctx context.Context) (*T, error) {
     ...
   }
   
   // old code
   func brownfield(ctx context.Context) {
     t, err := greenfield(ctx)
     ...
   }

This item is self-standingly concerning one.

2. Detachment from a parent context and continuing an operation out-of-band

   proposal: context: add API for performing tasks after Context is Done #19643

   context: add WithoutCancel #40221

   This one can be handled through the above proposals, but it's a specialization.

3. Ignoring that a local context (e.g., function parameter) already exists and calling context.Background to create another.

   func careless(ctx context.Context) {
     ...
     f(context.Background())  // woops; should have used ctx
     ...
   }

Will leave this open for another week, but I still don't see any significant inherent difference between the words Background and Root. Neither is terribly meaningful on its own. They will have the meaning we assign to them in docs and such.

No change in consensus, so declined.
— rsc for the proposal review group