Recently I came across a moderately large python codebase with lots of MyClassAbstractFactory, MyClassManager, MyClassProxy, MyClassAdapter etc. classes.

While on the one hand those names pointed me to research and learn the corresponding patterns, they were not very descriptive of what the class does.

Also, they seem to fall within the forbidden list of words in programming: variable, process_available_information, data, amount, compute: overly broad names, that don't tell us anything about the function when used by themselves.

So should there be CommunicationManager or rather PortListener? Or maybe I do not understand the problem at all...?

  • if you are familiar with what the pattern does then the pattern name is a decent description, however just the pattern name is a bad idea, it's better to have a MyClassFactory, a FooAdapter, etc. – ratchet freak Sep 16 '13 at 9:50
  • Edited the question to indicate that the classes were not called just "AbstractFactory", but some descriptive words were there too. – Vorac Sep 16 '13 at 9:59
  • 1
    ...did they seriously call it a Fctory instead of a Factory, or is that just a typo? – Izkata Sep 16 '13 at 17:22
  • @Izkata, lol, my bad. However, there were Adaptor and Adapter! – Vorac Sep 17 '13 at 7:49
  • AbstractFactory is indeed a poor choice for a name. There is no way to know what is created by this factory, and when you'll look for an entity which creates Animals, you'll never find the corresponding factory by name.

  • AnimalAbstractFactory is not a wise choice neither, since in most languages, it would be redundant with the abstract keyword in the signature.

    This being said, there are several good reasons, highlighted by the comments, to actually include Abstract in the name: not only there are several contexts where you don't have the full signature, but just the name, but also, keeping AnimalFactory for an interface may be a wise choice (unless, unfortunately, the convention of the language/framework is to prefix interfaces with I).

  • AnimalCreationUtility would also be a bad choice: if it's a factory, make things easier for people who will read code, and call it a factory.

  • abstract AnimalFactory is ok. It doesn't have redundancy, and is clear that it is an abstract factory which delegates the creation of animals to its children.

So yes, including the name of the design pattern is a good idea, but it should be only a part of the name, and shouldn't be redundant with the other parts of the signature.

  • 2
    Why is this better than writing a comment in a prominent place "In this module, we implement MVC. Reasons: ... Models:... Views:... Controllers:... Structure map:... API:... ". – Vorac Sep 16 '13 at 10:21
  • 38
    @Vorac: Having a clear name is always better than relying on comments. – Arseni Mourzenko Sep 16 '13 at 10:32
  • 2
    @Vorac sooner or later someone will add a new class without updating that prominent comment (or even knowing about its existence). While it's much harder to overlook a naming convention consistently used across the entire app. – Konrad Morawski Sep 16 '13 at 12:38
  • 2
    While you are browsing through your project solution, will you open each class file to find what it does? No. That is why it's always a better idea to have descriptive name classes/files. – matrix Sep 16 '13 at 15:29
  • 2
    I would like to kindly disagree with the second point: I think that AnimalAbstractFactory is a good choice, because even though it is redundant in the class declaration, it would be very helpful in the child class declaration: LionFactory extends AnimalAbstractFactory which, I think, is a nice piece of information. – Igor Deruga Sep 17 '13 at 12:58

Depends on the specific example. The Builder pattern is almost always best served by naming your class *Builder, while a Singleton doesn't usually need to be named as such.

If you don't put the pattern name in your class name, and maybe even if you do, you should generally put a comment in the class which explains that it implements a specific pattern.

  • 3
    Consistency is crucial here, because once only some factories are called ...Factory, it becomes quite a mental bump to realize a class is a factory if its naming breaks that convention. – Konrad Morawski Sep 16 '13 at 12:40

The whole point of using pattern names in classes is to make it easy to understand what the class does. If you name the class AnimalFactory it's obvious that the class creates Animal instances. If the name of your class includes a name of a pattern and it does not describe what it does you've either chosen a wrong pattern or implemented it incorrectly.


I think it can work really well. For example:

// Command for retrying card entry with CVN.
public class RetryCardEntryWithCVNCommand { ... }

// Query for getting expired accounts
public class GetExpiredAccountsQuery { ... }

// Decorator for logging exception. Implies that it's an additional 
//mechanism for logging exceptions.
public class LogExceptionToDbDecorator { ... }

// Factory for creating account filters
public class AccountFilterFactory { ... }
  • 1
    how does this answer the question asked? Per my reading, your "examples" only show useless duplication of class names and code comments – gnat Sep 16 '13 at 13:54
  • Comments are to justify purpose of each class in case class name is not apparent to some. By looking at these I instantly know that I have command that does something, query that returns data, decorator that adds additional behaviour to existing exception logging mechanism and a factory that creates account filters. In my opinion the more descriptive you are with your class names, the easier it becomes for others to read your code. If you are using a design pattern, then say so - at the end of the day the whole purpose of having design patterns is to make it easier for others to read your code – CodeART Sep 16 '13 at 14:49

Not the answer you're looking for? Browse other questions tagged or ask your own question.