Fare's response on threads

[Lynn H. Maxson]

"Sure. But this doesn't mean we have to always have precise 
understanding of all the details of what the system will do about 
what we tell it."

It makes no difference what we individually must have in terms of 
a "precise understanding of all the details" in any system in 
which we do not "author" all the details.  Tunes and the Tunes 
HLL, however, is not one of these.  On the contrary we cannot 
offer any higher level object, function, or operation without 
knowing its "passage" through all lower levels down to an actual 
instruction sequence.  We do not have the "grace" of assuming the 
"system" will do this or that, because it is the this or that for 
which we are responsible.

"Just like we have compilers precisely so that we do not have to 
understand the precise register scheduling and memory spilling 
constraints."

Again not if you are the compiler writer.  The compiler user who 
has no other responsibility with respect to the compiler itself or 
the operating environment in which we invoked may be ignorant or 
have no understanding of the underlying detail.  Such is not an 
option for Tunes which declares itself in terms of operating 
system and HLL as offering something which does not now exist.  
All these things must be accounted for to the most operational 
detail, if for no other purpose to insure that every higher level 
has a seamless path through all lower.

"In the case of threading mechanisms, this means that we can 
expect the system, _once it grows elaborate enough_, to 
automatically select threading tactics depending upon a wide body 
of information about all the threads: ..."

IMHO, you once more make the same mistake.  We can expect nothing 
of the system which we have not incorporated into it.  
Improvements to that incorporation, again which we direct, 
determines its "elaborate" condition at any point in time.  It 
will not (and never) automatically select anything which is not 
absolutely predetermined by the rules we have set, even if we use 
a "randomness" generator.  That even is under our control.  All 
the instances you quote following this explicitly point this out.

"Selecting the right tactic can be done much faster by the machine 
than by the human;"

Given the same set of rules, the machine will win every time.  
Basically that's why we automate (where it economically makes 
sense to do so) clerical (repetitive) human tasks.  However, it is 
those rules, which we must write so that the machine will execute 
them (again without knowing what it is executing).

"You have missed it.  People like Jacques Pitrat or Doug Lenat 
have experimentally shown such pattern generation in expert 
systems with meta^n rules.  In another field, some have also 
successfully devised theoretical and practical applications of 
Kolmogorov Complexity to extract patterns out of large bodies of 
data, which have been used in data-mining.  Also, genetic 
algorithms have allowed many computer scientists to generate
unexpected practical solutions to many problems from lower-level 
noise."

Again I must thank you for providing additional evidence of my 
position.<g>  All these are implemented in software written in an 
absolutely deterministic manner.  The software itself is incapable 
of such self-encoding.  Further it does not "know" or "understand" 
in any human sense what it is doing, nor in fact that it is doing 
anything.  That impossible capability is now and forever the case 
in any von Neumann architecture.

The truth is we know and understand what it does, because it is 
exactly what we told it to do and everything it does lies entirely 
within our control.  If for not other reason than this, we will 
never "replicate", only "mimic" (simulate), human behavior using 
hardware and software somehow separable and not self-sufficient as 
a "system".

"But I do envision TUNES as a framework to enable subsequent AI 
works.  And even in the early years, things will be done in 
declarative ways that favor metaprogramming and allow it to grow 
more elaborate as needs arise, without disrupting service."

You have two choices currently in AI, rule-based and neural nets 
(indirect rule-based).  In either case their rules and 
construction lies outside their control and entirely within ours.  
We set the rules.  Their sophistication depends entirely upon 
ours.  It makes no difference in genetic programming as it follows 
the same human-set rules.

"without disrupting service" has been an ongoing struggle in IT.  
Actually we have managed to come quite close in terms of hardware 
and supporting software.  If Tunes can achieve the 365/24/7 common 
in the IBM MVS environment, it will come about even.

No one can quarrel with the goals of Tunes.  I certainly do not.  
I support them.  As I suggested earlier in this response Tunes is 
a total responsibility, one system.  Within that framework of 
responsibility it is inappropriate, IMHO, to do something with the 
"luxury" of dismissing all that it is dependent on by suggesting a 
"separation" in the use of the phrase indicating that some other 
"agent" will handle the rest.  It is not a luxury that Tunes, if 
it is to meet its goals, can afford.

Every participant here is entitled to make the choice about what 
he chooses to understand and what he does not.  If he chooses to 
understand through every level of detail, he should have that 
option.  It is one thing to say that one has a choice not to know, 
it is another to say that he doesn't have the choice to know.  
Relegating "source" to the "system", something apart from the 
current focus, without the concomitant ability to choose the 
detail of understanding desired leaves Tunes as well as the 
individual in an "incomplete" state.  That's hardly an attribute 
of a total and complete system.

No software "knows" it is engage in reflection as no software has 
any ability to "know" anything.  We know what the software is 
doing as well as what it does.  That's two things entirely outside 
the realm of software.  Fare continues to act as if this human 
capability is transfered along with the rules to the software.  
That allows him to suggest that it can somehow on its own increase 
its level of sophistication and elaborate behavior.  

The fact that we observe or describe a behavior in human terms 
does not mean its existence the "system" under observation.  
Software executing on a machine has no "purpose".  That purpose 
belongs strictly to us and we have no means of transferring it, no 
matter how much we desire to do so.  It does what it does because 
that is what we told it to do.  It has no choice in what it does.  
It has no options.  Moreover it doesn't know that it is doing 
anything.

That does not mean you cannot engage in reflexive programming.  It 
does mean that is what people put into a program.  It is no more 
or no less than what is put in.  That accounts for "elaborate" as 
well.  The same is true for meta-programming.  Or genericity.  Or 
any of the other requirements.  They apply to what people do to 
insure that software complies.  The software has no other choice.