I have had this little text lying around for a while. It was written as much
as a way to force myself to articulate this, as for as for anyone to read.
Then I thought I might as well publish it. Maybe this has no merit, or maybe
it has already been written. Here it is regardless.

One of the challenges of doing generative work is how to get more
interesting results. The algorithms you write will do what you design
them to do. You might not fully understand all their aspects, but even so:
the algorithms are not creative, and they do not improvise.

So what is a possible strategy for generating more interesting results?
Here are three components that I think are needed.

First you need a set of rules. These rules should be able to create
structures similar to what you want your system to create. I tend to work
with geometry, so to me this would be rules that can generate
geometric structures; meshes, splines or other kinds of shapes. This was
partly why I started working on SNEK.

After that you need a way to introduce variation. I often find that my
programming mistakes yield interesting results. Hence I think that one
possible strategy is to introduce errors into the rules of your system. There
are two obvious ways of doing this. One is to try to find a way to introduce
errors as you apply a given rule. Another is to have a separate stage in your
system that messes with your data structure somehow.

Finally, since you probably want the system to work over time. You need to
give the system a way to correct itself to some extent. Depending on what
data structures are involved you will need to maintain some level of
integrity.

Obviously none of the suggestions above tell you how to encode and implement
this. Unless anyone can find a good way to do that then these suggestions are
pretty worthless. However, I have a certain hope that someone will be able to
do (at least some of) this eventually. Maybe someone has already?

There is a lot of talk about Neural Networks at the moment, and I think
perhaps this is a possible place to start. My limited understanding of how GANs
work makes me think that to some extent they do this already.

If you can find a way to encode these properties, then you are only
left with the final challenge of deciding what interesting actually
means.

Whatever interesting means is a big discussion alone, let us
ignore that for now. I touched a little on this when I wrote about my
twitter bots.

A favorite idea if mine is to introduce actual programming mistakes,
but I don't really know how you would go about doing that in
practice.