## Rybka 1.0 source code

Discussion of anything and everything relating to chess playing software and machines.

Moderators: bob, hgm, Harvey Williamson

Forum rules
This textbox is used to restore diagrams posted with the [d] tag before the upgrade.
bob
Posts: 20916
Joined: Mon Feb 27, 2006 6:30 pm
Location: Birmingham, AL

### Re: Rybka 1.0 source code

Rebel wrote:
bob wrote:
Rebel wrote:
bob wrote: The most likely scenario is that the code was copied,
And there we go again.

1. When you point out that Rybka evaluates different than Fruit, the most likely scenario is that it is just a speed-up.

2. When you point out it would be flat-out proof if Fruit's QUAD function would have been in Rybka but it is not, then again, a speed-up!

3. When you point out that 4 expensive loops in Fruit that calculate mobility is actually one instruction in Rybka then the explanation is bit-boards.

There is ALWAYS a most likely scenario (to use your own words) why things are different in Fruit and Rybka.

The premise is, whatever differences are found Vas copied Fruit because we will find a most likely scenario.

That's not objective.

I could go on with more than 20 of such points.

How many are needed for a different look ?

40.. 60.. ?
First, how about some correctness. On mobility, it is NOT "one instruction in Rybka." Done pointed this out a half-dozen times. Where does "attacks" come from? A pair of complex table lookups that involve taking two different 64 bit values, shifting, then anding, then indexing into two separate (and large) arrays. That is not "one instruction." Now you have the "attacks" variable that has the set of attacked squares. So how about keeping things technically accurate as opposed to distorted to make Rybka look far different than Fruit. The mobility is quite simple. Agreed. It is less simple if the multipliers are proportional. It is less simple if it is done for all pieces (where some programs do it just for one or two pieces). It is less simple if there are other ways to do mobility that are different. We are talking about the "entire picture" here. Not the 4 loops in Fruit, or the pair of rotated bitboard move generations in Rybka + a popcnt instruction. The whole picture. And they both look like a Mona Lisa.
First, how about some common sense ?

FRUIT:

Code: Select all

``````         case Bishop64&#58;

// mobility

mob = -BishopUnit;

for &#40;to = from-17; capture=board->square&#91;to&#93;, THROUGH&#40;capture&#41;; to -= 17&#41; mob += MobMove;
mob += unit&#91;capture&#93;;

for &#40;to = from-15; capture=board->square&#91;to&#93;, THROUGH&#40;capture&#41;; to -= 15&#41; mob += MobMove;
mob += unit&#91;capture&#93;;

for &#40;to = from+15; capture=board->square&#91;to&#93;, THROUGH&#40;capture&#41;; to += 15&#41; mob += MobMove;
mob += unit&#91;capture&#93;;

