Interface

How Interfaces Work

An interface arises where different systems or system components interact with one another.
It describes the properties of this boundary.

Depending on the type of system, this can include:

• which information is exchanged
• which functions can be called
• which data formats are used
• which protocols apply
• which states are possible
• in which order interactions take place
• which timing conditions apply
• how errors are represented or handled
• which physical or electrical properties are required

An interface can be very small.
It can consist of a single signal that has only two states.
But it can also describe an extensive protocol with numerous operations, data types, and states.

An Interface Describes a Boundary

An important property of interfaces is the separation between the inside of a system and what other systems need to know about it.
An application can, for example, provide data through an interface without revealing how that data is stored or generated internally.
For the other side, initially only what the interface guarantees is relevant.
This allows internal components to be changed without necessarily requiring all connected systems to be changed as well.
However, this works only as long as the properties of the interface that are relevant to other systems are preserved.
A technically unchanged interface can therefore still become incompatible if its actual meaning or behavior changes.

Syntax and Meaning

The fact that two systems can technically exchange the same data does not mean that they understand that data in the same way.

An interface can, for example, specify:

stock: 12

The technical representation is initially unambiguous.
What 12 means, however, has not yet been clarified.
Are twelve items physically in stock?
Are twelve items not yet sold?
Are already reserved items included?
Can the value become negative?
When was the stock level last updated?

The syntax of an interface can be correct while its meaning is interpreted differently by the systems involved.
For a functioning integration, therefore, not only formats and protocols but also the relevant meanings and assumptions must be sufficiently clarified.

An API Is Only One Form of Interface

In software, interface and API are often used almost synonymously.
An API, however, is only one possible form.

Interfaces can, for example, be:

• programming interfaces
• network protocols
• file formats
• command lines
• database access points
• message formats
• electrical connections
• bus systems
• mechanical connections
• user interfaces

A user interface also forms an interface: it connects a human with a technical system.
The type of interface being considered therefore depends on the respective system boundary.

Interfaces Create and Limit Dependencies

Interfaces are often intended to allow two components to be developed or changed independently of one another.
However, they do not become completely independent as a result.
Both sides remain dependent on certain properties of the interface.

These can include:

• data structures
• protocols
• meanings
• timing behavior
• error states
• security requirements
• versions
• availability

A well-defined interface makes these dependencies visible and limits them.
A poorly understood interface, by contrast, can create hidden dependencies.

Interfaces Change

Technical systems and their operating conditions can change over time.
Their interfaces can therefore evolve as well.
New fields are added, functions are removed, data takes on a different meaning, or previously tolerated states are suddenly handled differently.
A change can be technically obvious.
But it can also occur even though the formal interface appears unchanged.
An external service could, for example, continue to provide the same JSON schema while changing the meaning of a field.
For connected systems, therefore, not only the formal version of an interface is relevant, but also its actual behavior.

Interfaces Are Observation Points

Interfaces have another interesting property:

At them, behavior between parts of a system becomes visible.

At an interface, it is possible to observe, for example:

• which data leaves a system
• which data arrives
• when communication takes place
• which errors occur
• which states are transmitted
• how long an interaction takes

Interfaces can therefore be important observation points within a system.
However, they show only what becomes visible at the respective boundary.
A correct response at an interface therefore does not automatically imply that all internal processes of the system involved are also correct.

Why Interfaces Have Practical Effects

• Components can be separated: Internal details do not have to be fully known externally.
• Dependencies become describable: It becomes visible what other systems rely on.
• Systems can be replaced: A stable interface can make it possible to exchange internal components.
• Integration becomes possible: Different systems receive a defined boundary for working together.
• Failure boundaries become visible: Problems can be detected and isolated at boundaries.
• Legacy Systems can be encapsulated: New interfaces can shield old internal structures from other systems.
• Observation becomes possible: Boundaries provide suitable points for examining behavior between components.

Typical Example

An older inventory management system provides a CSV file with current product data every evening.
Providing this file forms an interface between the inventory management system and other systems.
A new shop system needs the same data. It would be possible to connect the shop directly to the internal database of the inventory management system.
This would, however, make the shop dependent on internal table structures and their meaning.
Instead, the existing file interface can continue to be used or be supplemented by a new defined interface.
If the inventory management system is later replaced, the shop system does not necessarily have to be changed as long as the new system provides the same relevant interface.
The interface thus forms a controlled boundary between the two systems.

Distinction

• An Interface describes a boundary between systems or system components.
• An API is a particular form of interface through which software provides functions or data to other software.
• System Integration goes beyond the interface. It considers the actual interaction of the systems involved, including states, processes, meanings, and failure cases.
• In System Architecture, interfaces describe relationships and boundaries between architectural elements.
• For Observability, interfaces can be important sources of information because interactions between different system components become visible at them.

Further Reading

Related Concepts

→ API
→ Systems Analysis
→ System Architecture
→ Solution Architecture
→ System Integration
→ Legacy System
→ Legacy Modernization
→ Open Data Format
→ Observability