Omnipresent Mismatch

Part of the reason computing is in a sorry state is due to poor interfaces.  Rather than retiring an
interface, the common reaction to some need is merely to extend it.  Worse, this is that reaction to
deficiencies of all sorts.  This leads to the titular quality which I notice in the world around me.
This quality is brought about by addition rather than subtraction, by convention instead of rule, by
discarding what little model of the system be present.  Worse, it's omnipresent, layers upon layers.

A machine code can be a good example.  Without foresight, some flaw will eventually be noticed, some
inability to do something which is necessary, and this can sometimes be corrected through blessing a
particular sequence of instructions.  What happens with this is that the specification has just been
extended, in a particularly vague and vile way.  Eventually, the model of the processor can become a
mess, with errata littered about, and what model could such a processor be said to implement at that
point?  This is an almost-inevitable result of haphazardly extending an instruction set for decades.

This quality isn't limited to machines.  Common operating system software, the both of them, exhibit
such degeneration.  The models are filled with hacks and exceptions without concern, in that name of
portability or security or whatnot, and it makes for an incomprehensible pile of nonsensical values.
Providing a common interface and forcing everything to adhere to it is either never done or is never
done well at a suitable level to prevent it from bubbling forth.  It amuses me to read of flaws that
were written decades ago being corrected but recently; rather than ever rewrite, I see the religious
cults of the false gods carry their source code for decades as if it were their Ark of the Covenant.

I'm guilty of creating omnipresent mismatch in one of my systems, Meta-CHIP-8.  Eventually, I'd made
the model invalid, by creating a very special case to avoid that need to further fiddle with it, but
I corrected this by later discarding that system and entirely rewriting it, something sorely missing
from modern software in which all of the concern is in retaining those millions of lines of garbage.

The WWW is a particularly good example of omnipresent mismatch; lacking any foresight, even spelling
checks, the model blundered on for decades, being extended in the most shortsighted of ways.  I view
little time passing by without some major issue that demands an adjustment of the semantics, largely
involving the programming language nailed into its side.  The business interest in it is but amusing
in light of its disgusting flaws and basic mistakes; it's most commonly used for anything except the
few purposes for which it's adequate, and making it more ``capable'' will but hasten its collapsing.

Omnipresent mismatch begets omnipresent mismatch.  A proper system may be set on one broken, but not
easily, and it will have queer omissions unless it be a convenient subset of the broken layer.  What
is more easily done is piling on another broken system.  A lack of thought is the prime commonality.
.