One of our most frequent tasks as programmers is assigning names. It’s hard to go an hour without coming up with a name for a class, a method, or a variable. But naming things is hard for at least two reasons:
- The exact purpose of an item might be not be clear until you’ve written its body or used it in context. I often use a clearly inappropriate placeholder that will force me to replace it once I have a good name.
- Picking appropriate words is tough. It can be hard to spend time selecting the right word when you’re focused on writing logic, but often the work of naming will help clarify that logic’s organization.
Here are some suggestions for naming rules, born from recent experiences.
Rule: reflect the usage and context
A name is the first and most important way a reader will determine what something does, and whether it’s the appropriate something to use.
If a class has a very specific context in which it’s useful, reflect that context in the name or its containing package. On the other hand, think forward to future uses of a class, and don’t unnecessarily restrict it to Foos by calling it FooEngine when it might also be useful for Bars.
Rule: influence the named object’s scope
Names can act as a valuable indicator that the scope of a class or method has grown too big. If a good name doesn’t seem to comprise the full functionality any more, or conversely the functionality is suggesting a name that involves too many steps, then consider factoring out some of that functionality.
A class named SearchEngine that’s also used to retrieve user configured paths needs to be refactored into at least two classes. A method named ValidateUpdateNotify (or more problematically, Process) should actually be three separate methods.
Rule: name length is inversely proportional to usage frequency
The more frequently a name will be used, the shorter it can and should be. The length and obscurity of names impacts how other developers use the named objects. In the following comparison, split is idiomatic, familiar, easy to read, and easy to remember; componentsSeparatedByString is much less so:
'a b c'.split(' ')
# Objective C
[@"a b c" componentsSeparatedByString:@" "]
Apple’s very long method names such as tableView:accessoryButtonTappedForRowWithIndexPath: have a clear benefit of being self-documenting and are appropriate for less frequently used API classes. But for the more common classes and methods in a language, API, or project, they add an unnecessary burden to the developer.
Rule: unique names are searchable names
If you ever need to refactor a widely used method or search the git commit history for the introduction of a variable, you’ll be grateful if the name is unique. For example, name a class PurchaseOrder or JobOrder rather than Order, which will easily be confused with sorting or other meanings for the word.
Rule: alphanumeric names are Googleable names
Rule: rename when necessary
In many cases, it’s hard to get a name right the first time, particularly when requirements or architecture change. As a project evolves, make sure to keep the above rules in mind and rename your classes and methods when their roles change. Don’t let a name rot into inaccuracy.
The subject of naming has been a popular one over the years. Here are some worthwhile posts:
- I Shall Call It.. SomethingManager (Coding Horror)
- Don’t make objects that end with ‘er’ (Objology)
- Don’t go into programming if you don’t have a good thesaurus (IT World)
- Ottinger’s Rules for Variable and Class Naming
- Naming tips
This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.