daniel-uzunu
commented
8 years ago A good naming convention should minimize the number of possible names you can use for any given variable, class, method, or function. If there is only one possible name, you'll never have trouble remembering it.
One lesson I heave learned, is that if you can't find a name for a class, there is almost always something wrong with that class: you don't need it, it does too much or it does too little.
The book Code Complete by Steve Mcconnell has a nice chapter on naming variables/classes/functions/...
"There are only two hard things in Computer Science: cache invalidation and naming things." — Phil Karlton
In short: I agree that good names are important, but I don't think you have to find them before implementing at all costs.
Of course its better to have a good name right from the start. But if you can't come up with one in 2 minutes, renaming later will cost less time and is the right choice from a productivity point of view.
Long: Generally it's often not worth to think too long about a name before implementing. If you implement your class, naming it "Foo" or "Dsnfdkgx", while implementing you see what you should have named it.
Especially with Java+Eclipse, renaming things is no pain at all, as it carefully handles all references in all classes, warns you of name collisions, etc. And as long as the class is not yet in the version control repository, I don't think there's anything wrong with renaming it 5 times.
Basically, it's a question of how you think about refactoring. Personally, I like it, though it annoys my team mates sometimes, as they believe in never touch a running system. And from everything you can refactor, changing names is one of the most harmless things you can do.
I want to write an article about why the names are important and how to come up with good names.
https://github.com/daniel-uzunu/daniel-uzunu.github.io/wiki/Naming-Things
Some Ideas
Everyone agrees that it is important to choose good names, but what a good name is varies a lot. In this article, I will try to prove that some general guidelines exist. I should probably start from searching about what makes the code easier to understand. One issue is, that names are only a part of the equation.
In this article, I will focus on guidelines for high-level object-oriented languages (Java, C#, Scala, JavaScript, Python ....). Should I explore naming for functional programming?