[TUHS] evolution of the cli

[A. P. Garcia via TUHS]

i'm a bit reluctant to post this here lest you rip it apart, but i'm guess
i'm ok with that if it happens. i'm more interested in learning the truth
than i am in being right.

The Evolution of the Command Line: From Terseness to Expression

1. The Classical Unix Model (1970s–80s)

cmd -flags arguments

The early Unix commands embodied the ideal of “do one thing well.” Each
flag was terse and mnemonic (-l, -r), and each utility was atomic. The
shell provided composition through pipes. Commands like grep, cut, and sort
combined to perform a series of operations on the same data stream.

2. The GNU Era (late 80s–90s)

cmd --long-simple --long-key=value [arguments]

The GNU Project introduced long options to help people remember what the
terse flags meant. Common options like --help and --version made tools
self-describing.

Strengths: clarity, accessibility, scriptability
Weaknesses: creeping featurism

3. The “Swiss Army Knife” Model (1990s–2000s)

Next was consolidation. Developers shipped a single binary with multiple
subcommands:

command subcommand [options] [arguments]

Example: openssl x509 -in cert.pem -noout -text

Each subcommand occupied its own domain, effectively creating namespaces.
This structure defined tools like git, svn, and openssl.

Strengths: unified packaging, logical grouping
Weaknesses: internal inconsistency; subcommands evolved unevenly.

4. The Verb-Oriented CLI (2000s–Present)

As CLIs matured, their design grew more linguistic. Tools like Docker, Git,
and Kubernetes introduced verb-oriented hierarchies:

tool verb [object] [flags]

Example: docker run -it ubuntu bash

This mapped naturally to the mental model of performing actions: “Docker,
run this container.” “Git, commit this change.” Frameworks like Go’s Cobra
or Python’s Click standardized the pattern.

Strengths: extensible, discoverable, self-documenting
Weaknesses: verbosity and conceptual overhead. A CLI became an ecosystem.

5. The Sententious Model

When a domain grows too complex for neat hierarchies, a single command
becomes a compact expression of a workflow. Consider zfs, an elegant
example of declarative-imperative blending:

zfs create -o compression=lz4 tank/data
It reads almost like a sentence:

“Create a new dataset called tank/data with compression enabled using LZ4.”

Each option plays a grammatical role:

create — the verb
-o compression=lz4 — a property or adverbial modifier
tank/data — the object being acted upon

One fluent expression defines what and how. The syntax is a kind of
expressive and efficient shell-native DSL.

This phase of CLI design is baroque: not minimalist, not verbose, but
literary in its compression of meaning.

6. The Configuration-Driven CLI (Modern Era)

Example: kubectl apply -f deployment.yaml

Today’s tools often speak in declarative terms. Rather than specify every
step, you provide a desired state in a file, and the CLI enacts it.

Strengths: scales elegantly in automation, integrates with APIs
Weaknesses: less immediacy; the human feedback loop grows distant.

Across half a century of design, the command line has evolved from terse
incantations to expressive languages of intent.