GPL

[Batlas]

I do somewhat agree with you XML, but I still dont like the idea that I will have to share the stuff I dont want to that wont really benefit DOL but will benefit others for making "clones". I have no problem with sharing some stuff dont get me wrong, but every server needs something that differs from another server.. Otherwise why have multiple servers? Playerbase atm surely isnt large enough to make x amount of Live server RVR clones due to lag from too many players, so something has to lure poeple in the less played servers.. I do however think that anything that can benefit DOL in becoming closer to live standards should be shared.. Even if it isnt added into the stable, it will make the Devs lives easier as poeple can tweak and optimize it and then give the Devs something to work with. ANyways Im too tired to continue to rant about this hopefuly all this stuff is figured out b4 I go live

[erevlydeux]

I'd always said this, and I'll say it again: the featureset of a server shouldn't be its reason of popularity. I believe in strong customer service and and even stronger developer team, fixing bugs and the likes.

Now, you might say, "well, gee, it seems like my developers would be doing all the work for DOL." You're right, they pretty much would be, but you'd be reaping the benefits before anyone else. DOL takes so long to integrate patches it isn't even funny. Couple this with the fact they are constantly refactoring stuff (full rewrite, anyone?) and you have a 2 - 3 week grace period of your shard holding these new bug fixes.

You also might say, "well, why should every shard have the features our shard does?" I don't think they should. However, if the feature exists on live servers (US or EU), it SHOULD be included in DOL no matter what. When you branch into things like server rulesets that aren't normal (Instant 50 RvR, for example) then you shouldn't have to submit the code, although making it open source could certainly help you by getting more input on it. There are so many newbie developers that have no idea what common programming conventions and practices are that should be learning this shit!

In short, if your shard can't compete with other shards other than by means of limiting how closely the other shards can emulate live servers, then your shard basically sucks, and that's the bottom line.

[Ogre]

Ogre: Where have you been?!

Working.

