Darwin at Home

Snelson Interview & Gaming Elements

Mon, 18 Jan 2010 10:55:17 +0100

This podcast episode starts with an audio segment from my visit to Ken Snelson in New York in which we talk a little bit about the definitions of tensegrity, and how it has gotten muddled up over the years. The audio is from approximately when the photo below was taken, because he put this bag of bars on the table as illustration.

The rest of the podcast is all about the new gaming elements that I've come up with, some of them during a brainstorm with my 16-year-old son, who is much more of a gamer than myself.

Pounce: Not only will there be locomotion genes for the different directions as described in the previous podcast, but now there will also be a pounce gene. The idea is that a competition between predator and prey will be resolved by judging which of the two has the greatest altitude at the moment that their radii touch. It's kind of like in platform games like Super Mario where you pounce on things to consume them.

Time: I've finally worked out some of the numbers to be better able to talk about the two temporalities, slow motion on the server, fast evolution on the client. I've taken the server time to be leading, and chosen for having the server do one time sweep every 3 seconds, nice and slow. This works out to 1200 time sweeps every hour, so on the client where you can do a thousand or more time sweeps per second, your client-side evolution is experimenting with the coming 2 to 24 hours. A whole day is 28,800 time sweeps, which is enough to cover some terrain and do a good pounce, and on the client you can see this happen in less than a minute.

Thinking in these temporal terms, you realize that a properly executed pounce will take two or three hours to complete. I think it's potentially exciting to know that all this is taking place when players are offline, however slow motion.

Genealogy: When a predator critter pounces on a prey critter, the prey is consumed by the player behind that critter comes back to life again afterward as a mutated descendant of the predator. The consequences are interesting.

Capable bodies will reproduce their shapes in the population, so even if new players start with random genes (garbage in garbage out) and therefore with hopelessly misformed bodies, they can just be consumed by a good body and return as a descendant.. also probably a good body. Only the growth genes are inherited, so the new player will have to re-train the movement and pounce genes.

But what if you attack and defeat another critter who has already defeated a number of others and therefore already has a bunch of descendants? Well, the defeated critter becomes your descendant as usual, but their former descendants become your minions! There's motivation to attack and win.

It also implies that it will be fairly easy in the beginning for players to saunter around and "eat n00bs". Ha ha. Transforming them into viable bodies for their second life. Eating n00bs is easy, but eating a successful ancestor-of-many will be difficult and rewarding because you inherit everything they had while turning them into your descendant.

Above every body on the planet will be written their minion and descendant counts, so you can see what you're up against.

Parallel Universe Evolution.. first time on the surface!

Tue, 1 Dec 2009 17:33:30 +0100

Sometimes during such a deep dive, the degree of deferment of gratification drives you nuts. In my mind's eye there has been something happening for months... but only in my mind. The critter bodies were evolving with their new genetically-grown trunk shape and tetrahelix limbs and the fittest movers were passing their genes on to future competitors. They were walking on the surface of the sphere, and maybe even swimming in the water.

Well after such a long time building and tuning the building blocks of the Darwin at Home game, today for the first time my eyes have actually seen it happen! Here's the first screen shot:

Above you see a critter, with its white "torso" grown by the branching symmetrical tetrahedron process, and its colorful tetrahelix limbs (stress is color). When the evolve key is pressed, the "Parallel Universe" evolution starts to happen slowly. Thirty mutants are pitted against each other to reach a goal, which is a direction I've given.

What you see here is the full rendering of all of the competitors after a number of generations, starting to distinguish themselves ever-so-slightly by hobbling slightly closer to their current goal. You have to keep in mind that these critters are all existing in the same space, but they do not experience each other in any way. Parallel universes.

To really get them hopping I have to turn off the visual so they can buzz at many times the speed, in "accelerated time". Wow, but it's nice to see this working, finally.

JOGL & Developer Friendliness

