This text is about my various twitter bots. But more
importantly it is about how I work, and some realizations I have made
recently.

To me bots are mostly just characterized by the fact that they run as an
independent process. That is, I don't manually execute the program, then
wait for the result. As such they are useful because they are a way to see
many images over periods of time. After all, this can be useful when it
comes to generative art. Even if you can often control the output to a
large extent, some results—and some configurations—are
inevitably better than others. Having a bot output new results at regular
intervals can be a reasonably practical way of eventually getting some good
results from an algorithm.

I don't quite remember why I decided to start making twitter bots. However,
a contributing factor was probably @mothgenerator. Inspired by
this, I remember wanting to make a bot that generated different kinds of
lichen. For some reason I never really got around to that. Instead I made a
bot from most of my generative algorithms work at the time.

I named it @generativebot.
The @generativebot is in
some sense a summary of all my generative work up until late 2016. It
generates images based on almost all the algorithms mentioned in my essay
On Generative Algorithms. It is also the first
twitter bot I ever made.

Late in 2016 I also started feeling like my work had stagnated a little. At
the time I had no real explanation for this. My inspiration and interest in
spending time on this rather time-consuming project has varied previously
as well. So it was not really that surprising.

I have gradually come to realize that part of the reason why I was not
content with my work was what I hinted at in Some Thoughts on Generative Art:
I was studying mathematics (and physics) when I started working with
generative algorithms. As such I, more or less consciously, felt obliged to
model some kind of real phenomenon. This is in some ways a nice limitation,
and a good source of inspiration. It is also a somewhat arbitrary
limitation.

To some extent I think this realization was beginning to dawn on me after
having made Sand Spline, and the
walkers in Shepherding Random
Numbers. These still utilize randomness similar to what can be found
multiple places. (Notably, the walkers behave similarly to Brownian
Motion.) However, I use the behaviour more as a tool, and less as a
target. This difference might be subtle, but I have come to think it is
important.

Because I was starting to feel a little tired with my work I decided it was
a good time to learn a new programming language. Since I have been wanting
to learn a functional language for a while I chose Common Lisp. At the
very least I figured learning a new language could give me a different view
of things. In addition I had some hopes that Lisp could offer interesting possibilities
related to code generation.

So far my experience with Lisp can be seen through @sandpaintbot. Most of these
sketches are based on a few simple—sometimes quite geometrically
strict—rules. In addition I use the same kind of technique as in Sand Spline to get the nice
sand-like texture. In many ways these sketches are similar to my
previous work. They are a little different in that I have been more
concious that I am not really aiming for a particular natural
phenomenon.

My next bot, which is called @scratchpaintbot, evolved
while I was working on the @sandpaintbot. And as these
things often go, it was mostly an accident. I know this because when I
tried to reimplement the behaviour at a later time, it turned out I did not
understand what was happening at all.

Having said that, this bot is in many ways one of the most interesting
pieces of code I have ever written. Not because it is terribly complex or
sophisticated—it is not—but because it is able to produce a
wide range of interesting shapes. These shapes frequently look like actual
things. Granted, it is mostly reminiscent of rudimentary drawings of people
or animals. But it is
still capable of surprising me more frequently than any other piece of code
I have written so far.

At some point I hope to be able to train this bot to gradually produce
better, or more interesting images, but I haven't quite gotten around to
doing that yet.

Finally I will mention one more bot I have made recently. Since I basically
consider a bot to be a process that independently does something, I see no
reason why the Moment Gallery
is not really just another kind of bot. The gallery produces a new image
approximately every minute, and posts it on the site. This happens
regardless of whether anyone is currently on the site. This means that when
an image is replaced, it is gone "forever".

This makes Moment Gallery a
gallery you have to experience through time, not space. Which is something
I have not really considered before.

Another concern with generative art is creating a system that
continues to produced surprising results. Mostly, once I have created a
piece of code, I know how it will behave. As such it will not surprise
me, and it will become boring rather quickly. This is a topic for
another time. See 10,000 Bowls of Oatmeal problem in this
post.