Development of Life in Programs

Hello, my name is William, the developer of a computer based experiment of massive proportions. I am a computer expert, studying in the art of programming software. A few years ago, in mid 2003, an idea came to me for a unique piece of software, the likes of which I had never personally seen, and as my recent studies have shown is still unique in some aspects. I was a student at the time, but luckily for me and my idea it was summer time, so I had the time I needed to make it grow into a healthy project.

THE FOUNDATION

Evolution and computer viruses have always been a fascination for me. Evolution was a fascination because of the possibilities it presented, especially to a creative mind. Computer viruses were intriguing because of their creative use of the computer and their similarities to real viruses and bacteria. It is these two fascinations that lead to the creation of this idea. If computers could simulate, in a basic way, creatures that were like those find in real life, then why not take it to the next level? Or rather, why not take it down to the basics, and give it all the tools it needs to grow into...well...anything. This lower level was the level that provided the foundation for evolution. And if I could get evolution to work in a computer, then that opens all the possibilities one could dream of. So the idea was born, and the conviction set, that I must take my idea from thought and put it into action.

THE IDEA

More specifically the idea was to make a program that acted like a very basic organism; like bacteria. Bacteria are very simple organisms, single-celled, though they sometimes live in colonies. Most bacteria don't do much else but reproduce, eating along the way to stay alive and...reproduce. So I sat down at my computer and began writing a program just like I always do, with the intent to write a program that does just what any bacteria does, reproduce. The problem, however, is that computer programs are very static; they don't change. Living creatures change all the time. Nature isn't perfect, but computers are (or try to be), so I had to force my program to be imperfect. And living creatures don't reproduce at the flip of a switch, it usually takes some time. So I had to incorporate all this into my program.

But what about its name? What should I call this program? Every good program needs a name, so I thought for a moment and took the most obvious solution. Program + Organism = Progranism.

AN IDEA DEVELOPED

After a lot of tweaking and tests I had finally taken my idea and put it into action. The result was very simple. There was one program, constructed from a relatively short set of instructions written in C++, that accomplished all I wanted and a few other things. First and foremost, after starting, the program sits and does nothing for a few seconds. This slowed down the program's progress. After that it made two copies of itself on the hard drive, never more nor less. While making these copies, manually, it would run a random number algorithm, like rolling a pair of dice, and decide if it should make a modification to the copies. This is like a "mutation", a very small change in the genetic code for an organism which often results in changes to that organism's behavior. Now, there's three kinds of mutations, both in the real world and in my computer program. Either something is added, something is removed, or something is changed. So, once the program makes its copies, sometimes with mutations, it runs them and finally quits. And that's about it, except for one small thing I added a bit later. Near the beginning of the program I had it check for a particular file. If that file was found then the program would quit without making copies. The purpose of this was to provide me a method of shutting down all the programs easily.

Details for the curious: The program sleeps for 60 seconds, makes 2 copies, has a 1 in 10 chance of making one mutation, a one in three chance for any of the 3 types of mutations, and a 1 in 100 chance of making two mutations. To avoid naming conflicts the program named its children like so: Progranism-%i%i%i.exe, where each %i is a random number between 0 and 999 (I think).

THE IDEA TESTED

With the program developed and it was time to do the real work of...sitting and watching it work. But first I needed a computer. One of the things about these programs is that they are dangerous. Like their real world counter parts they can cause bodily harm and make you sick. Except in this case it would make the computer sick. So I needed a test subject, and at first all I had was a very old computer from my earlier days. I dusted it off, got out the old monitor who had long ago forgotten the size of its screen and now displayed a huge black border all around, and fired it up. Luckily it still worked, so I got out a disk, copied over the program, and ran it. I waited a few minutes...and then a couple more minutes. I checked the folder, and saw it was working properly. A few minutes later and the computer froze, as most Windows 95 machines do. So I rebooted the machine to see how everything went, and saw that it had continued to work as planned. Mutations were formed, copies were made and run, and the machine had crashed, as I had expected it to. But obviously this wasn't going to work. If I could only run the machine for a few minutes before it cracking under the pressure then I'd go nowhere ... slowly.

WINDOWS XP TO THE RESCUE

Luckily for me, and my idea, I had spare computer parts and a copy of Windows XP. So I built a new, better, fast, stronger computer and put Windows XP on it. A better computer would help my tests in many ways, and Windows XP could hopefully withstand the pressure these programs put on it. I tried the same process as before on this computer and found the new environment to be all I had hoped it to be. The computer lasted a lot longer. In fact it never did freeze up completely, though it slowed down to a stale crawl, taking many minutes to perform very simple tasks like starting Task Manager.

