Fare's response on threads
Lynn H. Maxson
Thu, 21 Sep 2000 21:24:18 -0700 (PDT)
"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
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
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
"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
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.