Author of NGplay_61 should give credit to tscp

[User923005]

Yes, that is exactly the point.

Perhaps I was not clear enough.

I was suggesting that if some random poster had picked out a random line and then made a joke out of it, saying "This single line of code proves two programs are clones." Of course, it would be meant as a joke. But if by some strange chance the poster had chosen an obscure bug (I have found that exact construct in production code at a huge multinational corporation) to make his point and if further the obscure bug were found at the same place in both programs, then that would actually be very damming evidence that the two programs were clones.

Obviously, you should never use that construct because (as I said in my original post that used that construct) the result is undefined behavior.

OK, so what, he copied some xboard protocol code ? And it's not even copied it's mostly inspired. But that distinction doesn't even matter. The point is that the xboard protocol code is completely irrelevant. What makes plagiarizm is IMO (in no particular order)
1/ the board code
2/ the search code
3/ the eval
and everything that links these together

But code like xboard commands, frankly... Don't you think this entire thread is futile and ridiculous ?

At least he made his code available to everyone. That is both honest (not trying to hide anything) and very nice (as it may help some beginners to read other codes). Frankly if you want to go on a witch hunt against the usurpers, you're choosing the wrong one. Have a look at Bouquet, that's some SERIOUS usurpation:
- based on a GPL version of IvanHoe (by Kranium and Sentinel)

Ivanhoe/Iggorit/Robbolito was released as public domain. That means that anyone who wants to can do absolutely anything that they want to with the code. See:
http://ippolit.wikispaces.com/search/vi ... +domain%22

- author tried to hide it, but as evidence started to pile, he finally admitted
- the author of Bouquet doesn't wan't to release his source code (which is a patent GPL violation)

He doesn't have to. The original project is public domain, not GPL. You can make your own GPL version if you like, of course.

- and goes on spamming everyone on CCC, pretending to be the genious who wrote a 3000+ elo engine from scratch... And as most people are morons, he actually has a fan club on CCC's Tournament forum.

What some other guy did is certainly worthy of investigation. If you want to do it, by all means go ahead.

So hitting the poor little guy who developped a weak engine, for free and source code published, because he took some help from other open source on implementing the xboard protocol, is unfair.

Sheesh, I said he should add an attribution line to his readme.
His entire project started out as TSCP. Look at the board structure. Look at the book, etc.
Now, I said already in my posts that his program has changed enough so that I do not consider it a clone. However, he has clearly borrowed from TSCP, so he should add a line to his readme.
There are other people doing bad things in computer chess. Those deserve their own thread.

Personally, I think that some of the responders to this thread suffer mightily from a lack of reading comprehension.

P.S.
Whether the engine developed is weak or strong is irrelevant. If you use someone else's stuff, you should get permission (if needed) and you should always give proper attribution.

Why does anyone think it would be a big hardship to create a readme file that says,
"This program borrowed ideas from TSCP by Tom Kerrigan"
?
Others may thing differently, but I see this sort of thing as THE fundamental problem with what is going on in computer chess.

You add the line, you're a hero. You leave the line out, you're something less than that. At least in my eyes.

As far as Ivanhoe clones, that club is enormous. Whether they are doing something wrong is another matter.
Note that I differentiate between things that I do not like and things that are wrong.
People can do things that I do not like, but which are not necessarily wrong.

[pedrox]

I think you should make a post with all the lines that you've found and that according to your criteria show that NGplay author should write to a "readme.txt" file giving credit to the author of TSCP.

So far all you've shown is that NGplay prints a line with text "Share and enjoy", previously used on TSCP and that contains an instruction to remove signs, instruction using in multitude of engines. I myself have used this instruction before having a linux executable on my website and it does not mean I have started my engine from TSCP.

These are the only evidence that you have shown, 3 lines of code in a code over 5,000 lines or more.

Any engine can have more equivalences with TSCP including engines with UCI protocol.

I believe that you have not chosen a good engine to ask the author credit for TSCP.