Sat, 28 Nov 2009 14:12:09 +0100

This is kind of a note to myself, after searching around quite a bit to find out what the hell is happening with JOGL. I found this link:

http://download.java.net/media/jogl/builds/archive/

Last week I visited my friend Sam and got him set up with his development environment on his fresh macbook pro, and found out that it was quite a challenge these days to find and install JOGL for development. It seems a little confused, so I'll have to make it clear somehow in documentation how to proceed once I figure it out myself.

Also, it became obvious that I really needed to get around to restructuring things to make them more developer friendly. I'm also a little tired of the performance of sourceforge these days, so I'm making a fresh start with a new GPL v3 license and by setting it all up at Google Code:

http://code.google.com/p/darwinathome/

While moving the code over from sourceforge, I did a lot of restructuring and renaming to make it a lot more of a consistent whole. Soon it should be a fairly easy setup for developers.

Catching Up - Getting Closer

Fri, 27 Nov 2009 18:06:48 +0100

There has been a lot of coding between the previous podcast and this one, just not a lot of podcasting. Time to do a little catching up.

It's not that it's so late at the office, it's that the winter solstice is approaching so it gets dark pretty early. In this podcast episode I try and summarize the work I've been doing since the summer. It has been fairly difficult to get all the parts working but the results are satisfying.

This is a side project, although I've been able to invest a whole lot of time in it the last while, so I don't feel terribly guilty about having release dates slide.

A toast, to enjoying the process and to hopefully getting it just right eventually!

Long Live JOGL!

Thu, 26 Nov 2009 09:29:50 +0100

Wow, I hadn't realized that the Sun Microsystems takeover by Oracle had thrown the JOGL (Java-OpenGL) project off the rails, at least until it returns in another form somehow. Unfortunately I depend upon it.

This thread shows what's going on: JOGL is Dead, Long Live JOGL!.

Opening Triangles to Grow the Tetrahelix

Sun, 12 Jul 2009 12:04:11 +0200

This podcast episode is another walk in the bush, and since I got a couple of days to work on the project this week, some solid progress was made. This time my focus was on the geometry, since growing the bodies based on random genes has not been really satisfying so far.

The reason growth was producing such a large proportion of ugly bodies was that it was just adding individual tetrahedrons where faces were, and tetrahedrons tend to curl up into each other when they grow randomly. Enter the tetrahelix!

So what I did was built an algorithm to grow tetrahelix segments. It starts on a triangular face, and then basically opens up the triangle as if it were a book. Then the raised "front cover" becomes the back cover of the next book you can open, and so on. The tetrahelix grows in a very attractive way like this, and the bodies produced with tetrahelix segments are much nicer!

The image above shows my current test laboratory where the blind watchmaker code is building bodies out of tetrahelix segments. Many are still failures, but enough of them have just the right twists and turns in their limbs to give them great locomotion potential. Note that there are buttons saying kill this one, because when one gets killed it is replaced by a mutation of a randomly chosen other one. This is a fun way to aesthetically select a body (like dog breeding?) and it might eventually end up being part of the game.

Tetrahelix segments have a really beautiful rotation in them which produces attractive limbs because it results in all sorts of funky angles depending on when you stop. From a triangular face there are six different directions in which a tetrahelix can grow: Three rotations of the triangle, each with two chiralities (left handed, right handed).

There are of course some nice reference pages about the tetrahelix shape if you feel like digging.

Finally I have a smoothly working body generation process which gives lots of angular diversity to the limbs. All hail the Tetrahelix!! Now I can get back to the game at the macro level.

Bird Battle and the Exciting Unit Test

Sun, 7 Jun 2009 22:37:52 +0200

On this noisy walk in the bush I start by giving a listen to the remarkable spring wildlife in the bush near our place on the east end of Rotterdam, and then I explain a unit test.