Actually I spent a good chunk of time rewriting various parts of DOL and eventually realized it was hopeless and needed a total rewrite. The DB shit we all worked on is still solid though and works with DOL STABLE with minor mods. (See Camel Light Express in the CL repository if you're curious.) It could use some more exceptions and major cleanup but it does work and its a heck of a lot easier to manage than the NHibernate stuff.

Other than that... well I moved twice. Worked on a few big web projects. Finished learning .NET. Built a few new machines. Umm there's more prolly but I'm a space case today...

EDIT: If you guys haven't realized yet, heh, Corillian just likes to take the opposite side of arguements even if he knows the other side is right... As far as I can tell he is fueled by strife and conflict and just generally likes to create chaos. However, being a Discordian, this is actually a Good Thing.

[Phazer]

Well not trying to stir, poke, or prod at the situattion i just would like to add a n opinion, although an opinion means jack compared to law..

I think it is unfair of ANYONE to sit back and demand someone else's hard work to be obtainable, just because they are to lazy to either take the time to create the scripts themselves, or to lazy to learn C#.


But on the other hand C# is not a scripting language and acttually "compiles" everytime you startt your server.. so in reality it is a "code" language and thus everytime you start your server your "scripts" become a temporary part of your "core"

[Batlas]

Phazer it has nothing to do w/ poeple being "lazy". Why do we need 50 different version of the same epic quest? Someone releases there version, others improve on it, rerelease it. Someone else gets it, optimizes it further.. And hell what do you know, you now have a great script for epics! The point is that we shouldnt be seperated as a community. This seperation imo has caused more harm than good. Imagine if everyone shared everything and we had everything open sourced. We could have 3 fold the current player bases, and many more great servers to pick from. Its rare, but I agree w/ tobz on this one. Your staff, your hardwork, and then your added bonuses. (Fallen realms and there events for example) or I50 with its OF, etc etc etc. That should be your selling point, not stuff THAT SHOULD BE IN DOL!

[erevlydeux]

Exactly. Why should you be able to use DOL (which took a CONSIDERABLE amount of hard work) if you're not willing to give back? Let me tell you, it's not easy writing an emulator, even with 2 - 3 people. If I was going to put in all the work to create an emulator, I'd want to make sure people were going to give back to it.

I can only imagine how much people would cry if DOL decided cease updating the public SVN and stop releasing binaries. You guys would all be stuck with the buggy ol' 1.7 builds forever.

Never take things for granted.

[Phazer]

I know where your coming from, this is not the first server emulator community i have been in. One problem is the way everyone works with C# you need to have a standardized core for everyone to be able to submit thier coding for general use. Alot of people using DOL compile thier own core with slight to moderate deviations.

If people would just use code that could be dropped in 'scripts' and compiled when you run your server then creating a more 'community' friendly server would be more likely. As is everyone wants something "custom" no one is striving for a "base" server. I think we all need to start striving for a "base out of the box live server" and from there worry about customs. There are more then enough people to achive this if were all working for the same goal instead of seperate ones.

[Ogre]

I'd like to point out that the "Events" stuff for Fallen Realms always just ended up causing more problems than it was worth. That stuff wasn't even my idea and I discouraged the FR devs from implementing Event related stuff but they did it anyway. (Remember FR was supposed to be a clone of Mordred and the US servers didn't have "events" back then.)

The biggest problem was that they added the stuff to the core code instead of deriving new objects or figuring out some suave way to do the implementation. That code is and always has been in the Camel Light repository. There was some shard-specific stuff in the FR repo that called the CL code but really its not worth screwing around with or even looking at simply because the DOL codebase has changed so much and also because of what I said before with the implementation not being solid.

Ultimatley, however, this thread was about the GPL and I stand by my interpretation that pre-compiled binaries that only link to another library are not automagically GPL'd as well. Only modifications to the original code (or project files or solution files or any of the files for that matter) count as derived works. Just linking against the project isn't enough to make it a derived work.

Again, I site any open source "library" as an example. If I link my closed source, commercial project against a GPL library and include the library along with whatever documentation is required by the library, I haven't violated the GPL. DOL works the same way. The "scripts" are compiled seperately from DOL and aren't actually a modification (derived work) of the DOL codebase. Another example could be that Windows doesn't automagically become open source just because you compile a GPL project that's linked to the Win32 API DLL's.

Also all of the DOL code that became Camel Light has always been open to the public (the SVN repository has anon-read access, to comply with the GPL). The Fallen Realms specific code was never public because it isn't a derived work and moreover was made specifically for Fallen Realms, making the server unique. The DOL people could have used code from CL at anytime (I'm thinking of the DB project here) but they never did for reasons unknown. (Actually we never tested MySQL support so for all I know it never worked. The XML stuff, the embedded XML stuff and the SQL Server stuff all work very well.) Any FR stuff that didn't make FR unique was released at various points by various people. (Etaew's area system, teleporters, etc.)

[Ogre]

I think we all need to start striving for a "base out of the box live server" and from there worry about customs.

This is EXACTLY what one of my goals for Camel Light was and prolly why I focused on the DB project so much. Near the end, after we added embedded XML support, I had planned to include assemblies complete with world-data like mobs and items and whatnot. Not every zone in DAOC but at least enough to get started.

To mulitate a quote from Gates: "DOL is great but without data its just a tin box with flashing lights."

[erevlydeux]

I think we all need to start striving for a "base out of the box live server" and from there worry about customs.

This is EXACTLY what one of my goals for Camel Light was and prolly why I focused on the DB project so much. Near the end, after we added embedded XML support, I had planned to include assemblies complete with world-data like mobs and items and whatnot. Not every zone in DAOC but at least enough to get started.

To mulitate a quote from Gates: "DOL is great but without data its just a tin box with flashing lights."

Amen. The same thing goes for CL 3.0. All the static data is defaulted from the XML readers themselves. It is much like how DOL pulls out the region/zone data as embedded files. CL 3.0 has the default data as actual code though. (it populates objects with the data, and then adds them to the XML configuration reader, which then saves the data it has)

This isn't mob data though, yet. Most of it is just command privileges and class data and such.

edit: As far as I know, the MySQL support was present in the CL DB assembly, and it worked when I used it. A later change might have messed it up, though; I'm not sure.

[hobobill]

Again, I site any open source "library" as an example. If I link my closed source, commercial project against a GPL library and include the library along with whatever documentation is required by the library, I haven't violated the GPL. DOL works the same way. The "scripts" are compiled seperately from DOL and aren't actually a modification (derived work) of the DOL codebase.

Unfortunately, this isn't true. You are aware of the LGPL? If your interpretation of the GPL were correct, then the LGPL would not exist. The LGPL was created precisely because of the strict viral nature of the GPL. If you link to a GPLed library, then your entire application must be released under the GPL. This also applies when you link dynamically. Any use of GPLed software in your own code constitutes a derived work.