for &#40;to = from+17; capture=board->square&#91;to&#93;, THROUGH&#40;capture&#41;; to += 17&#41; mob += MobMove;
mob += unit&#91;capture&#93;;
``````
RYBKA: (taken from Zach's document)

Code: Select all

``````            mob = popcnt&#40;attacks & ~own_pieces&#41;;
``````
Common sense states that when you write code 10-20 times faster, pack 4 expensive loops into 1 instruction you are the better engineer. Furthermore there is no copyright on chess knowledge, no copyright on commonly used concepts such as mobility especially not when it's explained in detail on the Wiki chess pages.
You continue to show you have NO IDEA how rotated bitboards work. That "attacks" variable used does not just "appear" out of the clear blue sky. It has to be computed with some expensive operations. Yet you CONTINUE to say "4 loops replaced by one instruction." Outright false. If using popcnt() makes Vas a better engineer, I was a better engineer 30 years prior to him, because we used that SAME instruction on the Cray series of computers, the first computers to have a popcnt instruction. This has NOTHING to do with "better engineering". Vas took an idea that has been around for (at the time) 40 years (bitboards). And some things are faster using them, some things are not.

http://chessprogramming.wikispaces.com/Mobility
Second, your goal appears to be to dream up wildly implausible explanations (0.0 is an example) as opposed to "Occam's Razor" and realizing that the simplest and most believable explanation is likely the correct one. The chance of so many implausible explanations being true is essentially zero, as you multiply all the probabilities, and the more there are, the smaller the resulting probability since all are less than .5 in reality.
OK, your version of "Occam's Razor" vs mine.

http://www.top-5000.nl/evidence.htm#C6

Chapter 6 - The notorious 0.0 case.

It's about time-control and the accusation that Vasik "copied" that from FRUIT.

In a nutshell:

FRUIT's time control is fully FLOAT based;
RYBKA's time control is fully INT based.

And yet in RYBKA's time-control a FLOAT value is found -> 0.0 which is odd indeed.

The accusation is that Vasik "copied" the FRUIT time-control, converted FLOAT to INT to obfuscate (there is that pesky word again) the FRUIT origins. But in the process Vasik overlooked one instruction, the 0.0 and so a trace of copying was left.

Its rebuttal:

From the open sources I studied, some even before Rybka appeared, have a Fruit alike floating point driven time control that can deal with 1/10 or 1/100 of a second, an integer driven time control certainly can not. It's only logical to program your time control with decimals unless you want to lose long blitz games on time or make strange concessions during the very last seconds on the clock.

Interesting and silly comment (integer can not deal with .01 seconds.) You DO realize that the operating systems (both windows AND unix) use integers to report time, exclusively? My timing resolution is 0.01 seconds. I use integers. So that statement is purely nonsense. AGAIN. Why don't you look up the system calls to obtain time on windows and unix. You can get microsecond accuracy "using integers". In fact, you can ONLY use integers to access system time information. System doesn't report it in floating point values. Your entire argument, specious and irrelevant in the extreme. As usual. You make an absolute statement as fact, when it is exactly the opposite (can't use integers to measure time in .01 second intervals). You can ONLY use integers, in fact, unless you convert after obtaining the time from the system. Jeez, the stupid statements you make to try to explain away the unexplainable...

If Vas copied Fruit then why did he move from a superior (float) time control to an inferior (integer) time control with known issues? This makes absolutely no sense.

Because integers is the ONLY way to access system time, perhaps??? Anything else requires a conversion from integer to float, perhaps???

But far more important

Compile the following code with any of the MS compilers.

static int T=1;
void main() { if (T >= 0. ) T=5; }

It will produce the same code as 0.0

or compile

static int T=1;
void main() { if (T >= .0 ) T=5; }

It will produce the same code as 0.0

Meaning the 0.0 accusation falls apart, what was strong evidence for 4-5 years is now minimized to overlooking a dot typo.
A "." that requires an incredibly implausible set of actions to introduce in the first place? Maybe a space alien slipped in and hit the "." key with a ray gun while Vas was typing, but had looked down to pick up a soft drink or something?

Missing 1 pixel on a 1920 - 1080 screen.

That's no good reason to strip someone of 4 world titles and brand him as a fraud in the worldwide media.

By own experience I know the impact 0.0 had on me, an atomic bomb and from talks with other chess programmers I know they took the same road as me, after the 0.0 revelation suddenly programmers started to take the accusations more seriously.

But only a dot can be proven.

No FRUIT copying.

I recently had a discussion with Vas and on this issue and he said:

There isn't much I can help with here. I don't know where the 0.0 came from. It's definitely weird/wrong.

Rybka was UCI from the beginning, even back when everybody was using WinBoard. I would say that every two to three years I do a big cleanup of this code. This might take a few hours, and then I won't touch it until the next time. My first UCI parser actually used inheritance, I was extending UCI to do some testing, but that was gone even before Rybka 1.

Best regards,
Vas

I have checked Vas' words. Indeed the pre-Rybka version 1.6.1 which Vas entered in a tournament without permission of Crafty author Robert Hyatt is UCI. Crafty since day one is Winboard only. Meaning Vas wrote his own time control long before Fruit 2.1 appeared. Furthermore the pre-Rybka 1.16.1 contains on 18 occasions an odd kind of flag with the value "0x7fffffff" also one in the UCI time control.

Or meaning he copied an even EARLIER version of Fruit's UCI code?

As "999999" is a signature of Crafty "0x7fffffff" is a signature of Rybka. Checking Rybka 1.0 beta for "0x7fffffff" the value only appears 2 times, one again in the UCI time control. The evidence is presented here, a more detailed explanation here.

As "0x7fffffff" is not found in Crafty or Fruit it's safe to conclude Vas wrote his own time control and the accusation Vas copied Fruit's time control, converted float to int to hide the Fruit origin is pretty much debunked.
Adding one line inside a block of 20 lines means the other 20 could not be copied? On which planet is that true, exactly???

Zach Wegner
Posts: 1922
Joined: Wed Mar 08, 2006 11:51 pm
Location: Earth
Contact:

### Re: Rybka 1.0 source code

The bottom line is that Rybka 1.6.1 (April 19, 2004) has UCI and why would anyone copy something he already has?
If you really have R1.6.1 (not sure how you would get it...), then please stop spreading misinformation about it. The UCI parsing code is vastly different. R1 has a structure extremely similar to Fruit, while R1.6.1 uses UCI code derived mostly from Crafty's option parsing stuff.

Also, in your page above, why did you delete most of the Fruit code? That certainly makes the comparison much harder...

For all this 0.0 nonsense, one point that it seems everyone is forgetting is that right next to the 0.0, there's an obvious bug in Rybka that looks to be another direct result of converting floating point to fixed point (integer with millisecond base):

Code: Select all

``````  if &#40;movetime >= 0.0&#41; &#123;
time_limit_1 =    5 * movetime;
time_limit_2 = 1000 * movetime;
...``````
time_limit_2 should not be multiplied by 1000, the UCI sends its value in milliseconds. This is why "go movetime" doesn't work with Rybka, it always overshoots the time. And of course, the surrounding code is pretty similar--I don't know why you'd say otherwise. The signature of checking (infinite || ponder) twice is telling.

Don
Posts: 5106
Joined: Tue Apr 29, 2008 2:27 pm

### Re: Rybka 1.0 source code

michiguel wrote:
Sven Schüle wrote:
K I Hyams wrote:The exchange below is taken from the Rybka forum and altered to make it CCC friendly. In my opinion, his repeated claim to have lost the source code to Rybka 1 and Rybka 2 is shown to be unlikely to be true, at the time at which it was originally made. Either way, he appears to retract it immediately when faced with evidence that indicates that it is untrue. He then appears to offer to provide the code in question and immediately retract that offer when pressed.

[SNIP]
I am pretty sure that both statements of L. Cimiotti (from 2011-08-14 10:28: "Vas and I discussed whether or not he should give source code to the ICGA.") and Vas (from 2012-01-08 20:55: "In this scenario I would release the source code that I had.") have been misinterpreted as being related to obsolete source code. If you think of recent (R4+) sources being subject of these statements then don't you believe that makes more sense? Please consider that Vas did not refer to the term "obsolete" in any of his replies you quoted above, and did always answer on only a selected part of your questions, so you cannot be sure at all about the unanswered parts. Even though you started your questions referring to versions R1 and R2, it is possible - and in my view very likely - that by quoting the Cimiotti statement you attracted Vas' attention towards recent Rybka versions if that was what he knew the Cimiotti statement was all about.

Sven
Particularly in light of the panel decision, which requires current versions to be demonstrated to be free of guilt:
"ban his programs from future competitions until he can satisfy the ICGA that they are no longer derivatives and that he has satisfied the conditions of any other penalties the ICGA imposes."

Miguel
What the ICCA could do is launch MULTIPLE investigations, one for each version of Rybka that competed. They could be done one at a time starting with the oldest version until (and if) one comes up clean. We could drag him through the mud over and over again and keep this going for decades propbably.

Would such a process exonerate Vas? No. All it would do is humiliate him even more that the poor guy has been through already.

I believe in sanctions and we can argue about what is or is not appropriate, but in my view it does not have to be more than it has been. I sometimes wonder if it's the "drama" that is more important to us than the feelings of the people involved. Almost everyone involved has been attacked and bruised up.

I hate to say this but I also think his so called supporters, even if well intentioned, are not doing him any favors.

Gerd Isenberg
Posts: 2149
Joined: Wed Mar 08, 2006 7:47 pm
Location: Hattingen, Germany

### Re: Rybka 1.0 source code

Rebel wrote:
Gerd Isenberg wrote:
Rebel wrote:
Gerd Isenberg wrote:On the 0.0 issue. There are (only) about 32 >=, <=, >, < zero expressions in the Rybka C code Ed posted. And surely enough, the possible typo appeared exactly in the code where it had "semantical connections" with the floating point comparison inside Fruit.
Good point Gerd. And also only one float compare in whole Rybka 1 I must add. What about the 0x7fffffff sentinel in both Rybka 1.6.1 and Rybka 1.0 time control ?
INT_MAX might be used with similar +oo semantics as 999999. The range of INT_MAX - 257 to INT_MAX looks interesting in sub_40B1C0 (ln 4675) (mate score range?). Scoring move list? Where do you think INT_MAX appears in UCI-code?

The bottom line is that Rybka 1.6.1 (April 19, 2004) has UCI and why would anyone copy something he already has?
Ahh yes, found it. A global variable to additionally control the search, it is either MAX_INT, -1 or some parsed depth parameter. Later it is used in a condition with depth to trigger a global boolean which later terminates the search. So it seems Rybkas search has an additional condition with MaxDepth combined with others, which becomes never true if MaxDepth is MAX_INT, and always true if -1.

Code: Select all

``````  dword_667A20 = 2147483647; // maxdepth = INT_MAX
...
if ( v24 )
&#123;
v28 = strtok&#40;0, L" ");
if ( j__atol&#40;v28&#41; + 2 >= -1 )  // the famous + 2
dword_667A20 = j__atol&#40;v28&#41; + 2;
else
dword_667A20 = -1;
&#125;

....

if ( v25 >= dword_667A20 ) // depth >= maxdepth
byte_667A88 = 1;
``````
Crafty inits search_depth with zero and has a more complicated term to break:

Code: Select all

``````if (&#40;iteration_depth >= search_depth&#41; && search_depth&#41; break;
``````
Fruit 2.1 has an additional boolean to indicate depth limit is valid.

Code: Select all

``````if &#40;SearchInput->depth_is_limited
&& SearchRoot->depth > SearchInput->depth_limit&#41;
SearchRoot->flag = true;``````
So yes, Vasik used a tiny optimization with a simpler condition in search concerning depth. If that was already in 1.6.1, but not the 0.0, he might as well adapted his depth limit trick to the new parser.

Rebel
Posts: 5363
Joined: Thu Aug 18, 2011 10:04 am

### Re: Rybka 1.0 source code

Zach Wegner wrote:

The bottom line is that Rybka 1.6.1 (April 19, 2004) has UCI and why would anyone copy something he already has?
If you really have R1.6.1 (not sure how you would get it...), then please stop spreading misinformation about it.
What an opening statement.
The UCI parsing code is vastly different. R1 has a structure extremely similar to Fruit, while R1.6.1 uses UCI code derived mostly from Crafty's option parsing stuff.
R161 is UCI, Crafty is Winboard.

Fact.

So Vas wrote his own UCI code before Fruit appeared the scene.

Fact.
Also, in your page above, why did you delete most of the Fruit code? That certainly makes the comparison much harder...
No idea what you mean, if it's important rephrase the question.
For all this 0.0 nonsense, one point that it seems everyone is forgetting is that right next to the 0.0, there's an obvious bug in Rybka that looks to be another direct result of converting floating point to fixed point (integer with millisecond base):

Code: Select all

``````  if &#40;movetime >= 0.0&#41; &#123;
time_limit_1 =    5 * movetime;
time_limit_2 = 1000 * movetime;
...``````
time_limit_2 should not be multiplied by 1000, the UCI sends its value in milliseconds. This is why "go movetime" doesn't work with Rybka, it always overshoots the time.
In Fritz it plays too fast, under chesspartner too slow. Factor -2 <> + 2 not a factor 1000. I find your conclusion (the red) pretty premature.

oreopoulos
Posts: 109
Joined: Fri Apr 25, 2008 8:56 pm

### Re: Rybka 1.0 source code

The whole discussion is really stupid.

Mr Hyatt has lost touch with reality because for over 30years he has been a part in evolving chess engines.

Things are VERY simple.

I decide to create an engine. So how do i begin?

a) Are there any books on the subject? No
b) There are papers on various chess related subjects , if you can get them
c) There are open source chess engines. So this is the only way to actually get a working paradigm on how a chess engine is done.

And even that is hard because you have to "find" the building blocks from the start (instead of looking at the final product). If you look at many chess engines, you will probably understand the basic structure of an engine

Now you start your code. You select the board structure. You read that bitboards might be the best (you are just a newbie in the field, remember)

You understand how it works. Now is there are meaning in RE-writing the whole structure from scratch?
In my opinion. NO. Its public domain knowledge. Its like adding in my code some sort of sorting routine, by copy paste.

Mr Hyatt will tell you that its wrong. Well HE is wrong. He is part of the history. He made them the HARD way and says... you young boys should not get that for "free". That is complete ******

We go on... We have Search and evaluation...
There are basic things that you will keep at a first pass and so on...

So what if i "copy" 10 great ideas from a chess engine and put 5 more of my own and give a 100 ELO boost.

Why should i even bother to implement on my own the UCI interface. Common. This should be on public domain for everyone. We are not supposed to reinvent the wheel.

The fact is the Rybka CHANGE completely the level of chess playing engines. Some of you do not like that. it based its code on another program? Everybody does.. (ok mr hyatt you are that old that you were part of the evolution)

Now every top engine, is based on rybka (ippolit) leaked sources. So what? The one that makes the next big step is the important one.

mar
Posts: 2122
Joined: Fri Nov 26, 2010 1:00 pm
Location: Czech Republic
Full name: Martin Sedlak

### Re: Rybka 1.0 source code

Zach Wegner wrote:For all this 0.0 nonsense, one point that it seems everyone is forgetting is that right next to the 0.0, there's an obvious bug in Rybka that looks to be another direct result of converting floating point to fixed point (integer with millisecond base):

Code: Select all

``````  if &#40;movetime >= 0.0&#41; &#123;
time_limit_1 =    5 * movetime;
time_limit_2 = 1000 * movetime;
...``````
time_limit_2 should not be multiplied by 1000, the UCI sends its value in milliseconds. This is why "go movetime" doesn't work with Rybka, it always overshoots the time.
As I already pointed out, R1B "overshoots" go movetime ALWAYS by a factor of 3 (roughly), it has nothing to do with the 1000 you mentioned. You can verify this yourself.

Don
Posts: 5106
Joined: Tue Apr 29, 2008 2:27 pm

### Re: Rybka 1.0 source code

oreopoulos wrote:The whole discussion is really stupid.

Mr Hyatt has lost touch with reality because for over 30years he has been a part in evolving chess engines.

Things are VERY simple.

I decide to create an engine. So how do i begin?

a) Are there any books on the subject? No
b) There are papers on various chess related subjects , if you can get them
c) There are open source chess engines. So this is the only way to actually get a working paradigm on how a chess engine is done.

