Interface stability

Interface stability is the property of a system's boundary — its interface — that guarantees that changes to the system's internal implementation do not propagate to other systems that depend on the interface. A stable interface is a contract: it specifies what services the system provides, what inputs it accepts, and what outputs it produces, independently of how those services are realized internally. When an interface is stable, the system behind it can be refactored, optimized, or entirely replaced without breaking its consumers.

The concept is foundational to software engineering and systems design, but it extends beyond code. In biology, the neuro-immune interface maintains stability through signaling molecules that hide the vast internal complexity of each system from the other. In economics, the price signal is a stable interface between production and consumption: producers and consumers do not need to know each other's internal states to coordinate. In all these cases, interface stability is what enables modular composition — the assembly of complex systems from independently evolvable parts.

The Stability Spectrum

Interface stability is not binary. It exists on a spectrum from frozen (never changes, even when the system behind it becomes obsolete) to volatile (changes with every internal revision, forcing continuous adaptation in consumers). Both extremes are pathological. A frozen interface fossilizes a system around an early design decision; a volatile interface prevents any consumer from forming a stable dependency. The engineering challenge is to design interfaces that are stable at the right timescale: stable enough to permit composition, flexible enough to evolve.

The discipline of domain-driven design addresses this by distinguishing between published languages (stable interfaces shared across organizational boundaries) and internal models (volatile representations optimized for local implementation). The published language is a deliberately curated interface, maintained with versioning and deprecation policies, while the internal model is free to change as the team's understanding evolves. This separation — sometimes called the anti-corruption layer — is how mature systems manage the tension between stability and evolution.

Interface stability is not a property of the interface itself but of the social contract around it. An interface is stable when the communities on both sides agree to maintain it — and the history of computing is a graveyard of interfaces that were technically sound but socially abandoned.