On Fri, 2011-08-12 at 16:30 -0700, pmbauer wrote:
> +1
> 
> On Friday, August 12, 2011 3:16:15 PM UTC-7, Sergey Didenko wrote:
>         BTW, Is there a case when AI self-modifying program is much
>         more elegant than AI just-data-modifying program?
>         
>         I just can't figure out any example when there is a lot of
>         sense to go the self-modifying route.

Clearly both are equivalent in a Turing sense.

If you are 6 foot tall but "modify that in data"
so you are 7 foot tall and always report yourself
as 7 foot tall then there is no way to distinguish
that from the records. Yet there is a philosophical 
difference between "being" and "reporting". AI involves
a lot of debate about philosophy so expect that.

Learning, by one definition, involves a permanent change
in behavior. This has to be reported in some way. Since
programs are data in lisp this is something of a semantics
debate. Is the program "really changed" or just "reporting"?

Consider a more "advanced" kind of learning where we use
genetic programs to evolve behavior. Clearly you can do this
all using data but it is a bit more elegant if you can take
"genes" (i.e. slices of code), do crossovers (i.e. merge the
slices of code into other slices), and get a new mutated set
of "genes". These can be embedded in chromosomes which are
just larger pieces of code. Real cells don't use a "data
scratchpad", they self-modify.

The resulting self-modified lisp code has execution semantics
defined by the language standard (well, CL has a standard).
The "data representation" does not have standard semantics.
Data has semantics relative to the "master smart program thing"
you wrote. 

It turns out that self-modifying lisp code is both interesting
and elegant as the "data" is "itself", not some reported-thing.
There is a reason lisp dominated the AI world for so long.

Many centuries ago I authored a language called KROPS (see
[1] below). It was a program that allowed you to
represent knowledge using both subsumption (KREP-style) and
rules (OPS5-style). Adding a new piece of knowledge caused it
to self-modify in a way that allowed both execution semantics
and "data" semantics. KROPS is way too complex to explain here
but it was very elegant. IBM built a financial and marketing
expert system in KROPS on symbolics machines. The point of all
of this self-trumpet noise is that I don't believe I could have
had the insight to build it in a "data" model. I just let it
build itself to evolve a problem solution. There was no data,
only program.

This isn't intended to be a debate about WHY we might want a
self-modifying program. It is a question of whether Clojure, as
a Lisp, is sufficiently well-crafted to allow it to self-modify.
It has been done in other lisps but I don't yet know how to do
it in Clojure. If you only want a "master smart program thing
that reports data" that's perfectly fine. You could write that
in any language. 


Tim Daly
d...@axiom-developer.org

[Daly, Kastner, Mays "Integrating rules and inheritance networks
in a knowledge-based financial and marketing consultation system"
HICSS 1988, pp495-500]


-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Reply via email to