What is an appropriate length for function names? [closed]

Question

I'm writing a C++ class, CBookSpellDef which has the following methods:

    int     GetIndexOf(const char *psz);
    char*   GetNameAtIndex(int index) { return m_spellTypes[index].szName; }
    char*   GetWeaponNameAtIndex(int index) { return m_spellTypes[index].szWeaponName; }
    int     GetBasePowerAtIndex(int index) { return m_spellTypes[index].iBasePower; }
    int     GetCostAtIndex(int index) { return m_spellTypes[index].iCost; }
    int     GetFlagsAtIndex(int index) { return m_spellTypes[index].iFlags; }

Compare to those of a very similar class, CAmmoDef from the Source SDK:

    int                 Index(const char *psz);
    int                 PlrDamage(int nAmmoIndex);
    int                 NPCDamage(int nAmmoIndex);
    int                 MaxCarry(int nAmmoIndex);
    int                 DamageType(int nAmmoIndex);
    int                 TracerType(int nAmmoIndex);
    float               DamageForce(int nAmmoIndex);
    int                 MinSplashSize(int nAmmoIndex);
    int                 MaxSplashSize(int nAmmoIndex);
    int                 Flags(int nAmmoIndex);

These are all simple methods which return values from an instance of a struct at an index of a member array of the class, said instance representing magic book spells in the case of CBookSpellDef, or ammunition types in the case of CAmmoDef.

Are my names "too descriptive" while the ones from the Source SDK are the right length? What would the appropriate length and level of "descriptiveness" for these method names be?

Answer 1

The difference here isn’t length as much as warts. You’re cluttering your names with structural information that says “this is a getter” and “pass an index”. The other names have those exact same structural considerations but only use the name to convey semantics. No structural warts. The semantic names make a lot clear on their own but to learn the signature you look at the signature.

Names-with-warts is simply a different style. It’s not at all required. If you remove the warts I’m sure I can handle it.

Answer 2

Both sets of method names seem quite reasonable, abstractly.

Being reasonably systematic about naming is important. And being somewhat thoughtful about names is important.

But it's impossible to say whether exactly 6 or 7 characters is too many.

As a guideline off the cuff, I'd say around 6 to 15 characters for a name is quite ordinary.

Shorter names are good so long as their meaning is clear. And longer names inherently have a cost in terms of reduced readability and visual clutter - so that has to be balanced against any benefit of a long name.

The design of the naming scheme really depends on how many things need to be distinguished in context. That means not only the context of the application, but the context of different areas and scopes in an application, and also the context of the programmer's wider work.

Because strangers don't have access to that context and because it can be enormously difficult to describe all the relevant context, that's what stops there being a simple set of rules for how to name things which can be written down.