You should keep in mind one thing, if the author has done something wrong in NGplay with TSCP code then it is not sufficient that the author gives credits. The TSCP engine has a code copyrighted and you need permission from the author not only to post the code of your engine but even just to use the code in your engine.

So what you ask is not correct, if the engine has misused TSCP code should be removed and not give credits as you ask. If you see bad use the TSCP code, you should report this to Tom Kerrigan.

The only thing I see in the code NGplay is that the author has used a 12x10 board (120 elements), the same used to TSCP, but its way of generating movements and make and unmake is completely different of TSCP. If you use this as an argument to ask credits, any engine that uses bitboard should also give credit ...

Perhaps the closest thing we have in NGplay and TSCP is the code for the xboard protocol, but this is normal, you always find similarities in the code used by all engines to use the xboard protocol because you always have to follow a logical , check the keywords that sends the GUI to your engine and as each keyword act accordingly.

[pedrox]

Yes, that is exactly the point.

Perhaps I was not clear enough.

I was suggesting that if some random poster had picked out a random line and then made a joke out of it, saying "This single line of code proves two programs are clones." Of course, it would be meant as a joke. But if by some strange chance the poster had chosen an obscure bug (I have found that exact construct in production code at a huge multinational corporation) to make his point and if further the obscure bug were found at the same place in both programs, then that would actually be very damming evidence that the two programs were clones.

Obviously, you should never use that construct because (as I said in my original post that used that construct) the result is undefined behavior.

OK, so what, he copied some xboard protocol code ? And it's not even copied it's mostly inspired. But that distinction doesn't even matter. The point is that the xboard protocol code is completely irrelevant. What makes plagiarizm is IMO (in no particular order)
1/ the board code
2/ the search code
3/ the eval
and everything that links these together

But code like xboard commands, frankly... Don't you think this entire thread is futile and ridiculous ?

At least he made his code available to everyone. That is both honest (not trying to hide anything) and very nice (as it may help some beginners to read other codes). Frankly if you want to go on a witch hunt against the usurpers, you're choosing the wrong one. Have a look at Bouquet, that's some SERIOUS usurpation:
- based on a GPL version of IvanHoe (by Kranium and Sentinel)

Ivanhoe/Iggorit/Robbolito was released as public domain. That means that anyone who wants to can do absolutely anything that they want to with the code. See:
http://ippolit.wikispaces.com/search/vi ... +domain%22

- author tried to hide it, but as evidence started to pile, he finally admitted
- the author of Bouquet doesn't wan't to release his source code (which is a patent GPL violation)

He doesn't have to. The original project is public domain, not GPL. You can make your own GPL version if you like, of course.

- and goes on spamming everyone on CCC, pretending to be the genious who wrote a 3000+ elo engine from scratch... And as most people are morons, he actually has a fan club on CCC's Tournament forum.

What some other guy did is certainly worthy of investigation. If you want to do it, by all means go ahead.

So hitting the poor little guy who developped a weak engine, for free and source code published, because he took some help from other open source on implementing the xboard protocol, is unfair.

Sheesh, I said he should add an attribution line to his readme.
His entire project started out as TSCP. Look at the board structure. Look at the book, etc.
Now, I said already in my posts that his program has changed enough so that I do not consider it a clone. However, he has clearly borrowed from TSCP, so he should add a line to his readme.
There are other people doing bad things in computer chess. Those deserve their own thread.

Personally, I think that some of the responders to this thread suffer mightily from a lack of reading comprehension.

P.S.
Whether the engine developed is weak or strong is irrelevant. If you use someone else's stuff, you should get permission (if needed) and you should always give proper attribution.

Why does anyone think it would be a big hardship to create a readme file that says,
"This program borrowed ideas from TSCP by Tom Kerrigan"
?
Others may thing differently, but I see this sort of thing as THE fundamental problem with what is going on in computer chess.

You add the line, you're a hero. You leave the line out, you're something less than that. At least in my eyes.

