Adventures in Machine Learning

The Power of Interfaces in Programming: Informal vs Formal Python Implementation

Interfaces: Understanding their Role in Programming

Programming is an art, but it is also a science. As such, it requires precision, organization, and the implementation of dependable systems.

When we write code, it is often essential to be able to interact with other elements in the program and ensure that they work together cohesively. This is where interfaces come in.

In essence, an interface is a bridge that enables different components of a code to work together in harmony. By standardizing the way in which different elements communicate with each other, interfaces make it easier for programmers to create and organize complex systems.

They encapsulate the behavior that an object should exhibit when it is called upon to perform certain tasks.

However, not all interfaces are created equal.

In this article, we will take a look at the different types of interfaces and their implementation in popular programming languages such as Java, C++, Python, and


Python Interface Overview

Python is a strongly-typed language that supports dynamic typing. As such, it has a unique way of dealing with interfaces.

Here are some of the ways in which interfaces can be implemented in Python:

Informal Interfaces

Informal interfaces rely on duck typing, which means that a method or object has the same functionality as another method or object, even if they vary in their implementation. This allows objects to interact without having to be explicitly defined as an interface.

For example, we can have two classes, PdfParser and EmlParser. Both classes have methods with the same functionality, but they are implemented differently.

Using Metaclasses

Metaclasses are classes that define the behavior of a class. They can be used to create more advanced interfaces.

For example, the ParserMeta metaclass can be used to create new classes, such as PdfParserNew and EmlParserNew, which are derived from a common parent class and have the same methods.

Using Virtual Base Classes

Virtual base classes are a special type of interface that is used to define shared behavior among multiple classes. This is achieved by creating a base class that defines the method signatures that derived classes must implement.

For example, we can create a PersonMeta base class, and create a friend class that inherits from this class. From there, we can create multiple friend objects with different implementations.

Formal Interfaces

Formal interfaces are the most structured type of interface in Python. They are defined using the abc.ABCMeta metaclass, which is a subclass of type.

Formal interfaces are created using the @abc.abstractmethod decorator, which indicates that a method must be implemented in a subclass. If a method is not implemented, it raises the NotImplemented error.

This type of interface ensures that all objects derived from the interface have the same functionality.

Interfaces in Other Languages


In Java, interfaces are defined using the interface keyword. They are implemented using the implements keyword in a class.

Interface methods are declared using the abstract keyword, and they are implemented in the class that implements the interface. In Java, interfaces are used to define behavior that multiple classes must implement.

For example, we can define a Shape interface that has a method to calculate the area. We can then have a Circle and Rectangle class that implements this interface.


C++ uses pure virtual functions to define interfaces. They are declared with the virtual keyword, and they have no implementation.

Classes that implement the interface should provide an implementation for the methods in the interface. Multiple inheritance is also possible in C++, which allows a class to implement multiple interfaces.



Go, interfaces are defined using the interface keyword. They are implicitly implemented.

This means that any object that implements all methods in the interface automatically implements the interface. For example, we can define a fileParserInterface that has two methods, read and write.

Any object that implements these methods automatically implements the fileParserInterface.


In conclusion, interfaces provide an essential tool for programmers to create cohesive and organized systems. By defining a standardized way for different elements to work together, interfaces ensure that code is more maintainable, robust, and scalable.

Whether you’re using Python, Java, C++, or

Go, understanding interfaces is essential to creating successful programs. In our previous discussion, we explored an overview of interfaces in programming, with a focus on Python.

We looked at four types of interfaces that can be implemented in Python: informal interfaces, metaclasses-based interfaces, virtual base classes, and formal interfaces. In this expansion, we will delve more deeply into the differences between informal and formal Python interfaces.

Informal Python Interface

As mentioned earlier, informal Python interfaces rely on duck typing, where two methods or objects that have the same functionality are considered to be the same interface. This is possible due to the flexibility of the Python language, which allows a method or object to behave in any way as long as it meets the required functionality.

One of the benefits of informal interfaces is that they are straightforward to implement and can be quickly adapted to the changing needs of a program. An example of an informal interface in Python is as follows:


class Box():

def __init__(self, w, l, h):

self.width = w

self.length = l

self.height = h

def volume(self):

return self.width * self.length * self.height


Another example:


class Rectangular():

def __init__(self, w, l):

self.width = w

self.length = l

def area(self):

return self.width * self.length


Both these classes have a method that calculates the volume and area, respectively.

They adhere to the same informal interface and can be used interchangeably. However, informal interfaces also have limitations.

One of the major drawbacks is that they offer no guarantee that all objects or methods will perform as intended when used in the same code base. This in turn can lead to unexpected behavior and a lack of standardization across the program.

Formal Python Interface

Formal Python interfaces are more structured than informal interfaces and provide better standardization. They are defined using abstract base classes and raise NotImplementedError if a method is not implemented as required.

This ensures that any class derived from the interface provides the required functionality. To define a formal interface, we can use the abc module, which provides the ABCMeta class that can be used to define an abstract base class.

The @abstractmethod decorator is used to indicate the methods that must be implemented in subclasses. An example of a formal interface in Python is as follows:


from abc import ABC, abstractmethod

class ParserInterface(ABC):


def load_data_source(self, path: str, filename: str) -> str:



def extract_text(self, extension: str) -> str:



The ParserInterface class uses the ABCMeta metaclass, and two methods are defined: “load_data_source” and “extract_text”.

Any class that inherits from this interface must implement these two methods using the same method signature. The benefits of formal interfaces are plenty, including a better structure, increased standardization, and signaling which methods are required to be implemented, making the code more reliable.

The disadvantages can include a higher cost in code development time and possible limitations of developers when defining and implementing them. Python’s informal and formal interfaces provide two distinct methods to define the behavior of code components using a flexible, yet structured format to enhance the program’s functionality.

Ultimately, the choice of which interface to use depends on the specific needs and requirements of the program. In conclusion, interfaces in programming are essential tools that provide cohesion and organization to complex systems by defining interactions among components.

Python supports both informal and formal interfaces. Informal interfaces rely on duck typing, where objects as long as they meet the required functionality.

In contrast, formal interfaces mandate that objects define methods as established by the ABCMeta hierarchy, ensuring the required levels of standardization. It is essential to determine which method works best for a particular program based on its needs and structure.

Interfaces are integral to programming, and developers must have a firm grasp of their implementation to ensure the efficiency and functionality of complex systems.