Chris Whittington wrote:hyatt wrote:Chris Whittington wrote:hyatt wrote:Chris Whittington wrote:Uly wrote:
What is the 'bomb'? I only see Fabien agreeing with Hyatt that 'If [he does] _exactly_ the same thing [in mailbox], because [he copies] the code and then adapt[s] it to bitboard, [he doesn't] call that "original"'.
Hyatt is doing a cheat argument when he talks about mailbox/bitboard conversions.
What on earth are you talking about. The continual claim here is that Rybka is bitboards, fruit is not, they can't be the same. The conversion from mailbox to bitboard is too difficult. The conversion _I_ did in 1994 was _exactly_ this. I wanted to start to work on a bitboard engine. I took Cray Blitz, ran it thru a FORTRAN-to-C compiler, and cleaned that up. I then started to convert the thing to bitboards. And over time, I rewrote substantial parts as I wanted to use a recursive search rather than the iterated version we had in Cray Blitz. But the original conversion did not change the entire program. Search was unchanged. Move ordering and move selection code was unchanged. Code to deal with extensions, with hashing, etc were all unchanged. Parts of the move generator were changed since the board representation was altered, but this was not a huge effort. The eval was the most difficult, but I found it changed a good bit syntactically, but _not_ semantically. One continues to evaluate the same things, using the same weights, but using different comparisons and such.
That is a derivative work, period. Using bitboards to justify rybka 1 is pretty disingenuous, IMHO. It is an argument no person actually doing chess programming will consider for a minute. How many changed from an 8x8 board, to something else, to 0x88? New programs? Hardly. The better the programmer, the easier that is to do in fact...
Hyatt refers to his own conversion of Cray Blitz to Whatever (I forget the name) and calls the conversion copying.
In this case Hyatt wants to "copy" the original, perhaps with some additions optimisations along the way.
But the argument is about person A "copying" person B's program, "using ideas" from B's program.
In this case A does *not* want to "copy" the original, and he will definitely want his own ideas in there as well.
Only problem is, more than "ideas" were copied. Blocks of code were copied. And hand-waving is not going to make that go away anytime soon it would appear. Particularly now that Fabien has stepped into the discussion.
The act of wanting/not wanting to "copy" makes all the difference. Maybe by clean room, maybe by making a spec, maybe by total data structure change, certainly by using the *ideas* and not the code.
Bunch of nonsense. You either copy or you don't. Copying without wanting to copy, not copying but wanting to copy? All crapola.
Hyatt's attempt to use his own experience as a universal template is invalid in the context.
However, everything you wrote is nonsensical and irrelevant in any context...
The usual fatuous Hyatt response "in Crafty I did blah blah" and that's supposed to be the definitive only way anything can ever happen because High Priest Hyatt did it first (allegedly).
I cite what _I_ did. Which is a lot better than trying to cite what _others_ 'might have done' without knowing. Something you ought to consider trying from time to time.
Well, Bob, you're not the only person to have made a bitboard conversion, I did one too from CSTal2 to CSTal3 (unpublished), as have many others, it was basically a re-write using the ideas of bitboard and the ideas of speculative CSTal, so that gives us three pathways, as opposed to the ONLY ONE HYATT WAY for everything
1. Own programmer makes the copy/conversion trying to be as true to the original as possible. We can call that a copy, perhaps, and that's what you more or less claim you did with Crafty.
Which was exactly what I did, of course, and was exactly what I stated.
2. Own programmer re-writes using ideas (a spec basically) and doesn't care either way whether he uses or resuses his old code in the process
What does this have to do with anything? Did you not reuse _any_ pre-bitboard code? Of course you did, which is the exact argument being discussed in the fruit/rybka case.
3. A different programmer writes his own material having studied and taken ideas from some open source. In this case he would care very much NOT to reuse code and to make each and any idea implentation as different as possible. That's not a copy.
Except that there _is_ copied code from fruit, so this pig won't fly. Your basic premise has already been violated (very much NOT to reuse code...) The argument has been that rybka used bitboards, fruit did not, so that it would be impossible to copy code. That is pure nonsense. Search won't change. move ordering won't change. hashing won't change. book code won't change. learning code won't change. move selection code won't change. Overall eval structure and values won't change. Etc. This argument fails the most basic "stink test". And here you are _guessing_ what happened. Ignoring the similar program structure that would not happen if you started over from the "specs" which exist for no chess program I have ever seen, by the way. So how about stopping with the arguments that don't hold water, which don't pass a basic "stink test" and which clearly are at odds with observed facts and past experience. Again, did you rewrite everything in your conversion to bitboards? I certainly did not. And Crafty today doesn't look much like the released CB source, although you might recognize the basic chess program overall structure, the search output (which is identical by the way), and other ideas. Over 15 years the code has been modified, and re-modified, yet there are still blocks of code that will match up well with Cray Blitz, when you factor in bitboards vs mailbox...
One-way Hyatt seems stuck on the idea that 1. is the only way whereas 3. fits to the Rybka evidence so far. For example use of bitboards which numbers of programmers are telling you is a very non-trivial change and practically impossible line by line. In fact the only reason for trying a line by line approach (maddenly difficult, parallel to line by line converting a Newtonian paradigm to an Einsteinian one and missing completely the need for a new way of thought) would be to try and get a fully faithful exact replica of the old program, which, if all you want is the *idea*, is pointless.
Look up "Occam's razor". Then come back. The simplest explanation fits the observed facts. none of your speculative hand-waving fits anything remotely similar to what we have seen so far. So which explanation seems most reasonable? Again, re: Occam's razor for help.
I believe my "one-way" thought process works pretty well. As opposed to trying to find the most indirect route between two points, convoluting the reasoning, and adding things no rational programmer would do. Again, Occam's razor applies.
Perhaps you should look up your old posts when you claiming (falsely imo) to be the inventor of bitboards.
Feel free to quote such a claim. I have only claimed to have invented "rotated bitboards". So, once again, false statements are the only to proceed in an argument where you don't have a leg to stand on. But in any case, please cite _any_ post I have ever written where I claimed to invent bitboards. That goes to a tie between Donskoy, et. al. in Kaissa and Slate/Atkin in chess 4.0. And I have _never_ claimed otherwise.
You claimed then, I recall from memory and also agree, that bitboards force a whole new way of thinking about chess programming - a new paradigm of board representation, different easier ways to do stuff that just don't arise with mailbox etc etc. Now you claim line by line translation capability from mailbox to bitboard - well, bollocks. And bollocks to your claim that everybody else does it YOUR way.
I did not claim "line by line translation". That is _your_ hyperbole. I claimed that one can take a chess program component (move generator, evaluator, etc) and translate directly from mailbox to bitboard or vice-versa, and keep the _same_ structure, _same_ values_ and produce the _same_ final evaluation numbers. And that is not "original or rewritten" code, It is simply a derivative, as in "derived from". This is no more an original work than the first version of Crafty with parallel search was original, it was based on the previous version where I had to collect everything into a structure and pass a pointer around. Major changes. But a derivative of the previous version. This is _not_ rocket science. So stop with the obviously false statements, relying on your memory with respect to what you _think_ I have written, etc.
Very hypocritical to be bigging yourself up about new paradigm bitboard programming then when it suited you and claiming line-by-line equivalence now when it suits you.
That statement is meaningless. I have not claimed "line by line equivalence". I have not "bigged myself up". And I have not been hypocritical. That seems to be more in your balywick. But there is no need to rehash your attempts to rewrite history with respect to CCC and Rolf... I suppose you will continue to distort and fabricate however... Most see this for what it is.
BTW, even though you claim to have ported to bitboards, one might wonder if you copied anything, since you protest so strongly about the Fruit/Rybka issue??? An intelligent person would realize bitboards offer nothing new in terms of capabililties. They offer advantages in terms of speed here and there. The "new paradigm" crap is your words, not mine. I don't consider something developed in the early 70's to be "a new paradigm" at all. Just an "interesting one" that has characteristics that I thought would be useful, so I elected to "make the change". One can do that without completely rewriting the program, if, of course, one knows what they are doing and are worth a damn as a programmer. Whether you fit into that category or not is unknown, but based on your comments, either you don't, or you enjoy distorting facts to fit your agenda, whatever that might be.