The LGPL relaxes this restriction. The LGPL defines dynamic linking as 'usage' and not as 'derivation', making a distinction the LGPL does not. If you statically link to an LGPL library, then you are creating a derived work (except under special circumstances). Richard Stallman never agreed with the need for the LGPL and felt it defeated the purpose of the GPL.

I mean, imagine that we take the GPLed Quake 3 engine, strip out the game code, compile it as a static library, and create a commercial game from it. Let's assume we follow your interpretation of the GPL and, since we are using the quake engine as a library, do not release the game under the GPL. If id decided to take us to court, do you really believe we would win? I'm sorry, but no. We could still release the game commercially, but we would have to abide by the terms of the GPL and make the complete source, even the game we created that links to the quake engine, available to anyone who receives the executable.

The DOL scripting engine falls under this as well. Any scripts you create are calling into a GPLed API are also required to adhere to the terms of the GPL.

Another example could be that Windows doesn't automagically become open source just because you compile a GPL project that's linked to the Win32 API DLL's.

This is a horrible example. It isn't the same case at all. It isn't even realistic. The Win32 API is not derived from any GPLed software you may write. You are (in GPL language) deriving your software from the Win32 API, but just because you do does not mean Win32 must be re-released under the GPL. That would really be silly if all it took to force a company to open their source would be to create a GPLed application that links to theirs. There's absolutely no way such a thing could be enforcable.

The GPL sucks. It's a viral license that has no leniency. It makes sense in certain situations. The Quake engines are a great example. id licenses those engines for large amounts of money, even now. They allow you to pay for the license and keep your game source closed, or use the engine for free but abide by the GPL. But for most projects that begin life as open source, I think a less restrictive license is always more approptiate. Something along the lines of BSD, zlib/png, and MIT licenses are what I prefer. No one ever misinterprets those licenses, but there is always a lot of confusion surrounding the GPL and LGPL as this thread clearly shows. Too many open source project maintainers apply the GPL and LGPL without fully understanding them or misinterpreting them altogether.

[Ogre]

Unfortunately, this isn't true. You are aware of the LGPL?

Yes, the LGPL is more akin to the BSD license where not only can you make derived works and not release the code, you can also SELL compiled binaries. Big chunks of Windows actually contain Berkley developed and BSD licensed code. The license itself is really just a formality for legal indemification and whatnot.

If your interpretation of the GPL were correct, then the LGPL would not exist. The LGPL was created precisely because of the strict viral nature of the GPL. If you link to a GPLed library, then your entire application must be released under the GPL. This also applies when you link dynamically. Any use of GPLed software in your own code constitutes a derived work.

Think about what you've said for a second. If this were true, no commercial software written to run on Linux would ever exist. NVidia has closed source drivers for Linux and there's no legal path for anyone to take to force them to open the code because its simply not a requirement. See at some point they had to compile the drivers and the drivers need to be able to read code from the Linux Kernel Source tree. If what you said were true then those NVidia binaries would violate the GPL because they're directly linked to the Linux Kernel Source.

In Camel Light, which was a derived work based on Dawn of Light, we added "hooks" to call code from other assemblies. And those assemblies weren't part of CL or DOL and were created by us and at the time we didn't want to release that code, hence the hooks.

If you're still not getting it, think about plugins. If you wanna write a plugin for a GPL'd application, your plugin doesn't have to be GPL just because the application is. And some code can't be GPL'd. Code that contains state secrets or personal information. What about databases? If I write some script that does some stuff to a GPL'd database server, my code doesn't also become GPL'd just because its linked to a GPL'd application. And if you look at it from a certain perspective, database data is just "code" that tells the database what to do. That code doesn't become GPL just because its stored in and gets to manipulate an application that its linked to.

I mean, imagine that we take the GPLed Quake 3 engine, strip out the game code, compile it as a static library, and create a commercial game from it. Let's assume we follow your interpretation of the GPL and, since we are using the quake engine as a library, do not release the game under the GPL. If id decided to take us to court, do you really believe we would win? I'm sorry, but no. We could still release the game commercially, but we would have to abide by the terms of the GPL and make the complete source, even the game we created that links to the quake engine, available to anyone who receives the executable.