And even that is hard because you have to "find" the building blocks from the start (instead of looking at the final product). If you look at many chess engines, you will probably understand the basic structure of an engine

Now you start your code. You select the board structure. You read that bitboards might be the best (you are just a newbie in the field, remember)

You understand how it works. Now is there are meaning in RE-writing the whole structure from scratch?
In my opinion. NO. Its public domain knowledge. Its like adding in my code some sort of sorting routine, by copy paste.
These discussions keep circling around and around. It goes from suddenly trying to prove he didn't copy, to then saying what he did was ok, then back to trying to prove he didn't copy. Over and over again this keeps happening.

This is about the ICGA rules, not the ethics of copying. As far as I know the ICGA does not take a stand on whether copying is good or bad, acceptable or not acceptable - it's only position is whether they will allow programs to compete in their own tournaments that are based on the works of others.

Ok??

Mr Hyatt will tell you that its wrong. Well HE is wrong. He is part of the history. He made them the HARD way and says... you young boys should not get that for "free". That is complete ******

We go on... We have Search and evaluation...
There are basic things that you will keep at a first pass and so on...

So what if i "copy" 10 great ideas from a chess engine and put 5 more of my own and give a 100 ELO boost.

Why should i even bother to implement on my own the UCI interface. Common. This should be on public domain for everyone. We are not supposed to reinvent the wheel.

