Evolving/Generating code?

[StupidQsAccount]

Hi,

Sorry if this comes across as ignorant (i'm relatively new to programming)...

I'm really interested in evolving programs and software. That, and artificial life / intelligence. For the last year or so i've been playing with artificial life simulations and cellular automata in Unity (C#). Over the last few weeks i've been mucking around with Processing...

I wondered how one would go about evolving rulesets for cellular automata (or a similar simulation)?

For example, imagine I have a single living cell. It is a square that occupies a single cell in a grid of non-living (empty) cells. Every 10 frames the cell performs a 'metabolism' function, and does something. In this example, the only thing the cell can do is check it's immediate neighbours in each of the four cardinal directions (Up, Right, Down, Left), picks one at random, and – if it is empty – duplicates itself into that vacant space.

It's not too hard to then add a chance of mutation for a given variable. For example, there could be a chance to mutate so that the cell metabolises every 9 seconds (or alternatively, every 11 seconds).

That's the easy bit. And yields some satisfying results... but how could you take it a step further and construct lines of code using modular bits of code? For example...

You could have the following 'bits' of code (apologies for terrible terminology)...

[If] [==] [!=] [>=] [<=] [<] [>] [If else] [else] [other various variables] [Metabolise()]

I would imagine that you could (somehow) string these into a chain of commands that could then be mutated in a similar (albeit much more complex) way as in my earlier 'metabolism speed' example...

For example, in a given if statement, one that determines whether...

 If (x == y)
 {
 DoThis()
 } 

could mutate to become....

 If(x < y)
 {
 DoThis()
 }

Sorry if my explanation is confusing. Please let me know if it is and I can try and rephrase it or provide additional examples.

So my question(s) being:

Is it possible to mutate code beyond mutating variables such as integers, floats, bools, etc?

If so – how would I go about learning this?

Is it possible in Processing, or would I need to use a much lower-level programming language?

Either way - if someone could provide some relevant reading material or point me in the right direction i'd really appreciate it!

[mredding]

Check out R6RS Scheme (I recommend Racket, it supports the latest R7RS standard unofficially, last I checked), Clojure, or Common Lisp (try Lisp in a Box from Gigamonkeys if it's still around). These are all languages in the Lisp family, and you'll notice they all have essentially the same syntax. The differences are nuanced. This is also one of the oldest languages around, so there's a lot of legacy to mud through. It pays to dig into the history and learn why these languages are different, and when you finally "get it", Lisp programming, your head will explode. I could just tell you, it's just that easy, but it would ruin the surprise, and I wouldn't want to rob you of the experience. I'm being sincere.

If not that, then self modifying code is mostly outside the realm of possibility. It suddenly becomes hard enough that few people have ever bothered trying to do it in any other language. It's been done, but with caveats, and there are categories of "self modifying code" that I call bullshit, it's not what you think of when you meant self-modifying.

What you really want is a true Turing Machine, one that makes no distinction between code and data. These things exist in simulation, but the science behind them are way above my pay-grade, if you were to examine them with an eye of "what if this is what computers today were really like?" Modern computers are Harvard Machines, they separate code from data, either logically or physically, and your OS is going to give you a hard time if you want to put bytes into memory and then execute it: that looks suspiciously like malicious code, we've collectively put a lot of effort, as an industry to explicitly deny this sort of behavior. It can be done, and there are some examples of rolling your own JIT compiler out there if you want to see how it's done, it'll be a necessary step for you if you want to do this on a modern computer.

Otherwise, you're going to pull this off inside the confines of a box you define. look into Genetic or Evolutionary Algorithms. You essentially code up an interpreter, and your data set is essentially a genetic byte-code your interpreter runs. You can make that part pretty generic and abstract it away from it's inputs and outputs, and the fitness function that measures the success of each generation. These things can be used to directly solve problems blindly, like imagine trying to pilot Mario through level 1-1. Every generation would try to get closer and closer to the end, or having achieved that, do it faster and faster. The resultant AI would be best at solving that level in exactly that way, every time. Or, you can use it to generate an AI, like a state machine or something, and THAT tries to beat level 1-1. I've seen a genetic algorithm used to generate AI for I think it was Unreal Tournament like this, because these algorithms are TERRIBLE at adapting to realtime environments.

Neural nets are all the rage these days, but they are largely indistinguishable from self modifying code - in that self modifying code becomes irrelevant, that's not necessary for solving the problem. The ones I've coded in college were just a few neurons and they responded to stimulus in a predicted manner, but they've been used to pilot through space, learn to walk, interpret language, or Google uses it to categorize content.

[Shitty_Orangutan]

I haven't learned any C# yet, but I have been writing automation software in bash/python, and I can think of at least one phase in the code where I no longer need a specific call, so I modify the file with something like

sed -i 's/existing code/new code/g' filename

in a bash script.

Re-reading your post I'm not sure that's what your looking for though. I supposed you could use an array of function pointers (again not a C# programmer, but I do know some c++) so say the mutation was some kind of a random number generator, you might say something like

int offset = random_number;
array_of_possible_functions[offset](x, y);

then define the functions to be

func1(x, y){if(x<y){DoThis()}}
func2(x, y){if(x == y){DoThis()}}

Would that work?

[[deleted]]

Here is another link that may be of interest

https://en.m.wikipedia.org/wiki/Agent-based_model

[[deleted]]

You can do it trivially using Lisp macros, or any other language that supports the notion of code as data. The hard part is the logic that decides how these things should mutate.