Application programming interface

An application programming interface (API) is a defined set of protocols, routines, and tools that specifies how software components should interact. It is the boundary between abstraction layers: the API defines what operations are available, what inputs they require, and what outputs they produce, without exposing the internal implementation details.

The API as Contract

Like an ISA, an API is a contract. The provider commits to maintaining the documented behavior; the consumer commits to using only the documented interface. This separation enables independent evolution: the provider can change internal implementations, optimize algorithms, and fix bugs without breaking consumer code, as long as the API contract is honored.

APIs exist at every scale of software systems:

• Operating system APIs (POSIX, Win32) provide access to file systems, processes, network sockets, and hardware devices.
• Library APIs expose the functionality of reusable code modules — from the C standard library to modern frameworks like TensorFlow or React.
• Web APIs (REST, GraphQL, gRPC) enable communication between distributed systems over network protocols, forming the connective tissue of modern cloud computing.
• Hardware APIs abstract device capabilities, from GPU compute APIs (CUDA, Vulkan) to sensor interfaces on embedded systems.

API Design and System Architecture

The design of an API shapes the systems built upon it more profoundly than is commonly recognized. A well-designed API reveals the essential structure of a problem domain and hides incidental complexity. A poorly designed API leaks implementation details, forces consumers into awkward patterns, and creates technical debt that propagates through every system that uses it.

The history of computing is littered with APIs that became constraints. The Windows API determined the structure of desktop applications for decades. The POSIX API enabled Unix-like systems to share software ecosystems. The x86 ISA — itself a hardware API — shaped compiler design, operating systems, and the entire PC industry. APIs are not neutral infrastructure. They are design decisions frozen into interfaces, and their consequences compound across every layer of the systems that depend on them.

An API is a theory about what matters. It declares which operations are essential, which details are irrelevant, and how the pieces fit together. A good API embodies a correct theory; a bad API embodies a theory that its users must constantly work around.