The fact is the Rybka CHANGE completely the level of chess playing engines. Some of you do not like that. it based its code on another program? Everybody does.. (ok mr hyatt you are that old that you were part of the evolution)

Now every top engine, is based on rybka (ippolit) leaked sources. So what? The one that makes the next big step is the important one.

Evert
Posts: 2929
Joined: Fri Jan 21, 2011 11:42 pm
Location: NL
Contact:

### Re: Rybka 1.0 source code

oreopoulos wrote: I decide to create an engine. So how do i begin?
I could tell you how I did it, in the mid 1990s without internet. But that's probably beside the point.
a) Are there any books on the subject? No
Of course there are.
b) There are papers on various chess related subjects , if you can get them
This is sometimes difficult, especially if you don't have access to academic journals through a university library. Still, there's lots of stuff available for free and easily accessible.
c) There are open source chess engines. So this is the only way to actually get a working paradigm on how a chess engine is done.
Wrong, it's not.
In fact, it's probably harder to learn how a chess program works by just looking at the source without any background knowledge.
And even that is hard because you have to "find" the building blocks from the start (instead of looking at the final product). If you look at many chess engines, you will probably understand the basic structure of an engine
Yes.
Or you could safe yourself time and effort and do some background reading.
Now you start your code. You select the board structure. You read that bitboards might be the best (you are just a newbie in the field, remember)
Personally I thought a plain 64 byte array made the most sense back when I wrote my first chess program. Then when I got my first 64 bit PC I decided that it would be fun to use 64-bit integers to represent a chessboard, so I wrote a program based on that idea (without reading much in the way of background information).
You understand how it works. Now is there are meaning in RE-writing the whole structure from scratch?
In my opinion. NO. Its public domain knowledge. Its like adding in my code some sort of sorting routine, by copy paste.
There is freely available code that you can use for bitboard manipulation and move generation, yes. So?
By the way, if I need to write a sorting algorithm (as opposed to just using a library function for that) I tend to find that it's less effort to write it from scratch and to my needs than it is to modify a piece of code I found on some website.
So what if i "copy" 10 great ideas from a chess engine and put 5 more of my own and give a 100 ELO boost.
So what?
Of course you can use ideas by other people, especially if they're published. That's the whole point in making ideas available, isn't it? So that other people can use the idea and benefit from it.
Why should i even bother to implement on my own the UCI interface.
I'll tell you why I did: it took less time and effort than adjusting someone else's code to work with my coding style and engine layout.
If someone wrote a UCI parser library that was easy to use, it'd be a different matter, but if it's integrated in someone else's code and you need to integrate it in your own... more effort than it's worth.
it based its code on another program?
Doing that is fine, within the conditions of the licence of the original program. In this case, under the condition that the source be released under the GPL.

