Lambda the Ultimate

The idea centered around adaptive computations being used in embedded systems. And since 'adaptive' is a rather obtuse word I will attempt a narrowing of the context in which I am speaking of.

The idea centers around an s-expression syntax, extending an evaluator to allow for non-determinism (and functions used in stating facts, rules, and queries), and incorporating the collection of metadata for use in reflection.

The proof-of-concept that I am laying out is statically typed, currently works on top of the KVM, allows for the inlining of byte-codes, and only computations that deal with integers, booleans, and characters.

My goal is to introduce a problem within the code, that defies rules in relation to facts defined then attempt to make the code modify itself by recognizing the problem based on the rules broken.

I see the main area of trouble coming from pushing the reflective cabilities of a class file, and the KVM itself, for I am completely unaware of its depth of introspection. I am also doubting the reason for using an s-expression syntax when it will be the byte-codes that will have to be modifyed and written.

None the less, I have quite a few ideas rushing my head; too many to include in this posting in fact, but in spite of my rather vague posting I would like to request any probing or criticisms from the people here on LtU.

Best regards,

M. Stahl

this is just vague advice offered in case it's helpful. i don't mean to say that your particular ideas are no good (i didn't even understand them completely) and realise that you may know much more than me. it's just what i've picked up with my own amateur experiments and occasional book (i don't know if you've read norvig's book on ai/lisp - it's pretty good).

also, there's no need to include physical robots. unless you want to meddle with hardware, life is simpler inside a simulation - you can repeat experiements much more easily for example.

and, finally, in my (limited) experience self-modifying code, while really fun, doesn't seem to give anything that, once you finally understand the problem, you couldn't do with separate data.

having said all that, maybe the best thing about self modifying code and introspection and playing around with all these cool ideas is that it's so much fun that you do learn a lot (does that sound condescending? not meant to be - very aware you may know much more than me!)

You might be interested in constraint-based programming. I'm a bit unsure of what exactly you're trying to do, but it sounds "given a problem and these constraints, find a solution that solves the problem and doesn't violate the constraints" (an equally vague description) which is basically what constraint-based programming is all about. You can find a lot of research in this area at The Cork Constraint Computation Center.

This seems like a nice intro - Constraints are a declarative knowledge representation formalism that allows for a compact and expressive modeling of many real-life problems. Constraint satisfaction and propagation tools, as well as constraint programming languages, are successfully used to model, solve, and reason about many classes of problems, such as design, diagnosis, scheduling, spatio-temporal reasoning, resource allocation, configuration, network optimization, and graphical interfaces. - http://www.ics.uci.edu/~dechter/publications/r85.html

And here's a lighter article that explains Satisfiability - http://sjcomp.virtualave.net/files/compsci9703.html

The author of the second article looks to have written a pile of interesting stuff - http://www.amsci.org/amsci/other/BPH.html (see loinks at bottom of page).

From this list - http://www-course.cs.york.ac.uk/cop/links.html