From: Michal Suchanek <hramrach@...>
Date: 2007-10-15T04:11:01+09:00
Subject: Re: MIT vs. Ruby/GPL License

On 14/10/2007, Trans <transfire@gmail.com> wrote:

>
> That link helped --well almost. This is what it says on the subject:
>
> <i>
> What is the difference between "mere aggregation" and "combining two
> modules into one program"?
>     Mere aggregation of two programs means putting them side by side
> on the same CD-ROM or hard disk. We use this term in the case where
> they are separate programs, not parts of a single program. In this
> case, if one of the programs is covered by the GPL, it has no effect
> on the other program.
>
>     Combining two modules means connecting them together so that they
> form a single larger program. If either part is covered by the GPL,
> the whole combination must also be released under the GPL--if you
> can't, or won't, do that, you may not combine them.
>
>     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.
> </i>
>
> Kind of fuzzy.
>

It is. You cannot decide that unless you go to court, and even then it
won't be final.

Note however that there is LGPL for libraries that can be used in
non-GPL software so in general you should probably avoid GPL stuff
when non-free software is involved.

But even in ruby with its marshaling capability, drb, and whatnot you
get slight difference between single process and multiprocess
situation.
iirc it is not possible to restore objects for which the class is not
present so you are limited to basic types and objects from libraries
you can load in both processes.

Thanks

Michal