introspection vs. self-printing

[utzoo!decvax!harpo!ihps3!ihuxr!lew]

I think that the self-printing problem is much different than the
introspection problem. The later involves a program copying itself,
or at least it ought to. Surely this is the case with the Turing
machine example. The point of this would be that the program is stored
as data. Isn't this what "sufficiently powerful" is all about?
Note that compiled programs do not have this capability.
That is, an a.out cannot read itself. Of course, it can copy itself with
a fork() call, but this is a special provision.

A compiled program running on a system cannot be regarded as an
automaton. You can build an automaton in the memory of a program, but
this converts the program to the "hardware" of a virtual machine.
The automata power of the real computer is reserved to the system.
It is the only "program" running.

I think that an executable file named "me", which contains

cp me you
rm me
mv you me
chmod 777 me

is a legitimate introspecter. Here the shell interpreter is a virtual machine
and the program literally instructs the machine to copy itself. The machine
really comes back to the very instructions which it is executing and copies
them to another place. The files are the system's memory, core is all part
of the processor.

In the case of a.out files which reconstruct their source files, the
program (a.out) is not copying itself at all. And of course, the
source file is not executable at all. It requires the intervention
of a compiler call and an a.out invocation to be reproduced.

Does this make sense? (Sorry about abusing net.lang.c)

Lew Mammel, Jr. ihuxr!lew