Clean Code

Chapter 17: Smells and Heuristics
the terms from this language extensively. In short, the more you can use names that are
overloaded with special meanings that are relevant to your project, the easier it will be for
readers to know what your code is talking about.
N4: 
Unambiguous Names
Choose names that make the workings of a function or variable unambiguous. Consider
this example from FitNesse:
private String doRename() throws Exception
{
if(refactorReferences)
renameReferences();
renamePage();
pathToRename.removeNameFromEnd();
pathToRename.addNameToEnd(newName);
return PathParser.render(pathToRename);
}
The name of this function does not say what the function does except in broad and vague
terms. This is emphasized by the fact that there is a function named 
renamePage
inside the
function named 
doRename
! What do the names tell you about the difference between the
two functions? Nothing.
A better name for that function is 
renamePageAndOptionallyAllReferences
. This may
seem long, and it is, but it’s only called from one place in the module, so it’s explanatory
value outweighs the length. 
N5: 
Use Long Names for Long Scopes
The length of a name should be related to the length of the scope. You can use very short
variable names for tiny scopes, but for big scopes you should use longer names.
Variable names like 
i
and
j
are just fine if their scope is five lines long. Consider this
snippet from the old standard “Bowling Game”:
private void rollMany(int n, int pins)
{
for (int i=0; ig.roll(pins);
}
This is perfectly clear and would be obfuscated if the variable 
i
were replaced with some-
thing annoying like 
rollCount
. On the other hand, variables and functions with short names
lose their meaning over long distances. So the longer the scope of the name, the longer and
more precise the name should be.