KISS

[Lynn H. Maxson]

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 
computer science.

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 
system.

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 
generation).

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 
it.

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 
specification language.