How do you name interfaces that are derived or extended from other interfaces?

1 Why name interfaces?

Naming interfaces is important for several reasons. First, it helps you organize and document your code. By giving meaningful and descriptive names to your interfaces, you can easily identify what they do and how they relate to other interfaces and classes. Second, it helps you avoid conflicts and confusion. By following a consistent naming convention, you can avoid naming collisions and ambiguity between different interfaces and implementations. Third, it helps you adhere to the principle of least astonishment. By naming your interfaces in a way that matches the expectations and conventions of your programming language and domain, you can make your code more readable and maintainable.

2 What are some common naming conventions?

Different programming languages and style guides have different naming conventions for interfaces. Common conventions include prefixing interface names with I, such as IAnimal, IFoo, or IDisposable (used in C#, Java, and TypeScript to indicate that the name is an interface). Alternatively, you can use adjectives or nouns that describe the behavior or role of the interface (preferred in Python, Ruby, and Swift). Lastly, you can use suffixes or modifiers that indicate the relationship or hierarchy of the interface (useful when you have multiple interfaces derived from other interfaces). This convention shows the inheritance or composition of the interface and its subtypes or mixins.

3 What are some common naming mistakes?

When naming interfaces that are derived or extended from other interfaces, it is important to be aware of the common naming mistakes. Generic or vague names such as IInterface, IObject, or IManager do not convey the meaning or scope of the interface and increase the risk of name clashes and confusion. Additionally, using verbs or actions such as IRun, ICreate, or IHandle implies the implementation or usage of the interface and limits its flexibility and extensibility. Finally, inconsistent or contradictory names like AnimalInterface, IFooable, or DisposableClass are confusing and misleading as they mix different styles and signals and violate consistency and clarity.

5 Examples of naming interfaces that are derived or extended from other interfaces

To illustrate how to name interfaces that are derived or extended from other interfaces, let's look at some examples in different programming languages. For example, in C#, you might have an interface named IAnimal that represents a generic animal. This could be extended by ICarnivore, which adds a method named EatMeat, and IFeline, which adds a property named FurColor. A class named Lion would then implement IFeline and provide the concrete implementation of the methods and properties. In Python, you could have an interface named Animal, which can be inherited by Carnivore to add a method called eat_meat and by Feline to add a property called fur_color. The Lion class would then implement Feline and provide the concrete implementation of the methods and properties. Finally, in Swift, you may have a protocol named Animal representing a generic animal. This could be conformed to by Carnivore to add a method called eatMeat and by Feline to add a property called furColor. A struct named Lion would then conform to Feline and provide the concrete implementation of the methods and properties.

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?