Remember, Stockfish is based on Glaurung. There is no issue with that: Glaurung is GPL, and so is Stockfish.
Everybody does..
Wrong.
Most people use eachother's ideas, but that's not the same thing as already pointed out (just now and ad nauseam by others).
Now every top engine, is based on rybka (ippolit) leaked sources. So what?
So what indeed. Well, for one thing, if the top-10 engines are all forks of eachother, is it really 10 engines or is it 1 engine artificially taking up the first 10 places on the list?

Personally, I'm just glad that I'm not invested in the politics that surround computer chess (which I wasn't aware of before I took it up and would probably have given me pause had I known) and that my programs are sufficiently far down the ratinglist that what happens around the top does not affect me directly.

michiguel
Posts: 6401
Joined: Thu Mar 09, 2006 7:30 pm
Location: Chicago, Illinois, USA
Contact:

### Re: Rybka 1.0 source code

Don wrote:
oreopoulos wrote:The whole discussion is really stupid.

Mr Hyatt has lost touch with reality because for over 30years he has been a part in evolving chess engines.

Things are VERY simple.

I decide to create an engine. So how do i begin?

a) Are there any books on the subject? No
b) There are papers on various chess related subjects , if you can get them
c) There are open source chess engines. So this is the only way to actually get a working paradigm on how a chess engine is done.

