Thoughts on the Foolishness Known as ``Hyrum's Law''

The relatively young field of computing has collected another so-called law, which of course has its
very own website with all the bells and whistles and worthless encryption, whose domain now follows:
https://www.hyrumslaw.com

 With a sufficient number of users of an API,
 it does not matter what you promise in the contract:
 all observable behaviors of your system
 will be depended on by somebody.
 --Hyrum Wright

This law is, in a trivial way, true to some degree, but I only ever see it used as justification for
the opposite of its proper application.  Quite recently, I read an article about this law and the Go
language; this pathetic ``law'' was cited in a comment as the reason why one string used as a return
value to indicate an error couldn't be changed.  I immediately recalled how Lisp got its error type:
One hacker wanted to change an error message, and realized he couldn't, because symbols were used as
both the error messages as presented to the users and as the values for programmatically recognizing
the errors.  He correctly realized a real error type which decouples these two uses to be necessary.

Go is a language explicitly designed for midwits who can't understand a real language, such as Lisp:

 The key point here is our programmers are Googlers, they're not researchers.  They're typically,
 fairly young, fresh out of school, probably learned Java, maybe learned C or C++, probably learned
 Python.  They're not capable of understanding a brilliant language but we want to use them to build
 good software.  So, the language that we give them has to be easy for them to understand and easy
 to adopt.
 --Rob Pike

Disgustingly, Hyrum's ``law'' was used to justify ignoring decades of hindsight, and this appears to
be one of its primary uses.  Rather than think, some programmers will make a basic mistake, and then
cite this law as reason to never change it.  Programmers who have never used a real language believe
this to be a selling point of Go, not understanding that Go's one implementation which allows taking
advantage of such minutiae to be the problem.  A Common Lisp hacker typically understands he may not
use such details, for he usually expects his program to run under multiple, varying implementations;
this of course ignores that Common Lisp avoids all of these trivial design flaws in the first place.

That main motto of the Go language may as well be ``Foreseeable Fuckups Forever'', and this motto is
easily derived from Hyrum's ``law'' how I see it; the ``law'' is little more than an attempt to turn
flaws into strengths, predictable mistakes into backwards-compatibility guarantees, so pathetically.

Hyrum was an employee for one of the most evil corporations to exist, Google, and that status is one
used to help justify his stupid belief.  I believe it truly shows the poor engineering discipline at
his former employer, a total inability to set and enforce boundaries, and therefore abstractions.  I
know for a fact how that Object-Oriented programming approach can defeat this ``law'' in every sense
except performance, which can be merely included in a specification to solve that final issue.  With
message-passing, nothing about an object is known beyond its answers to questions asked of it, which
leaves naught but side-channels remaining.  Side-channels may be eliminated through hard work, or by
exposing them, and many side-channels are so obscure as to be completely useless as some dependency.

I long ago read another article about the greatness of Google, and how the engineering culture there
isn't irreparably fucked by a total lack of discipline; it took roughly a year to change the default
C++ language sorting algorithm, and the sad story that now follows is supposed to be one of success:
https://danlark.org/2022/04/20/changing-stdsort-at-googles-scale-and-beyond/

The article's worth reading, if only to learn of the insanity of the C++ language.  I learned of the
std::nth_element function, a partial sorting function so incredibly specific that I've never seen it
present in any other programming system; this is made all the more amusing as the article goes on to
explain how the idiots working there repeatedly misused it.  When one reads about the supposed magic
happening at Google, it's enlightening to instead read of idiots handling array indices directly and
incorrectly.  One should read this article and wonder why a single sorting interface is present with
so many varying uses; it would be clearly better to provide many, more specific interfaces to thwart
this supposed law, and yet it appears to have occurred to no one there to carry out this minor task.

Microsoft Windows is commonly touted as another example of this ``law''.  The flaws with that system
stem mostly from its history of exposing hardware details, and in its implementation using the worst
programming languages ever created which are also seriously used by man, primarily the C++ language.
The IBM i system, which exposes a compiler target not directly executed, stands as a counterexample;
the compiled program representation is compiled to the underlying machine code, and control over the
machine code gives that system easily-enforced control over behaviours largely impossible otherwise.

An irony with Hyrum's ``law'' is its relationship with Google, a company widely known for destroying
its offerings and compatibility thereof on a whim.  Clearly, the intended relationship goes one way.
These evil corporations simultaneously love to destroy interfaces, and make work for volunteers they
loathe, whenever possible; one example would be changing ``whitelist'' and ``blacklist'' everywhere.

That easiest and best way to deal with this ``law'' is to damn those who insist on somehow violating
interfaces, for whatever reason.  In yet another article about this dumbfuckery, I saw some nerd who
apparently deeply fears talking to other people using encryption on a cookie for some irrelevant WWW
interface; I can only think the idea of asking his fellow employee not to do something horrified him
and left passive-aggressive encryption his one option, so he could continue to hole himself away so.

I view ``Hyrum's Law'' no differently than the ``Law of Leaky Abstractions'' and ``Amdahl's Law'' in
that all pretend to be some fundamental quality of the universe, ARGUMENTUM AD MUNDUM.  The last has
the nice quality of trying to be a mathematical argument, whereas the former two make up software to
be anything but a mathematical object; each presents a false statement denying the very existence of
better, and they form naught better than excuses for poor practices that have fooled so many people.
.