Everyone I've worked with agrees that naming matters. Almost nobody spends any time on it. The name gets picked while the code is half written and then it sticks, because renaming feels like fuss once the thing works.
The check I use in review is to read the function name and the parameters and say in one sentence what the call does. If I can do that without opening the body, fine. If I can't, either the name is bad or the function is doing two jobs and no single name will cover it. In my experience it's the second more often than you'd think, so I run this before I look at length or complexity. It finds the same problem earlier.
The best names are the ones the product owner already uses. The worst describe the machinery: process, handle, manager, helper, data. Each is a placeholder for a noun nobody has bothered to find yet. The type should agree with the name too. A parameter called id typed as string takes anything. Call it userId with a UserId type and the call site, the signature and the compiler all say the same thing.
The fair objection is width, and code that borrows abbreviations from the paper it implements. Width is an editor problem. For code that follows a paper, cite the paper next to the module and the abbreviation is the honest name for its readers. For ordinary application code I'd hold the line.
Agents have made me stricter about this. They abbreviate out of habit and it's easy to wave through proc because the prompt said processing. A developer who meets that later opens the body and works it out. An agent takes the name at face value and builds on it, so one lazy name becomes the vocabulary for everything around it.
I write these up at https://prickles.org/tenet/intention-revealing-names/F2 if the longer version is any use.
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 withfor..ofin 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:
I don't really think a variable needs to be redundant with its type. It can just be
idwith the typeUserIdunless there are other variables of the same type in that scope. For example, if there's asellerId, then auserIdcould make sense for the user who is viewing the product (not necesarily buying it), thoughviewerIdcould work there too.I see this a lot in languages that don't support local shadowing. For example:
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:
Note: JS doesn't have local shadowing, of course, so the above won't work