[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [gnugo-devel] endgame module for GNU Go

From: Marco Scheurer
Subject: Re: [gnugo-devel] endgame module for GNU Go
Date: Tue, 7 Sep 2004 20:05:54 +0200

On Sep 7, 2004, at 19:47, Paul Pogonyshev wrote:

Arend wrote:

If you simply intend to ship GNU Go bundled with your program, and the
only connection between the two is over GTP, then there is no issue.
I think you should also make the source for the version of GNU Go
available, but other than that it doesn't sound like there's a problem
with what you want to do.

I don't think it is so easy. The question is whether your work should be
considered "derived work" of GNU Go. If you only use the standard GTP
commands, then it is probably not. But with the GNU Go-specific GTP
commands, you can get quite deep into the engine internals. Then it might
be less clear.

For example our debugging GUI view.pike might very well be considered a
derived work of GNU Go. (It would not work with any other engine at

While I'm not an expert either, I strongly believe you are wrong.  It
doesn't matter that `view.pike' relies on GNU Go-specific GTP commands, this
doesn't make it a derivative work.
For work B to be derivative of A, it has to include some pieces of A or be "non-separatable" in some way. The latter option is fuzzy and it has to be
decided in the court.

And I am also not an expert (nor a lawyer), and I suspect that nobody can pretend to be one until this has been decided in court (which is unfortunate, maybe the GPL could be made clearer in that respect, or is it now too late to be changed?).

The FAQ at says:

"What is the difference between "mere aggregation" and "combining two modules into one program"?

What constitutes combining two parts into one program? This is a legal question, which ultimately judges will decide. We believe that a proper criterion depends both on the mechanism of communication (exec, pipes, rpc, function calls within a shared address space, etc.) and the semantics of the communication (what kinds of information are interchanged).

If the modules are included in the same executable file, they are definitely combined in one program. If modules are designed to run linked together in a shared address space, that almost surely means combining them into one program.

By contrast, pipes, sockets and command-line arguments are communication mechanisms normally used between two separate programs. So when they are used for communication, the modules normally are separate programs. But if the semantics of the communication are intimate enough, exchanging complex internal data structures, that too could be a basis to consider the two parts as combined into a larger program."

So it looks to me that Arend could be right, but based on the concept of aggregation, and not of "derivative" work according to copyright laws.

Marco Scheurer
Sen:te, Lausanne, Switzerland

reply via email to

[Prev in Thread] Current Thread [Next in Thread]