Now, what could be more exciting than a unit test?! I know. Actually, there's a very good reason why this unit test is absolutely crucial to building the infrastructure for the game, so there's no way around it. It's too important to skip over.

TestBeingMarshalling.java

Rearrangement, in Preparation

Sat, 18 Apr 2009 11:57:53 +0200

Good news for Java developers!

I worked all friday on the DaH code, rearranging everything so that I can start the final construction of the online game. All the parts are now available under one tidy subversion directory:

svn co https://fluidiom.svn.sourceforge.net/svnroot/fluidiom/dah/

If you can figure out how to install JOGL on your machine, you should be able to watch the program evolve in the coming weeks.

I had to separate off the core DaH classes into their own maven jar artifact when I realized that this exact same code must work on both the client and the server.

This is getting more fun! Just a few more sessions and I'll probably be able to put a demo online.

Marshalling & Persistence

Thu, 27 Nov 2008 09:45:13 +0100

In this podcast episode I continue to describe the developments on the way to the new version of the online darwinathome program. Marshalling is all about transforming fabrics (bodies) to a binary format and back into object graphs again. The Fablob (Fabric BLOB) class does the work and it can store fabrics in either lossy or non-lossy form, depending on what the situation demands. It will be used for database storage, http communications and also for fabric cloning (during evolution).

Also I've put together a datamodel using Hibernate and Postgres, and it maintains the genaeology of the fabrics; the parent-child relationships so we can store lots of fabrics in the database and we can brows through the ancestors of any fabric to see how it developed.

Spherical Physics and Rewrite of Fabric class

Thu, 20 Nov 2008 10:01:33 +0100

In this podcast episode I describe two of the improvements that I have been able to make in the past couple of months during evenings and weekends. Time has been tight lately since I've been working intensely on my contract with the team at the European Library to finalize the site which is finally going live right now. The project is called Europeana and it functions as a search engine for a mountain of metadata about european cultural heritage collections from all over the continent.

There are now two different variations on the Physics class (two subclasses) which are identical except for the way they treat gravity and the walking surface. The original one, VerticalPhysics, has gravity pulling in the -z direction and the floor is the plane where z=0. The new physics has gravity pulling "inwards" and the floor is actually the surface of a spherical planet. The critters can now exist and move around on the sphere surface, and therefore they will tend to encounter each other for the first time.

Also, I've managed to implement a really nice simplification of how the Fabric class works. Fabrics used to be just joints and intervals with these two things mutually pointing at each other, so it was possible to ask a joint for the intervals that meet there. This involved a lot of bookkeeping when the fabric was being edited, and things started getting complicated when I introduced "faces" (trianglular), "tetras" (four joints), and even "vertebra" (those tensegrity modules). Should a joint also be aware of the faces, tetras, and vertebrae to which it belongs? Too much work.

The way the Fabric class works now is that it's centered around the joints, and they hold no references to any other entities. Instead collections of faces, tetras, and vertebrae can be extracted from a fabric using what looks a bit like an SQL query. Give me the tetras connected to joint X. Since it's all in memory these queries are lightning fast, and it makes the code quite a bit simpler.

I've built quite a bit of other stuff already too, but I'll talk about those things in subsequent podcasts soon, now that I have a bit more time available. Stay tuned!

Forking and a pinch of Intelligent Design

Sat, 11 Oct 2008 15:26:24 +0200

In this podcast I get on to the next step in the blind watchmaker development, assuming the first three steps described in the last podcast are meeting no resistance.

Sensory observations are to be communicated back to the genome interpreter in the form of instructions that return nuances.

We could choose among different subroutines, but in this episode I try to make a case for introducing symmetry.

Blind Watchmaker

binary genome
nuances
cost
forking
- Instruction return values
- void or null means continue normally
- return nuance means make a choice
- fork could choose different genome paths
- ... but would it be legitimate to introduce symmetry??

Blind Watchmaker Birth

Tue, 7 Oct 2008 22:17:29 +0200