OBSESSION

This program had quickly become very exciting, and a good thing that it did because that gave me reason to be obsessed over it. I started up a routine. Once the day began I would start the computer, fire up a few of the recent programs, and leave for two hours. When I returned I'd shut down the computer and inspect the system to see what new things had happened. These were, in fact, changing creatures so I had to keep my eyes open to see what was going on. Also I had to clean up all the old copies. After two hours the number of old copies was astounding, in the thousands. And the computer I was working on still wasn't the best, so everything was quite slow when dealing with thousands of files. But once my work was done I'd be left with about 800 copies and I'd try to run all of them again and start my routine over again.

THE FIRST FINDINGS

I wouldn't be writing this today if I had failed at my project. So obviously there had to have been some findings, right? There was plenty! I'd do constant tests on the Progranisms, trying to find out what they had turned into, if anything. I sought, and I found. My memory isn't perfect here, and I wish I had recorded these things, but at least one of the first discoveries was that the programs had chopped down on their waiting time. Do you remember how the programs waited a little bit before making the copies? Well a mutation had occurred which reduced this time, by a small bit. Considering that every two hours I reset the whole population it isn't surprising that beneficial traits such as this became very pronounced. The program that had acquired this new strength quickly took over and now every program was like it. Another finding was the destruction of my old fail safe. As I said earlier, at the presence of a certain file the programs would shut down. This no longer held true, as my research discovered, and then, as before, it wasn't long before every program was immune to my antics.

Does it stop there? Of course not! The programs continued to "evolve" into even more powerful forms. Obviously they began to reproduce even faster than before. Weeks later they began producing three copies instead of two. This was very obvious, because I noticed that as soon as I ran one Progranism the system would be saturated in only minutes, where as before it would take much longer. The original program created roughly 3,000 to 5,000 copies in two hours. This new breed of program created 15,000 and up copies in two hours. Remember, I made none of these changes myself, and did nothing to hand pick them. I did my same old routine and the Progranisms evolved these traits by themselves.

My final important finding is the best of them all. During one of my tests I did my usual thing and ran one or two programs to see how they ran, and if they ran because often they wouldn't due to a poor mutation. However at the end of my study I found that some of my test subjects were missing. I had around 20 test subjects in the folder I was working in, but by the end of the test there were far less. In other words, they had been removed, not by me, but by the programs I had run. Only one or two things could have happened. Either the programs had searched for and modified existing files (thus throwing off the modification date, so I would delete the file as if it were new when I tried to get back to only the original), or the programs deleted other files. In either case it's an amazing mutation. It means the programs can fight amongst themselves, possibly improving the natural selection process.

THE END

After awhile my motivation in the project began to wane and I stopped doing tests. Managing the tests was a very exhausting process, and if I ever wanted to see progress I had to do it all day long, checking back every two hours to clean up and run tests. So I had to put an end to those tests, and hopefully pick it back up again later.

THE FINAL END....REALLY

Over the next two years I explained the idea to various people, usually with exciting reactions, and sometimes I'd return to the project and run further tests. At one point I even started back where I left off. Luckily I kept a few archives of "batches", the 800 or so copies I was left with after cleaning up. So I grabbed the latest and started the tests again, this time with a program that manages the population, so the machine isn't as stressed. Of course I still had to do the cleanup and testing, which consumed a lot of my time, but I had a better computer (virtual machine on my main desktop machine) this time so it was easier than before. The results were rather disheartening, though, due to ... well, many things really. The fact that I had to restrict the population, and had to perform cleanup after several hours, caused many bad side-effects. Imagine this: Imagine that every idea that you have you have to write down on paper, otherwise you won't remember them. Everything from remembering to pick up the kids, to remembering to go to the bathroom. Now imagine that you could only hold a limited amount of ideas and every couple of hours someone came along and removed a whole bunch of them and mixed them up. You could live, yes, but sometimes you'll forget to go to the bathroom. The point is that this is similar to what I was doing to the Progranisms; disrupting all their wonderful ideas (mutations). In the end this was nearly the end of them. By the end of these tests the Progranisms had degraded their naming scheme, which is important in generating random numbers for future generations. For some odd reason the Progranisms with the smaller naming scheme were benefited and eventually overtook the whole population, no matter how hard I tried to keep the others alive (which were promptly deleted in the fights, mind you). So I was stuck with these programs that couldn't generate good random numbers. The result? Poor mutations, less "ideas". I'm not sure if I could have continued the testing and they'd eventually beat the slump, but I decided that was the end of those tests.

