On the Costs of No Customization

Programs ought to be customizable; this is a claim so inarguable I feel it to need no justification.

The ability to customize a program naturally makes it less efficient, a common argument, and this is
true in the same sense that checking invariants makes a program less efficient, and so is true in no
particularly meaningful way.  It's always less efficient for there to be no avenue for such, even if
harder to measure, but efficiency is a false god.  There are different ways to enable customization,
and some are better than others.  Some methods can be so efficient regardless as to be unnoticeable.

One way requires a program to evaluate its customization on every usage, and is a poor way to do it.
Another way has the program embed its customization into itself, and thus has fewer of these issues.
Either way, there's the issue of whether or not the customization is itself custom, whether or not a
familiar or unfamiliar mechanism is used to express it.  Lisp programs most commonly express this as
Lisp code to be executed in tandem with the Lisp used to define the program itself, and this usually
is better than that other way, with the full power of the system available, but can require exposing
the program's organs a tad too much for good taste.  Either way has an excuse to avoid better tools.

Very rarely have I seen tools for customizing programs in foolproof ways; there's no general-purpose
way to customize a program, and to pretend otherwise is farce.  Programming tools are also generally
bad, but this is related to my preferred way to customize a program: modifying the program directly.
In writing this I've reminded myself of a band of idiots who also champion this, but incorrectly so.

For customization to work in directly modifying a program, it must be comprehensible and thus small.
For the program to exist only in a form suitable for machines is unacceptable; the source code ought
to be available always, so that the user never be stranded with a program that can't change for him.
Thus the source code ought to be mandatory for using the program at all.  My machines regularly fall
into a state preventing them from installing programs normally, and so I often find myself using GNU
Emacs purely for this quality, that I can never reasonably be stranded so, and what an oddity to me.

I've found myself downloading a new program for what amounted to just a few more instructions, for I
simply couldn't add them to that program I already had, and these are the costs of no customization.
It was a monitoring program, and I merely wanted it to maintain a running sum of some values between
some times, but I was forced to install and use a different program for such a stupidly simple task.
The simplicity of changing the prime loop to do this and add a command to reset the sum stood out to
me throughout this; the program still was likely too complicated for me to do such, making it worse.

Perhaps it truly be best to provide programs as a cracked-open shell of code and data, as with Lisp,
but that's such an unsatisfying answer to me.  Even then, the very design of the program limits what
customization can be done simply and reasonably.  I'm intoxicated with the idea of programs designed
so that all reasonable customization can be done by changing data with dedicated tools and not code.
.