As far as Ivanhoe clones, that club is enormous. Whether they are doing something wrong is another matter.
Note that I differentiate between things that I do not like and things that are wrong.
People can do things that I do not like, but which are not necessarily wrong.

You do not believe that the author of TSCP should give credits in your engine by using the alpha-beta algorithm?

[velmarin]

At least he made his code available to everyone. That is both honest (not trying to hide anything) and very nice (as it may help some beginners to read other codes). Frankly if you want to go on a witch hunt against the usurpers, you're choosing the wrong one. Have a look at Bouquet, that's some SERIOUS usurpation:
- based on a GPL version of IvanHoe (by Kranium and Sentinel)
- author tried to hide it, but as evidence started to pile, he finally admitted
- the author of Bouquet doesn't wan't to release his source code (which is a patent GPL violation)
- and goes on spamming everyone on CCC, pretending to be the genious who wrote a 3000+ elo engine from scratch... And as most people out there are morons, he actually has a fan club on CCC's Tournament forum.

So hitting the poor little guy who developped a weak engine, for free and source code published, because he took some help from other open source on implementing the xboard protocol, is unfair.

Looking more fronts, lucas.

You're my number one fan.
Are you in love with me, I have grandchildren.

Ippolit is PUBLIC DOMAIN.
And I just do one more project, with support and continuity.
And with obvious improvements.
But the saying
"They talk about you, because we are alive"
 
Soon will come an Open Source version and in the public domain, some mouth shut or be worse???

http://ippolit.wikispaces.com/FAQ

[alfons]

NGplay isn't a windows-only-app: it compiles not only well on Linux and Mac, but rather is usable (BAM!) on both platforms too (on the *BSDs also).

So it is cross-platf@ck!

Thanks for the this to the author.

[User923005]

You do not believe that the author of TSCP should give credits in your engine by using the alpha-beta algorithm?