And even that is hard because you have to "find" the building blocks from the start (instead of looking at the final product). If you look at many chess engines, you will probably understand the basic structure of an engine

Now you start your code. You select the board structure. You read that bitboards might be the best (you are just a newbie in the field, remember)

You understand how it works. Now is there are meaning in RE-writing the whole structure from scratch?
In my opinion. NO. Its public domain knowledge. Its like adding in my code some sort of sorting routine, by copy paste.
These discussions keep circling around and around. It goes from suddenly trying to prove he didn't copy, to then saying what he did was ok, then back to trying to prove he didn't copy. Over and over again this keeps happening.
Different people have different opinions, so they are not necessarily going to be in sync. That happens with the people in the panel too.
This is about the ICGA rules, not the ethics of copying. As far as I know the ICGA does not take a stand on whether copying is good or bad, acceptable or not acceptable - it's only position is whether they will allow programs to compete in their own tournaments that are based on the works of others.

Ok??
The debate will continue because there are lots of things that are at stake, much more important than the individual fate of a single programmer. As I mentioned before, precedents are set, and some of them, IMHO, are disastrous.

Miguel

Mr Hyatt will tell you that its wrong. Well HE is wrong. He is part of the history. He made them the HARD way and says... you young boys should not get that for "free". That is complete ******

We go on... We have Search and evaluation...
There are basic things that you will keep at a first pass and so on...

So what if i "copy" 10 great ideas from a chess engine and put 5 more of my own and give a 100 ELO boost.

Why should i even bother to implement on my own the UCI interface. Common. This should be on public domain for everyone. We are not supposed to reinvent the wheel.

The fact is the Rybka CHANGE completely the level of chess playing engines. Some of you do not like that. it based its code on another program? Everybody does.. (ok mr hyatt you are that old that you were part of the evolution)

Now every top engine, is based on rybka (ippolit) leaked sources. So what? The one that makes the next big step is the important one.