Posted by Paul Kline to the Usenet newsgroup rec.games.corewars on 15/02/98
___________________________________________________________________________

I might be old enough to have played DARWIN :-)

We played Darwin as part of a course in Artificial Intelligence at Iowa
State University in Fall 1973.  I know they played it for a couple years
after that.

The instructor was one-of-a-kind.  He read about Darwin in a magazine and
sat down at a card-punch machine and wrote an interpreter from scratch.
The class then submitted entries in card-deck format through a window into
the computer room, and picked up a listing after an hour or so (kind of
like PIZZA [1] :-).  After one semester very simple programs were
performing best.  As I remember a small replicator that quickly overwhelmed
most other programs was the overall winner.

DARWIN had some of the same instructions [as Core War], but also some more
powerful ones.  A single instruction replicated and started a program at a
given location, there was no other way to replicate, you copied the whole
program.  Another instruction gave you the distance to the next live
program in core.  Another gave you the Identity Number of a program running
in core.

Program boundaries were well-defined.  No two programs occupied the same
space.  The first few instructions of your program were reserved for core
information, like your Identity Number (so you could tell your descendants
from your opponents), Core Size, length of your program, and your starting
position.

There was a Kill instruction that you used to kill an opponent, if given
the proper address it would kill that copy of that program.  But programs
were allowed to designate a small number of 'protected' locations.  If you
tried to Kill one of those there was no effect.  And if you tried to
replicate yourself into occupied space you died.  After being killed, your
instruction space was wiped clean.

One devious strategy, called Polio, was to change the opponent's Core Size
register to about 10 (instead of 10000).  That usually left him searching
for unoccupied space in 10 bytes instead of the whole core.  I believe the
class always ran DARWIN in multi-warrior mode, though you could submit
tests against single opponents.  There was an automatic adjustment to core
size depending on the number of opponents submitted.

I seem to remember that DARWIN was not multi-threaded like CoreWars.  A
program copy ran until it died, replicated, or scanned a protected
location.  If you looked at or attempted to kill a protected location,
control transferred to that program.  If you died control passed to the
next program in queue (not yours).  Surprisingly there seemed to be no
clear advantage to going first, you had to scan core to find free space for
copying, you only got to copy once per turn, and scanning a protected
location caused you to lose your turn.

State-based intelligence was attempted by some, keeping track of what had
been attempted in case you lost your turn, but in a multiwarrior
environment there could be major changes in the field before you got
another chance.  Imps would be impossible, given the copying scheme and the
rule prohibiting executing an instruction outside the body of your program.
Dumb bombers gave up control too often, replication was _important_ in a
multi-warrior game.

Comparing Darwin to Core War, the fixed data locations were more extra
baggage than help - they were too vulnerable to attack.  Multi-threading is
better.  Respecting program boundaries seems like an interesting idea.  In
general I like Core War's primitive instruction set, you can do anything
with it you can dream up.

Paul Kline - pk6811s@acad.drake.edu
___________________________________________________________________________

Footnotes:

[1] PIZZA - an on-going King of the Hill Core War tournament available on
    the Internet at http://www.ecst.csuchico.edu/~pizza/koth
___________________________________________________________________________