In this podcast episode I get into the first details of how the Blind Watchmaker works, since the design seems to be solidifying into something that looks tight and actually has proven to do something, building D@H bodies. The next step, as I said at the last Greythumb gathering, is to get the blind-watchmaker code to also manage behavior.

The plan now is to go step by step from the very basics of the blind watchmaker development, and see if people can contribute ideas and maybe code as we go. At least people can stop me from doing stupid things, if they're listening.

Blind Watchmaker

Generic Binary Genome & Instruction Sets
- Bit strings
- Invented but remembered
- Short bit string --> method call
Nuance parameters (with bit precision)
- Spectrum between two ends
- They come from the genome
Cost
- Default is bit-length
- Instructions represent expenditure
- Observations are acts too

Bits Building Bodies

Sun, 21 Sep 2008 20:47:03 +0200

Done with building the tensegrity by hand, I've decided that for now it's too difficult for me to evolve anything interesting with tensegrity shapes. There's a lot of design to be done with them, And I'll be continuing that most definitely, but for evolution I'm going to search elsewhere

In this episode of the podcast I talk about this and the direction that things are going now. I've returned to the code that makes up all the previous versions of Darwin at Home and I'm working intensely to distill the best things from them all into a toolbox that can be used to build a number of applications.

Next tuesday the 23rd of September at the Dutch Royal Academy of Visual Arts in Den Haag we will be holding the second Greythumb Netherlands gathering. If you're interested, please join the group online.

I wanted pretty badly to present something interesting at that gathering, and finally my work of the last while is starting to pay off because I've been able to build a program where "bits build bodies". The blind watchmaker project with its genetic system, is now connected to the new fluidiom-core classes I've been distilling, and producing lots of interesting geometrical phenotypes.

The Blind Watchmaker

Thu, 17 Jul 2008 23:36:09 +0200

In this episode of the podcast I once again go for a walk in the bush, and this time talk about the change in direction that the Nuance Engine has taken, as well as about the very first Greythumb Netherlands get-together.

Here's a picture of WORM, where Greythumb NL was held in June:

..and here is the duck (a WORM-sponsored work of art, for you cultural barbarians!)

I've decided to change the name of the project to Blind Watchmaker because I no longer like the association "engine", and it's one of the most thought-provoking archetype memes that Dawkins introduced with his book of that name.

I'll save going into the actual Blind Watchmaker code until I've got it stable enough. It's going to be a neat system, which lets you submit instruction sets and takes it from there.

ecodesic

This is the first crack at creating a mini-universe in which the Blind Watchmaker system will be demonstrated. The little balls you see represent creatures that move around on the surface of the planet. Listen to the podcast to hear about how I plan to try and turn this into a Blind Watchmaker programming competition.

Tensegrity World Applet

Thu, 19 Jun 2008 13:56:55 +0200

Let's try something new! I found out about a trick that allows me to put this JOGL application into the form of a Java Applet which makes running it more straightforward since it just appears on a web page.

Please give the new version of the Tensegrity World Applet a try and let me now if it works for you without a hitch. You are asked to approve the JOGL extension which comes from Sun Microsystems, but that shouldn't be a problem.

This applet shows growing tensegrities, and they are growing on the basis of "Cell" objects which are each attached to individual tensegrity segments. So far the code of the cell is very simple. It just waits a short while, sprouts a new segment, and then vulcanizes itself. The new segment is given a new cell, which does the same thing only it vulcanizes slightly earlier than the previous one. Eventually this will all be orchestrated by a genome.

In this episode of the podcaset I talk about what this applet is doing, and what it should eventually develop into. Lots of work has been going into getting the tensegrity code prepared to work with the Nuance Engine, although this version doesn't yet show the connection. That will take a little more work.

For those of you in the Netherlands, don't forget the upcoming Greythumb NL Gathering at WORM! I hope to see you there.