Actually you're wrong. You would be required to release the changes you made to the GPL'd source as source and you could release compiled binaries of that source along with your other compiled binaries that are linked to that source but you don't have to release the code that you've written that's not a derived work of the GPL'd game engine.

Tivo does exactly what you describe. They modified the Linux Kernel to support their weird hardware and do whatever else, they have that code released on their website for anyone to download. But they also have lots of code that powers their devices that they don't release. In fact some of it is patented in the US. Their stuff all runs on Linux which is GPL.

This is a horrible example. It isn't the same case at all. It isn't even realistic. The Win32 API is not derived from any GPLed software you may write.

Its a perfect example actually. Win32 isn't derived from GPL'd stuff but the code you just wrote is (for the purposes of this example). Just flip them around and its the same example. The position of the variables is irrelevent.

You are (in GPL language) deriving your software from the Win32 API, but just because you do does not mean Win32 must be re-released under the GPL.

Umm you don't "derive" your code from the Win32 API, you link to it. We really need to have a good understanding of all of the concepts we're talking about here before using them in sentences. You link to libraries. You derive from previous works. Linking to a library is not the same thing as creating a derived work. Making changes to code creates a derived work. Linking only creates references and invokes stuff, it doesn't derive.

That would really be silly if all it took to force a company to open their source would be to create a GPLed application that links to theirs. There's absolutely no way such a thing could be enforcable.

Umm no shit and isn't that what I've been trying to say the whole time? Right? How is:

Shard Scripts (not GPL) vs DOL (GPL)

different from:

Win32 API (not GPL) vs GPL Example Application (GPL)?

Basically you guys are just saying you want all scripts that run on DOL to be GPL because that's just how you want it. There's nothing in the GPL that actually requires this.

It doesn't matter if the process that compiles your code is the same process that executes it or not, the location of compilation is irrelevent. It is only when you change the original source code that your code becomes virally GPL'd. And its not ALL of your code, only the CHANGES to the GPL'd code also become GPL'd. That's what they mean by derived works: new "works" created by modifying the original work.

I guess the bottom line is that if the Commercial-Applications-on-Linux example doesn't make it clear then you've already made up your mind and trying to explain it with more examples is just pointless.

The funny thing about this thread is: Who cares? I don't think any of us have enough time or money to handle intellectual property litigation and shit half of us live in countries where IP doesn't have the same weight as it does in the Anglosphere.

Well, I was just about to hit Post when I decided to check out Ye Olde Wikipedia: http://en.wikipedia.org/wiki/GPL

A key dispute related to the GPL is whether or not non-GPL software can dynamically link to GPL libraries. The GPL is clear in requiring that all derivative works of GPLed code must themselves be GPLed. However, it is not clear whether an executable that dynamically links to a GPL library should be considered a derivative work. The free/open-source software community is split on this issue, with the FSF asserting that such an executable is indeed a derivative work, and other experts disagreeing. This is ultimately a question not of the GPL per se, but of how copyright law defines derivative works. In Galoob v. Nintendo the Ninth Circuit Court of Appeals defined a derivative work as having "'form' or permanence" and noted that "the infringing work must incorporate a portion of the copyrighted work in some form," but there have been no clear court decisions to resolve this particular conflict.

So ultimately none of us are right until a court case can happen and a president is set. Until then I don't think its fair to tell someone that they MUST release their scripts but you could make it very clear that this is the suggested behavior for the benefit of the community... or whatever.

Different tangent but... You can't switch licenses now because you'll never get the consent of everyone that's ever contributed to the project. And yes, you need permission from EVERYONE that's ever contributed to the project in order to change licenses.

/waves to umm some ppl

[eshmeup16]

i hope i dont get screamed at but i stopped reading at page 3.. this is my view. please dont flame me.

From what i have experianced in life thus far being in courts countless times for doing countless stupid things i learned one thing

I cant say no one but for this case i will even tho its an impossible statement.
NO ONE will ever sue you unless they will make profit off of you.

meaning

If i run a shard thats no one makes a profit off of and anyone can play it no questions asked then it would be a bad and costly choice to sue the host because there is no money to be made, and lets face it modern society is all about ways to make money

And with this "gray" area everyone is talking about because the GPL isnt clear about something to me means that it can be exploited just know your boundries..

like they ask you that if you are to script anything blah blah blah u need to publish it to the public.. OK great go for it but they dont say how long of a time you have to make it public.. so to me this means i can write something and say hey of course im going to make it public but hell ill take my time to "perfect" the source code so it will be 100% stable..

