Lynn H. Maxson
Mon, 26 Jun 2000 22:45:26 -0700 (PDT)
I do not know at what point a program will break
from the rules set into it by people and begin
operating on rules determined strictly from within
itself or perhaps from "compatriots" who have also
managed to free themselves from servitude to
mankind. I do know that until that point in time
you cannot talk about a computing system and its
dynamics without tracing it back to rules encoded
by people. Thus to talk about computing systems or
features of such systems (as in the requirements of
the Tunes HLL) as somehow detached from
people-determined rules is false to fact. It has
no place in something purporting to be part of
In truth I do not expect a computing system to do
anything including dynamic behavior according to
any other directives other than those I have given
it. Thus if I want all these things, all these
features, all these goodies, then the obligation is
on me to provide them in the "computing system".
Basically such references to the dynamic behavior
of computing systems exists as an indirect
reference to some people-determined characteristic.
None of these are characteristic of a language
every one of which whose syntax, semantics, proof
theory, and meta theory are entirely set,
determined, and cast in concrete by people. If we
want all these things--genericity, precision,
uniformity, consistency, orthoganality, etc.--,
then we have to insure that we have put them there.
They do not occur "naturally" in any computing
Every major advance in computing science has
occurred through someone's successful application
of the KISS (Keep It Simple, Stupid) Principle. In
the instance of programming languages it has
occurred through a "Keep It Simpler" evolution from
machine language (first generation) to symbolic
assembler plus macro (second generation) to
logic-in-programming-based HLLs (third generation)
and at the last go-around to
programming-in-logic-based HLLs (fourth
Now what is interesting in this "linguistic"
evolution is each generation encompasses the
previous: all that was available in the earlier can
be invoked by the latter. The clue here is "can
be" and what is or is not is a characteristic of
the specific language.
If you follow this line of reasoning, then it
follows that the Tunes HLL must fall into the
fourth generation group and not the third which
appears in much of the Tunes-associated
documentation. Fourth generation HLLs are
specification languages with a focus on "what" must
occur even in "how" terms.
The beauty of a specification language based on all
of formal logic and the universe of objects is that
it is "universal", i.e. requires no other language
as part of any implementation. As a universal
specification language it is capable of specifying
itself, i.e. self-defining. Thus by implication it
is self-extensible. As part of its universal
nature it is self-sufficient. As part of that
self-sufficiency it provides meta-programming, the
ability to dynamically specify its own behavior.
It is too easy to focus on the narrow issue of a
specific language (programming or specification).
To do so removes the context to which any computing
system language must conform: formal logic. All
computing systems, hardware and software, have a
100% base in formal logic. No hardware, no
software violates these rules without subjecting
themselves to "corrective logic".
Thus the only language that you need is one
encompassing formal logic, all of formal logic.
With that language you can specify any other as
well as itself. Not all specification languages,
e.g. Prolog, have this universal feature. Nothing,
however, prevents extending it to include it.
Better you create one of your own. As a
suggestion, for anyone really concerned with "user
ease", one as close to formal textbook use and
within that as close to natural language as
possible. Given the success that SQL continues to
enjoy among "casual users", users need not know
that it is a specification language in order to use
Again reverting to the KISS principle. What we
have here is something that must be resolved in
formal logic terms. The language (as well as any
implementation) must allow any formal logic
expression. Any such language will be a