Here are two descriptions written by Bruce. The second one can be found here : http://groups.google.com/group/rec.game ... 64397a131bmichiguel wrote:He started with GNUchess, and rewrote it completely. Nothing wrong with that. I remember clearly that he was really interested in the GNUchess move generator and how he improved it. I do not think my memory is playing me tricks:marcelk wrote:Dear Miguel,michiguel wrote:If we apply the same criteria to Ferret, Comet, and...
They were not the only ones that started as a different program and everybody considered them clean.
I don't know Comet, but I do remember Ferret quite well. Can you elaborate on your claim that Ferret started as a different program?
You might remember one of Bruce's first rgc postings about chess programming (I certainly do remember this being posted):
http://groups.google.com/group/rec.game ... c86d?hl=enYou might recognize this as a rather basic problem that only a beginning original author would ever encounter (and many have, maybe you also). Anyone who takes another program as a starting point will most likely never see this bug.Bruce wrote:Aug 14 1993
I ran some of the "Peasant" pawn endings from "How Computers
Play Chess" through my program, and came across a bug. The
search would fail high when the program discovered it could
win a pawn, so it would modify its aspiration window and try
again. This time it would fail low. It didn't expect this
case, and responded by treating this as a normal fail-low
condition, so it would set the aspiration window up for that
and try yet again, resulting in another fail-high, and so on.
[...]
What am I doing wrong?
Also Bruce at occasions has been very specific about his program with relation to gnu
http://groups.google.com/group/rec.game ... 5f59?hl=enI have always interpreted these postings as signals that he was writing his own programs from scratch. Now many years later you come here saying Bruce has been modifying gnu to make Ferret? I'm really surprised by this and I'm interested to know where it comes from.Bruce wrote:May 6 1996
I started writing a chess program because I was disgusted by the way that
gnu did this "sort".
Go to page 29 and you will see "Ferret was a derivative of Moreland's open source engine GNU Chess." (that sentence mixed up the name of the author)
Regarding Comet, you can see it in the ICGA website
http://www.grappa.univ-lille3.fr/icga/program.php?id=14
Miguel
There are more comments in this thread, including Bruce's assertion that he took ideas from many sources but used his own code.
http://www.chessgames.com/perl/chessplayer?pid=30003
http://groups.google.com/group/rec.game ... 64397a131b"Ferret dates from approximately 1990, although serious work didn't start until 1994.
The program is 100% original, although at the time I started I had access to the Gnuchess source code. That code was kind of messy and it was its messy state that inspired me to think that I could do better.
In 1994 I created something that could play a complete game of chess. The program entered Don Beal's uniform-platform tournament later that year (I emailed him a copy of the program), and it scored well. Surprisingly well, since the program had never played a game at tournament time controls before.
In late 1994 I discovered the ICC. Work immediately stopped on the program as I spent many hours using the program to play against other computers, and against strong humans including some grandmasters and other titled players.
During 1994 and 1995, I made the acquaintance of many other chess programmers, and I am indebted to these people, without whom Ferret would still be very weak. Included in this list are Bob Hyatt, Peter McKenzie, Dave Kittinger, John Stanback, Mark Lefler, Martin Zentner, Thorsten Greiner, and Stefan Meyer-Kahlen.
The program played in two ICCA events in 1995, which started a string that has remained unbroken except for the year 2000 event.
Ferret is a "normal" chess program. By that I mean that it uses alpha-beta full-width search, a quiescent search, a transposition hash table, an evaluation function that is called at the tips, and so forth.
It uses null-move forward pruning, and for that I am indebted to Chrilly Donninger, who did not invent this technique, but he made it accessible to the amateur community via an ICCA Journal article (Vol. 16 #3, September 1993).
The program uses numerous common extensions such as check extension, recapture extension, and single-response to check.
It also uses a sort of singular-extension that is loosely based upon the extension of this name that appears in Deep Thought and presumably Deep Blue.
The evaluation function is designed to catch common features without being slow, but it's slow enough that the program isn't particularly fast.
The program uses endgame databases of my own design and construction, but which aren't any better than the Nalimov, Edwards, or Thompson endgame databases. I wrote my own because I didn't want to take advantage of code written by others, since I felt that the program would be less mine if I did so.
The program has a series of special case low-material evaluation functions that it uses when endgame databases are not present, and in some cases when they are.
The program is written 100% in C, and is portable to any platform that runs any Windows-based operating system, including multiprocessor machines."
(by Bruce Moreland, chief programmer)
Ferret is a conventional null-move program (R=2, described by Donninger).
Other than null move, I do little pruning and extension tricks that cost a
little here, and save a little there (ideas from Hyatt, a single-response
extension that I deduced from an ad for a commerical program, and a few ideas
that may even be original, if this is still possible). I use a recapture
extension stolen from Hans Berliner via Bob Hyatt.
It's 32-bit, written in C, compiled with MSVC 5.0, and running on anything
that runs Windows '95 or Windows NT.
Quiescent search is constrained by a static exchange evaluator. This is
stolen from Cray Blitz or Belle, can't remember which.
The evaluation is done at the tips, and it has as much stuff in it as I can
include without slowing it down much. It doesn't compute mobility, but it
does try to understand when a piece is good or bad. It uses asymmetrical king
safety routines. Stuff is stolen from Chess 4.5 and GnuChess and everyone
else.
Move generation is done via a move table, a refinement of the technique used
in GnuChess.
It has all of the standard stuff including a hash table (two tables, one is
replace always, and one is replace if deeper or left over from a previous
search, this is stolen from Ken Thompson), a pawn hash table, a king safety
hash table (these last two are stolen from Cray Blitz description), killer
moves (don't know who invented this), history heuristic (Schaeffer), etc.
It has endgame tables that I built myself from a description by David Levy.
I've certainly left some people out. I've gotten ideas from Deep Thought but
offhand I can't remember which ones. I have also gotten a lot of help from
various amateur programmers, and the odd hint from a professional.
Node rate on a P6/200 is between 75K and 225K, >350K in weird cases.
Node rate on a 533mhz Alpha is maybe 150K to 400K, >600K in weird cases.