THE PENGUIN

For awhile I had thought about moving my tests to Linux, since it can be a far better environment for these tests. The programs are smaller, the system is far more powerful and stable, and shell scripts are amazing tools. So with the finding of an extra Dell computer I installed Gentoo, for the fifth or more time in my life, and began my tests anew! I had to rewrite the program for Linux, both to make it work on Linux and to improve upon it based on my previous studies. Also, thanks to the help of the Gentoo Forums community I was given some other ideas I had not thought of, and added those. Along with writing the new program I created a series of tools to assist me in my tasks. Make someone lunch once, and you'll be making lunch for them for the rest of their life. Teach them to make lunch, and you'll be cleaning up the kitchen for the rest of your life. Okay enough with the stupid joke; basically instead of doing the work myself, I took the time to write tools to do it for me forever. The tools were entirely automated and if they worked properly they would manage all my tasks on the machine forever, keeping everything under control. Unless of course the Progranisms mutated into something uncontrollable, but that would be for the best anyway.

The tools were very useful. They managed the population, cleaned up the old copies, made hourly archives, and did all of that without disturbing the population beyond having to removing a few to keep the population under the cap.

As of right now, late 2005, that's about where this project stands. I've run a few tests with the new tools, but a busy life has blocked attempts to really get things going again. Yes, even with the tools, there is work to be done. I've got to go into the machine from time to time to run the usual tests to see what mutations have arisen. I'm hoping that I can start again and see some results again, better than before.

WHAT I'VE LEARNED

It's incredibly difficult to fully study these programs, because of their sheer number and the limited number of tests you can run on them to discover what really has happened in the past, say, two hours of running. Mutations are subtle things, and the really good ones have to build up over time before anything visible happens, like when the program starts deleting other files. Still, I've thought over the subject quite a bit and try my best to dissect what's going on and learn from it.
First and foremost is the study of what caused the failure of my first experiments after I picked them back up. My meditation on this subject brought me to the conclusion that the limited resources of the computer environment was their undoing. The fact that the computer can only handle so much forces me, and it, to limit the population, killing off programs here and there. To those that have studied evolution this may sound like a great idea, but it would not seem so. Certainly, very powerful, evolutions take time, and take several leaps. If at any point during these leaps the programs carrying the traits die, the whole process is set back possibly millions of generations. Which is why death can be a very tricky subject. Obviously it is needed for good mutations to prosper, but it is also a roadblock to really good mutations. At first I thought it best to give the program the ability to mate with other programs. The reason is that with mating the programs could transfer their traits from a weak program, to a stronger one, and so the stronger program could carry it and continue the evolutionary process. I tried this in the Linux environment with a new version of the program that I wrote. The results weren't very good; they were incredibly unstable and difficult to test, so I had to throw that idea away.

In the mean time the best I can come up with is to try and provide the largest environment possible, and keep disruptive deaths to a minimum. So far, with the resources I have, the closest I have come is to use my current tool set, which is as non-disruptive as I can be while still keeping the system running. But there is a far better idea I have in mind which one day I hope to put into action. If I could get several test computers networked together, and then modify the program to use the network to transmit itself between the computers then I could create a very good environment. With more than one computer there's obviously more power, and with that there can be a larger population. Also, with separate computers, there is more protection for programs with new ideas that aren't necessarily helpful yet (which is the thing we want to protect). The traits of these programs can try to survive on one computer, while on the other they would have been wiped out.

Besides getting more computers for the project, I also need to spend some time learning ASM under Linux and Win32 and reverse engineering programs. Why? Well if I could decompile one of the mutated programs I could get great insight into what has happened to it and what it is currently doing. It's like looking at the gears in a clock to see how it works, rather that trying to figure it out from the outside. So I'll need to take a few classes in school on the subject, or at least find someone else who can do it.

I still have a lot of ideas to try for this project, and a lot of hopes. Only time will tell if any of it gets done.

DOWNLOADS

WARNING! I am not responsible for any damage these files may cause in any shape or form to anything, your cat, your house, your computer, yourself, etc. You agree to these terms by downloading any or all of these items.
That said, none of them are supposed to damage anything, except the batch of 1600 programs which, like all Progranisms, can do random and dangerous things.

CONTACT

BillCoder *at* Gmail.com