No history yet

Meaningful Names

The Power of a Good Name

Writing code is a form of communication. While the compiler only needs correct syntax, the humans who read, debug, and maintain your code need clarity. The most fundamental act of clarity is choosing a meaningful name. A good name tells a story about what a variable, function, or class is and why it exists.

Consider this simple declaration:

int d; // elapsed time in days

The comment is a warning sign. It exists because the variable name d is meaningless on its own. The programmer must perform , translating d into "elapsed time in days" every time they see it. This cognitive friction adds up, making the code harder to understand and easier to break.

Now, look at the alternative:

int elapsedTimeInDays;

There is no ambiguity. The name itself reveals its intent. It doesn't need a comment. This is the first and most crucial step in writing professional, clean code: names should be explicit, intentional, and require no outside explanation.

Making Names Searchable

Beyond clarity, good names have a practical benefit: they are easy to find. Imagine you're debugging an issue related to the maximum number of items allowed in a shopping basket. If the limit is hard-coded as the number 50 throughout the application, finding every instance is a nightmare. Is 50 the item limit, a user's age, or a discount percentage?

Single-letter names and numeric constants have a common problem: they are difficult to locate in a body of text.

Instead of a raw number, a well-named constant is far superior. A name like MAX_ITEMS_PER_BASKET is not only descriptive but also easily searchable. You can instantly find every place it's used. The same logic applies to variables. A loop counter i is a common convention and often acceptable for very short loops. But for anything more complex, a name like customerIndex provides more context and is easier to search for.

Nouns for Classes, Verbs for Methods

Object-oriented programming organises code around objects, which are conceptual things. The naming conventions should reflect this. A class or object name should be a noun or noun phrase. A method name should be a verb or verb phrase, as it represents an action that can be performed.

// Class name is a noun
class Customer {
    private String name;
    private String email;

    // Method names are verbs
    public void saveToDatabase() {
        // ... logic to save customer
    }

    public void sendWelcomeEmail() {
        // ... logic to send email
    }

    public boolean hasValidEmail() {
        // ... logic to check email format
    }
}

This convention creates a natural, readable grammar. You can read the code almost like a sentence: you might create a Customer and then customer.sendWelcomeEmail(). Accessor, mutator, and predicate methods should be prefixed with get, set, and is or has, respectively. For example: getName(), setName("Alice"), and isActive().

Avoiding Disinformation

Just as important as what names should do is what they should not do. A name must not be misleading. This is what we call in code: names that imply something other than the truth.

For example, don't name a group of accounts accountList unless it is literally a List object. If it's another type of collection, like a Set or just an array, name it accountGroup, bunchOfAccounts, or simply accounts. Be precise. Avoid using names that are similar to, but different from, established patterns or acronyms within the project's domain.

Similarly, avoid noise words that add no real meaning. Suffixes like Data, Info, Object, Variable, or String are usually redundant. A class named Customer is better than CustomerObject. A variable named name is clearer than nameString. These words are clutter. If a variable name needs a suffix to make sense, the name probably isn't good enough to begin with.

Choose meaningful names for variables, functions, and classes which reflect their purpose and make your code self-documenting.

Ready to test your naming instincts?

Quiz Questions 1/5

What is the primary reason for using clear and meaningful names in programming?

Quiz Questions 2/5

The cognitive effort required to constantly translate a vague name like d into its actual meaning, "elapsed time in days", is an example of:

Choosing names is the first step in communicating intent. By focusing on clear, searchable, and honest names, you lay the foundation for a codebase that others can understand, maintain, and build upon.