Actually, on many occasions I have advocated exactly that policy (but the credit should go in his algorithm's code and not in mine. I of course have done exactly that.). I have called for "literate programming" where proper citations are given on many occasions. Dr. Hyatt does a good job of this. Look at the main.c file in crafty. However, chess programmers tend to be a lazy lot, so I would never expect things to get to where they ought to be. Not only do I realize that most computer chess programmers do not do this, I also realize that most of them will never do it. In fact, most of them are also actually breaking the law, although I realize that nobody cares about it and also that I am casting pearls before swine.

It's a swarming pack of backbiting thieves, each calling the other a liar and a thief. I think it should be improved, too bad it won't be.

[User923005]

You do not believe that the author of TSCP should give credits in your engine by using the alpha-beta algorithm?

Actually, on many occasions I have advocated exactly that policy (but the credit should go in his algorithm's code and not in mine. I of course have done exactly that.). I have called for "literate programming" where proper citations are given on many occasions. Dr. Hyatt does a good job of this. Look at the main.c file in crafty. However, chess programmers tend to be a lazy lot, so I would never expect things to get to where they ought to be. Not only do I realize that most computer chess programmers do not do this, I also realize that most of them will never do it. In fact, most of them are also actually breaking the law, although I realize that nobody cares about it and also that I am casting pearls before swine.

It's a swarming pack of backbiting thieves, each calling the other a liar and a thief. I think it should be improved, too bad it won't be.

For instance:

Code: Select all

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

/*
**
** In the following code, every reference to 'CLR' means:
**
**    "Introduction to Algorithms"
**    By Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest
**    ISBN 0-07-013143-0
*/


/*
** CLR, page 187
** RandomSelect() is an O(n) selection algorithm.
** Given a set S, find the element that represents the Kth element of the set.
** On average, the time is proportional to the number of elements in S.
*/
template < class Etype >
Etype           
RandomSelect(Etype A[], size_t p, size_t r, size_t i)
{
    size_t          q,
                    k;
    if (p == r)
        return A[p];
    q = RandomPartition(A, p, r);
    k = q - p + 1;

    if (i <= k)
        return RandomSelect(A, p, q, i);
    else
        return RandomSelect(A, q + 1, r, i - k);
}

/*
** RandRange() returns a random value between 'a' and 'b'.
*/
size_t          RandRange(size_t a, size_t b)
{
    size_t          c = (size_t) ((double) rand() / ((double) RAND_MAX + 1) * (b - a));
    return c + a;
}

/*
** CLR, page 162
** RandomPartition() chooses an arbitrary element from the list 'A'
** and then divides the set into things bigger than the chosen item
** from 'A' and things smaller than the chosen item.
** The item is stuffed into the last position in the array, then
** the real paritition forming algorithm Partition() does the work.
*/
template < class Etype >
size_t          
RandomPartition(Etype A[], size_t p, size_t r)
{
    size_t          i = RandRange(p, r);
    Etype           Temp;
    Temp = A[p];
    A[p] = A[i];
    A[i] = Temp;
    return Partition(A, p, r);
}

/*
** CLR, page 154
** Partition() {called by RandomPartition} moves data to the 
** above and below the pivot element stored at position 'p'.
** Position 'p' is the start of the partition (but could be 
** a subset of the list 'A' due to the recursive nature of
** the algorithm.)
*/
template < class Etype >
size_t          
Partition(Etype A[], size_t p, size_t r)
{
    Etype           x,
                    temp;
    size_t          i,
                    j;

    x = A[p];
    i = p - 1;
    j = r + 1;

    for (;;) {
        do {
            j--;
        } while (!(A[j] <= x));
        do {
            i++;
        } while (!(A[i] >= x));
        if (i < j) {
            temp = A[i];
            A[i] = A[j];
            A[j] = temp;
        } else
            return j;
    }
}

#ifdef UNIT_TEST
double           data[30];
int             main(void)
{
    size_t          i;
    size_t          size = sizeof(data) / sizeof(data[0]);
    for (i = 0; i < size; i++) {
        data[i] = rand();
    }


    for (i = 0; i < size; i++) {
        cout << data[i] << endl;
    }

    cout << "1st item is " << RandomSelect(data, 0, size - 1, 1) << endl;
    cout << "2nd item is " << RandomSelect(data, 0, size - 1, 2) << endl;
    cout << "3rd item is " << RandomSelect(data, 0, size - 1, 3) << endl;
    for (i = 4; i < size; i++)
        cout  << i << "th item is " << RandomSelect(data, 0, size - 1, i) << endl;
    return 0;
}
/*
Sample output:
41
18467
6334
26500
19169
15724
11478
29358
26962
24464
5705
28145
23281
16827
9961
491
2995
11942
4827
5436
32391
14604
3902
153
292
12382
17421
18716
19718
19895
1st item is 41
2nd item is 153
3rd item is 292
4th item is 491
5th item is 2995
6th item is 3902
7th item is 4827
8th item is 5436
9th item is 5705
10th item is 6334
11th item is 9961
12th item is 11478
13th item is 11942
14th item is 12382
15th item is 14604
16th item is 15724
17th item is 16827
18th item is 17421
19th item is 18467
20th item is 18716
21th item is 19169
22th item is 19718
23th item is 19895
24th item is 23281
25th item is 24464
26th item is 26500
27th item is 26962
28th item is 28145
29th item is 29358

*/
#endif

As you can see, it isn't difficult at all, if even a simpleton can do it.

[pedrox]

1. NGplay course is not a clone, it would be ridiculous to consider this possibility.
2. NGplay is not a derivative of TSCP engine.
3. The author of NGplay has studied TSCP code and surely the code of other engines, as most programmers. Among other reasons for that are open source programs. TSCP specifically to teach.
4. NGplay code was written from scratch.

I am now going to argue because I think NGplay code was written from scratch:

1. The TSCP engine is an engine very stable. If a programmer starts from TSCP source code, he does not need to change most of the code of the engine since the engine is operating and has the basics, the skeleton of a chess engine, but it would do is add new things to the engine to improve the strength of the game. For example, add null move in the alpha-beta function of TSCP, he could have improved the time management, add killers moves, he could have add in the search LMR, he could have added a function to support positions in FEN format and allow editing positions in the GUI, he could be added mobility in the evaluation function, etc. So removing these additions you could still see the TSCP code, which does not occur in NGplay.

This is seen very clearly in my engine: Caligula, seeing the code you can see very easily that the engine has started to TSCP (Caligula es 800 point up). Of course I have permission of Tom Kerrigan to do it and I keep code closed because Tom likes it this way.

2. But when you see NGplay code, you can see that the author does pretty everything different than the author of TSCP. For example, to collect the PV the author uses the form of Bruce Moreland do it instead of a triangular array of TSCP. What is the author need to do this if the triangular array of TSCP working properly?, the same is true in most parts of the rest of the code, for example the author uses an alternative way to calculate random numbers, the author does not use the same way to calculate repetitions, movement generation is completely different functions do make moves and undo, virtually everything. And not only different but possibly the author makes it more original than many existing engines.

3. Yes, the board of NGplay is based on an array of 120 elements, but also engine stockfish is bitboard and therefore is not considered a derivative of Crafty (maybe the engine made ​​famous bitboards in the chess programming but not the first engine in use), stockfish also if I remember correctly uses the Polyglot book format and is therefore not considered Fruit derivative.

4. The author of NGplay offers gently with his engine source code. If the author of NGplay thought that the engine is a derivative of TSCP and broke copyright of TSCP, he will not give source code.

I agree it is very nice to give credit to other developers, for example, is admirable Bob with Crafty. But I'm sure that even if one studies the credits of Crafty he could say that he have forgotten to give credit to other programmers, for example the creators of language C. Bob also has more than 40 years in chess programming, he has lived all developments become and surely it is easier to know who and when has invented something and give credits. Today one can learn in forums, on websites like chess wiki programming, open source engine, you have so many sources that it is impossible to name them all and do not forget the many.

If you ask the author of NGplay give credits to Tom Kerrigan because you not ask that the autor also gives credits to Bruce Moreland for using his way of collecting the PV?

If you ask this to NGplay you should ask this for each existing engine, not only for NGplay. You can not just ask this for a given engine, you're crucifying the author of NGplay for something that makes all programmers.

In this thread all it has done is discredit NGplay programmer and some users do doubt whether to use this engine, which is totally unfair.

If you believe that today the chess programming world is wrong because programmers do not give credits for previous work, you can put this in the forum, but I think that is wrong make it with the engine NGplay.

This is my opinion and my last post on the subject.

Pedro

[User923005]

And yet on far flimsier evidence Vas was given a lifetime ban, and international disgrace in the news media.
Go figure.

You are, of course, wrong about the origin of Ngplay, but that does not really matter much.
It is obvious if you do not have a preconceived idea and are of at least moderate programming ability.

Anyway, I only said he should offer a line of credit in his readme, that is all. If anyone thinks this gesture is too much, then I consider them to be "morally challenged".
But really, that is what chess programming has become. Fakers, liars and cheats dominate the sport and boldly waive their banner of stolen achievement over their heads. When it is so much easier and more pleasant to be honest and forthright.

Note that I myself said Ngplay was not a clone. I think that those calling themselves chess programmers are now past all moral sense. Due to wanting to justify their own bad actions, they say that any sort of wrongdoing is just fine.

If you don't think Ngplay should give credit to Tom, then I think I know why.

[Samer]

You have problems.

You want credit for TSCP.
You sent a email to NGPlay autor demanding him credit. But you are no Tom Kerrigan.

If you insist with this road you will be considered a troll and will be ignored.

Sven Schudle, Pedro Castro, Lucas Braesh and me think you are wrong.

You must send a email to Tom Kerrigan.

Either way you will be ignored.