Oliver, I saw your notes.  Thanks.

Daniel, looking at the rt.jar is an excellent idea, I'll give it a try.
Probably you are right, it will be best to limit the set of functions
used as building blocks, so as not to get overwhelmed.

All of the genetic algorithms I have seen are fixed.  That is, the
algorithm itself does not change, only the organisms.  In real
genetics, the algorithm is part of the genotype of the organism.  I
left genetic algorithms and started toward genetic programming in hopes
of solving this problem.  The pie in the sky is a program that is able
to identify its peers and breed with them (if appropriate) according to
its own set of code.  Thus, the code itself will be open to the genetic
operations, and could evolve.

I know it is an enormous task, but I like to dream.  Just getting a
code generator to generate a simple

public static void main(String args[]) {
  System.out.println("Hello world!");
}

becomes non-trivial because we are calling the System class,
referencing the static field "out", then using that field to call the
println method.  In order for the a program to select this code, it has
to be able to find it.  As I move down this path, I find that I am
writing a compiler, or nearly so.  Thank goodness for JavaCC.  Each
organism has a symbol table that it keeps for each compilation unit.
Other symbols available for use are discovered through reflection.  The
referenced set of symbols (the stuff the organism is actually using) is
one of the mutable parts of the organism itself.  The project
JRefactory gave some good insight on how to move things around...

Anyway, that was probably way more that either of you wanted.  For now,
my immediate target is to get code that will generate the simple
HelloWorld.  From there I'll move onto equations, and hopefully someday
onto code that can generate itself.

Randall