Me and a friend of mine had a common understanding of what we called "2 lines of defense aganinst F12":

1. First line: member signature (name, returned type, arguments).
2. Second: documentation.

If these 2 do not provide sufficient defense against anyone pressing F12 (Go To Definition in IntelliJ-based IDEs) - we have failed.

It's sometimes tough to come up with specific nouns, but it's well worth the effort

This is a bit reductive. Scope and visibility matter. A private function called by precisely two implementers within the same package doesn’t need to do heavy lifting on naming. It can be short; in fact I’d argue that it should be. Contributors working on the package can scan the code more quickly and will already know what is happening in that scope. Same for variable names.

On the contrary, publicly consumed functions called across maybe hundreds of scopes should be crystal clear in the name, maybe even largely implying the contract.

But even those probably have exceptions. So while I agree that names should be thoughtfully considered, one shouldn’t take the “name and parameters should tell all” axiomatically. It’s not so simple.

I like descriptive names, to a point. I'd rather have a slightly ambiguous name with a more descriptive sentence in the docs that I can see at the call site via LSP than a super long function name.

The worst names I've seen are too long to be useful, too short to be understood, or tied to some specific vendor or framework or something that never gets changed when that entity is long gone.

Thanks for sharing your though.

I think also that naming is an underused super power. It's also difficult to do it well at the first try.

For variables, my favorite name is i. It doesn't tell you what it is without prior knowledge that it's probably an index, it doesn't tell you what it's an index of, it doesn't tell you which direction, if any, the index is moving in, and it's probably not necessary and can be replaced with direct iteration over the collection (like with for..of in JS). And yet it's somehow an extremely popular variable name.

On that note, I have a minor nit about your post, though it's mostly pedantry:

Call it userId with a UserId type and the call site, the signature and the compiler all say the same thing.

I don't really think a variable needs to be redundant with its type. It can just be id with the type UserId unless there are other variables of the same type in that scope. For example, if there's a sellerId, then a userId could make sense for the user who is viewing the product (not necesarily buying it), though viewerId could work there too.

I see this a lot in languages that don't support local shadowing. For example:

const fooStr = getSomeString();
const fooInt = parseInt(fooStr, 10);
const foo = foos[fooInt];

With local shadowing (or local redefinition in the case of a language like Python), you can use the same name if it remains the most descriptive and the old value is being dropped/"moved" anyway:

const fooIndex = getSomeString();
const fooIndex = parseInt(fooIndex, 10);
const foo = foos[fooIndex];

Note: JS doesn't have local shadowing, of course, so the above won't work

functionOne, functionTwo....