Interfaces — UI, GUI, API

Everyone uses “UI”, “GUI”, and “API” with possibly different definitions. I will try to stop the confusion.

1. Interface ≠ Just a Pretty Screen

An interface is the handshake between two systems—human ↔ computer, service ↔ service, org chart ↔ workflow. If signals move in both directions, you’re looking at an interface. Full stop.

2. User Interface (UI): Where Humans Meet Machines

UI is the catch-all for every touchpoint a person uses to steer a computer:

• The TV remote buried in your couch.
• A blinking terminal cursor.
• DOS-era command prompts.
• The GUI you probably spend 90 % of your day in.

Key point: GUI is a subset of UI. Calling every UI a GUI is like calling every vehicle a Tesla.

3. GUI: Visual Sugar, Same Contract

A GUI layers icons, windows, and drag-and-drop muscle memory on top of the core commands. It lowers the learning curve but raises engineering cost. Underneath, the same requests fire—just prettied up for eyeballs and fingertips.

4. API: Interfaces for Code, Not AND People

An API is an interface for programs. Its job description:

1. Bridge — wire two services together with a stable conduit.
2. Hide the guts — expose what callers need, bury the rest so you can refactor next quarter.
3. Standardize — nail down nouns, verbs, data shapes, versions.
4. Enable tooling — once the surface is locked, you can test, doc-gen, stub, throttle, and swap internals without breaking callers.

History footnote:

• 1960s mainframes demanded hardware-agnostic APIs so code survived chip swaps.
• 1990s pushed logic to remote servers, making network APIs mainstream.
• 2000s: Roy Fielding codified Web APIs (REST) and the Internet hasn’t shut up since.

5. Anatomy of Modern Network APIs

• Sync vs Async — request/response vs webhooks, long-polling, pub/sub.
• Transports — TCP, UDP, QUIC.
• Encodings — JSON, Protocol Buffers, Thrift, Avro.
• Styles — SOAP (legacy), REST (workhorse), GraphQL (flex), gRPC (performance), WebSockets (live), message queues (event-driven).

Good APIs still follow Joshua Bloch’s litmus test: self-explanatory, hard to misuse, evolves without breaking clients, and reads like prose.

6. Why You Should Care

• Strategic — clean interfaces decouple teams and timelines; you deploy without a 20-person Slack war.
• Performance — tight contracts let you cache, batch, and fail fast.
• Longevity — your code still works after rebrands, rewrites, and “we’re pivoting to micro-whatever” Slack bombs.

Stop conflating UI, GUI, and API. Nail the distinctions and you’ll design cleaner systems, write less glue code, and ship faster.