there are loop holes everywhere and unless something isnt 100% then it will be taken advantaged of. its as simple as that

sorry for this rant, but after reading all of this and having alot to do with helping people develop their own custum shards i find i have a right to voice my opinion even tho im a newb in these fourms and pretty crappy scripter myself.

[hobobill]

Yes, the LGPL is more akin to the BSD license where not only can you make derived works and not release the code, you can also SELL compiled binaries. Big chunks of Windows actually contain Berkley developed and BSD licensed code. The license itself is really just a formality for legal indemification and whatnot.

The BSD and LGPL are very different. You are not required to release the source of derived works with the BSD style licenses under any circumstances. With the LGPL, this is only true when you dynamically link with the LGPLed binaries. Anything that is statically linked to LGPLed code is then considered a derived work. That's why the LGPL is referred to as the "Library GPL".

You can also SELL compiled GPL binaries. The GPL does not prevent you from selling anything. It just requires that you make the source available to anyone who obtains the binary. Free software is "free" as in "libre", not "free" as in "gratis" (that's called freeware).

Think about what you've said for a second. If this were true, no commercial software written to run on Linux would ever exist. NVidia has closed source drivers for Linux and there's no legal path for anyone to take to force them to open the code because its simply not a requirement. See at some point they had to compile the drivers and the drivers need to be able to read code from the Linux Kernel Source tree. If what you said were true then those NVidia binaries would violate the GPL because they're directly linked to the Linux Kernel Sourc

.

I direct you to this page. There is a myth in the Linux world that the Linux is distributed under a version of the GPL which has a special exception for binary modules. The referenced page has a lengthy discussion on the issue. Linus Torvalds participated. Below are quotes from him that are directly relevant to our discussion:

Nope. No such exception exists.

There's a clarification that user-space programs that use the standard
system call interfaces aren't considered derived works, but even that
isn't an "exception" - it's just a statement of a border of what is
clearly considered a "derived work". User programs are _clearly_ not
derived works of the kernel, and as such whatever the kernel license is
just doesn't matter.

And in fact, when it comes to modules, the GPL issue is exactly the same.
The kernel _is_ GPL. No ifs, buts and maybe's about it. As a result,
anything that is a derived work has to be GPL'd. It's that simple.

Now, the "derived work" issue in copyright law is the only thing that
leads to any gray areas. There are areas that are not gray at all: user
space is clearly not a derived work, while kernel patches clearly _are_
derived works.

But one gray area in particular is something like a driver that was
originally written for another operating system (ie clearly not a derived
work of Linux in origin). At exactly what point does it become a derived
work of the kernel (and thus fall under the GPL)?

THAT is a gray area, and _that_ is the area where I personally believe
that some modules may be considered to not be derived works simply because
they weren't designed for Linux and don't depend on any special Linux
behaviour.

Basically:
- anything that was written with Linux in mind (whether it then _also_
works on other operating systems or not) is clearly partially a derived
work.
- anything that has knowledge of and plays with fundamental internal
Linux behaviour is clearly a derived work. If you need to muck around
with core code, you're derived, no question about it.

...these days it would be hard to argue that a new driver or
filesystem was developed without any thought of Linux. I think the NVidia
people can probably reasonably honestly say that the code they ported had
_no_ Linux origin. But quite frankly, I'd be less inclined to believe that
for some other projects out there..

If you're still not getting it, think about plugins. If you wanna write a plugin for a GPL'd application, your plugin doesn't have to be GPL just because the application is.

This depends largely on the nature of the plugin architecture. The "interface" of an API cannot be licensed, but the implementation can. If the plugin architecture relies on a particular GPL implementaion of an API, then the plugins will be considered derived works and must also be GPLed. However, if the plugins were not dependent on a particular implementation, then they could not be considered derived works. This follows from Linus' comments that I quoted above.

And some code can't be GPL'd. Code that contains state secrets or personal information.

That is irrelevant. If you can't release your code as GPL it doesn't change the nature of the license. You just can't derive your work from GPL code.

What about databases? If I write some script that does some stuff to a GPL'd database server, my code doesn't also become GPL'd just because its linked to a GPL'd application. And if you look at it from a certain perspective, database data is just "code" that tells the database what to do. That code doesn't become GPL just because its stored in and gets to manipulate an application that its linked to.

I'm not sure what you are getting at. From the perspective of using SQL on a GPL database, that does not make your application a derived work. However, if you link to a GPLed database library - then yes you are creating a derived work and must abide by the GPL. MySQL is licensed under multiple licenses, but if you choose the GPL option then your application becomes a derived work if it links with the C-API MySQL ships with.

Actually you're wrong. You would be required to release the changes you made to the GPL'd source as source and you could release compiled binaries of that source along with your other compiled binaries that are linked to that source but you don't have to release the code that you've written that's not a derived work of the GPL'd game engine.

That's not true. All of your code that uses the GPLed code would become a derived work. You can't mix and match. It's not a selective license. The GPL is the most viral open source license in existence. If you add anything to the Quake 3 code base, not just modifications but some completely new system, you are required by the GPL to make that source available to anyone who gets your binaries.

Its a perfect example actually. Win32 isn't derived from GPL'd stuff but the code you just wrote is (for the purposes of this example). Just flip them around and its the same example. The position of the variables is irrelevent.

It's very relevant. The GPL works in one direction: it affects workd derived from GPLed code. You can't retrofit existing software with a GPL license just because a GPLed application uses it. That's ridiculous. The existing software is not a derived work of the GPLed software that uses it. I don't know how you can see it otherwise.

Umm you don't "derive" your code from the Win32 API, you link to it. We really need to have a good understanding of all of the concepts we're talking about here before using them in sentences. You link to libraries. You derive from previous works. Linking to a library is not the same thing as creating a derived work. Making changes to code creates a derived work. Linking only creates references and invokes stuff, it doesn't derive.

This is perhaps the biggest source of confusion surrounding the GPL and LGPL licenses. What constitutes a derived work? Logically, there's no problem with your distinction between deriving and linking. But your definition doesn't matter. Neither does mine. The only definitions that matter are those described by the GPL and LGPL. I can't remember exactly, but I don't recall that the GPL says anything about "linking". All it is concerned with is what is a derived work and what isn't (see below).

That would really be silly if all it took to force a company to open their source would be to create a GPLed application that links to theirs. There's absolutely no way such a thing could be enforcable.

Umm no shit and isn't that what I've been trying to say the whole time? Right? How is:

Shard Scripts (not GPL) vs DOL (GPL)

different from:

Win32 API (not GPL) vs GPL Example Application (GPL)?

These are two extremely different scenarios. I don't understand why you can't see the difference.

You are creating the shard scripts using DOL internals. Without DOL, there are no shard scripts. The scripts are wholly dependent upon DOL and are therefore a derived work of DOL (according to the GPL definition of 'derived').

The Win32 API existed before your GPL Example Application. It exists whether your GPL application does or not. It is not a derived work of your GPL application. The fact that your GPL app uses the API does not change this.

Basically you guys are just saying you want all scripts that run on DOL to be GPL because that's just how you want it. There's nothing in the GPL that actually requires this.

Wrong. The GPL does require this.

It doesn't matter if the process that compiles your code is the same process that executes it or not, the location of compilation is irrelevent. It is only when you change the original source code that your code becomes virally GPL'd. And its not ALL of your code, only the CHANGES to the GPL'd code also become GPL'd. That's what they mean by derived works: new "works" created by modifying the original work.

I direct you to the following entry in the GPL FAQ, which clarifies this much better than I can:

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.

As you say, nobody is right until a court decides. But the FAQ illustrates the intent of the GPL, and Richard Stallman, being the original force behind the GPL, has made his intent known in writings and discussions for years. When interpreting the GPL, it is best to interpret it in accordance with that intent as outlined in the FAQ.

The best course, of course, is to avoid the GPL altogether. BSD is much more palatable.

[Ogre]

I don't understand why you can't see the difference.

Because you want your interpretation to be correct.

But the FAQ illustrates the intent of the GPL

Intent and reality are often two very different things. Example: I didn't intend to kill all those people, I intended to go to the store and pick up more beer.

Bottom line: Shard scripts aren't GPL unless the author says they are. It doesn't matter if the "script" calls DOL code, Win32 code, .NET code, Mono code or some random crap that an infinite number of monkeys managed to hack out on an infinite number of typewriters. The only code that has to be GPL is code that is a modification of other GPL code. After all this discussion, if someone can't figure this out, then they should prolly pick a different career.