Slashdot Mirror
Vidomi GPL Violation Case Resolved
Andy Tai writes: "The Vidomi GPL violation case, previously mentioned at slashdot as the "first legal test of the GPL", has been resolved without going to court. Vidomi has split their program into two programs and released the source code of the encoder, which links to other GPLed libraries, under the GPL. The FSF has approved the resulting arrangement as compliant with the GPL." See the original story.
Me fail English? That's unpossible!
I'd hate to see the arguements here on Slashdot if Microsoft was caught using GPLd code. The problem with the first post's interpretation of the GPL is its severity. Imagine if someone at Microsoft placed a non-essential GPLd component into Microsoft Office, such as a jpg convertor. To be forced into releasing the source code for Microsoft Office + Windows (due to integration of now GPLd libraries) due to a minor infraction is completely unfair. The problem lies in what constitues a significant portion of the functionality of a program. Therefore, rereleasing the program to a state where it is no longer using the GPLd source is the only acceptable remedy.
These comments assume that the people who work on the proprietary source code are unethical. How do you catch a violation?
The truth is that companies do not steal the GPL code, but the software developers do. Sometimes it is accidental, however. For example a tool may have been developed for internal use and later sold. Alternatively, people who used the code may cycle out of the company before product release, thus reducing visibility into the licensing issue.
If a company learns about an infraction, it is vulnerable to a large lawsuit unless it tries to fix it. If it tries to hide it, then the company is vulnerable to a larger suit and those involved in the conspiracy may face jail or personal fines. There is incentive for them to play nice.
The company I worked for had their closed source code stolen about 5 years ago. The way we finally proved that they stole the code was showing that both their product and our product had the same obscure bug. After showing this to the judge/arbitrator (I can't remember if it was a full blown court case or arbitration) the case was over. They were forced to pay us lots of money to purchase rights to our source code so they could use it in their own product plus damages to us.
Exactly!!! A company I used to work for violated the GPL by compiling glibc into their programs. When it was pointed out to management their reply was, "So what! There has never been a lawsuit filed for it." (at that time, yes) The company even told the FSF that there was a problem and they were working it out. FSF said, "OK". The company released an "open source" version while continuing to sell the illegal version. This was a major factor in my leaving the company, before it hit the fan. One question I ponder is, what's the difference if the FSF will not stand up for it's own GPL? They did in this instance but didn't in a lot of other cases. Why worry about the GPL if practically no one will get sued. The names were changed to protect the guilty.
I'm the author of VirtualDub, and I'm posting as AC because I'm too lazy to look up my old login. I never thought I'd be defending Vidomi, but here goes....
:)
Mr. Moglen, the legal counsel for the FSF, was not retained by Vidomi, AFAIK. When I first emailed RMS for help in enforcing the GPL, he referred my message to Moglen, asking him to help as possible. Mr. Moglen was actually quite helpful in explaining the GPL issues to the people at Vidomi on our behalf, and negotiating a manner of usage that was compliant with the license. The FSF was thus quite helpful in rectifying this issue, so please don't belittle their efforts.
The proprietary encoder, GPL decoder, and the overseeing application are all running in separate process spaces; the IPC mechanism supposedly consists of window messages designed only to smoothly modify the visibility and position of the different application's windows. I have not had a chance to verify this in the source, but checks with DUMPBIN and HandleEx would appear to confirm that neither static nor dynamic links between proprietary and GPL code are taking place. Asserting that proprietary and GPL components of the package are reasonably a single program is a much harder sell now that they have been separated technically (process isolation) and functionally (player vs. encoder).
Regardless of whether I like my software used as part of theirs or not, the issue is compliance with the GPL, which is only concerned with the software itself and not the ethics of its authors. Any further attempt to attack the company at this point is probably unproductive and less likely to succeed. If you think the situation is still untenable, I suggest you make use of the code they have just added to the GPL pot, and attempt to outcode them!
Did I mention I hate dealing with licenses? Don't underestimate the influence of the FSF in providing a standardized license.
P.S. I just released more free stuff at virtualdub.org in celebration.
As long as the program as distributed is compiled and linked against the LGPL version of B, they're fine. If/when they distribute a copy of B to be used with D, they should distribute the LGPL version. The fact that it works with GPL versions of B too is a happy side effect, and there is no guarantee that later versions of B will still work. If later GPL versions of B break binary compaitibility with the LGPL version, they can't upgrade, since they're only allowed to distribute versions linked with the LGPL version.
To use a real-world example: Thousands of commercial, proprietary, closed source software packages were distributed linked to the Motif libraries. Then LessTif was released under the GPL; this did not force all Motif-based programs to be licensed under the GPL. The fact that Motif program "Foo" happens to be functional if you replace Motif with a GPL library is irrelevant, since Foo is not distributed as linked with LessTif. The binary compatibility does not make Foo a derivative work of the GPL code. If LessTif offered a feature *NOT* in Motif, Foo could not legally use it without becoming a derivative work of the LessTif, with all that entails, but as long as they stick to distributing based on Motif Foo is fine, license-wise.
----
----
Open mind, insert foot.
copyright != patent. Copyright says you can't use their code. You can implement it yourself no problemmo
I think most of the violations of the GPL are perpetrated by lazy and dishonest programmers within some more-or-less ethical company. For instance, some guy needs a regex parser, but Windows doesn't include any libraries for this (true the last time I asked, quite a while ago). Options:
1) go read about automata and regular expressions, and build your own parser.
2) go grab the first regex engine for which you can find the source.
I think many people would choose 2. Lazy and dishonest people may not check whether they are violating the rights of the copyright holder, or may intentionally disregard these rights. The company didn't mean to do anything wrong, but they don't even know this is happening. The guy gets fired eventually (hopefully all such assholes get fired eventually) and now nobody at the company knows about the violation, until someone discovers it accidently.
If you could watermark in such a way to make it easier for the dishonest, unethical programmer to use someone else's code (maybe they'll come across something with a BSD license) than remove the watermark, then you've protected your rights as the copyright holder. Honest, ethical programmers don't need to sweat the watermark issue, and encounter no additional barriers to assuming ownership of a copy of your code -- just as you desired. Of course, I have no idea right now how to make such a watermark.
-Paul Komarek
Copyright says that the recipients don't have any ownership of the code at all. GPL says you have ownership, but with some responsibilities. Seems to me that the GPL is less restrictive (you own it and can produce derivative works, etc) than copyright. I think you have the wrong idea about copyright, including the idea of "derivative works".
I can see why you use the term "infect". But "protect" would work just as well, as would "enhance". I expect that you use "infect" because you have a bias, probably one that you copy from other people. If this is the case, you might consider reading about copyright, and engaging your brain before opening your mouth (or typing =-).
Screw right or wrong. Simply put, the company isn't meeting it's obligations if it doesn't make it's best effort to prevent this sort of thing. They accepted those obligations when they assumed ownership (not copyright) of their copy of the library's code.
I really don't understand why you're picking on the GPL with this scenario. I expect that LGPL'd libraries infrequently switch to GPL. It seems much more likely that a commercial vendor would require a a new license fee for every version they released, regardless of whether you get anything more for your money.
For example, consider the mozilla/netscape split. Mozilla ended up recreating everything from scratch, because some of Netscape's code was integrated with closed-source products. That sounds like a much worse "infection" than your infectious-GPL example. At least in the LGPL->GPL example, one could continue using the LGPL'd code if one wanted, because one *owns* the code.
If you ever create anything worth owning, I expect you'll come to appreciate the purpose of the GPL and LGPL, and quit acting so high an mighty about your decision to disagree with them on an ideological level. You'll might even come to agree with them if you ever wish to own something you created after signing an intellectual property release for your employer.
The GPL and LGPL are well concieved licenses, and were produced with legal advisors. They are *not*, as you claim, ridiculous.
Why do you think that the FSF approves of this? Eben Moglen approves of this for sure, but he is not the FSF nor is he acting on their behalf or representing them in this issue.
The FSF have made no statement one way or the other.
"Pinky, you've left the lens cap of your mind on again." - P&TB
"I can see my house from here!" - ST:
--
So, putting 2 and 2 together, why can't the GPL be enforced in the same way? The lawyers get a cut, and the GPL gets enforced without the FSF or anyone else spending a penny.
--
Come on, people, don't be so hard on this! It is just a missing "t", a violation of English. It is not serious, like, say, a violation of the GPL.
Ok, seriously, sorry for the misspelling.
Free Software: the software by the people, of the people and for the people. Develop! Share! Enhance! Enjoy!
But the company hasn't really done anything wrong, have they? They never had to agree to the GPL, because they aren't distributing any GPLed code.
What if someone makes a library that's indistinguishable from libreadline, and distributes it with LGPL, BSD, or some other similar license. Then suppose someone distributes a closed source program that uses this libreadline clone. All legal right? But what if someone goes and installs GNU libreadline on a system that's got this closed-source program?
The fact is, RMS's belief that GPL can infect even software that only dynamically links is ridiculous, especially if one believes his claims that GPL isn't any more restrictive than plain old copyright.
you might consider reading about copyright, and engaging your brain before opening your mouth (or typing =-).
Ah yes, you can't face the truth, so you stoop to personal attacks. Perhaps you are the one who should try openeing your mind. And I'd be very interested if you can show me where in copyright law it states that dynamically linking constitutes a violation of copyright.
Simply put, the company isn't meeting it's obligations if it doesn't make it's best effort to prevent this sort of thing. They accepted those obligations when they assumed ownership (not copyright) of their copy of the library's code.
The company in the hypothetical story didn't copy the GPLed library, so how are they bound by copyright? Answer: they aren't. Yet RMS claims that any non GPLed code that dynamically links with GPLed code is a violation of the GPL. How can one violate a license they never accepted?
Perhaps you should read the GPL again. In section 5 it says: "You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works." The hypothetical company did not accept the license, so they're not allowed to "modify or distribute the Program [the library, in this case] or its derivative works". Well, they didn't modify or distribute the GPLed library, and their program isn't a derived work, since it was written before the GPLed version of the library existed.
I really don't understand why you're picking on the GPL with this scenario. I expect that LGPL'd libraries infrequently switch to GPL.
RMS has been pushing for LGPL libraries to be converted to GPL ever since he renamed LGPL the "lesser" GPL. People also occasionally convert things from BSD/X11 style licenses into GPL licenses as well. Expecting users of LGPL, BSD and X11 dynamic libraries to somehow prevent people from dropping in a binary compatible GPL library, which may not even exist at the time the software is written, is ridiculous.
Anyway, I don't think there's anything wrong with the GPL itself, except I believe the claim that non-GPLed software cannot dynamically link with GPLed code is completely bogus. If RMS and his flunkies will finally admit that the GPL cannot infect software that merely dynamically links, then I'll agree that it truly is less restrictive than copyright.
Incidently, I use the term "infect" because the GPL is commonly referred to as a "viral" licence because the GPL, like a virus, "infects" things. It wasn't intended to be derogatory, merely descriptive.
First, unless you accept the GPL, you have NO right under copyright law, except what is given to you by Fair Use Law.
In the hypothetical example, the company didn't copy, distribute or modify the GPLed library. Hence copyright does not apply.
Second, if you dynamically link to a library, you are creating a derived work.
I don't believe this to be the case in general, but especially not in the hypothetical example. Explain how a work could possibly be derived from something that was created later?
Let me repeat the hypothetical example, and spell it out a bit more clearly. Imagine the following events were to happen in the following chronological order:
- a library libfoo is released under LGPL (or possibly even an X11 or BSD style license)
- someone else develops a non-GPL program quux that dynamically links with libfoo
- a GPLed libfoo that's binary compatible with the original libfoo is released
So the non-GPLed program quux was written before the GPLed libfoo, yet it is possible that a user might install the GPLed libfoo as well as (the non-GPLed) quux. In that situation, quux would dynamically link with the GPLed libfoo, but no reasonable person would claim that quux was derived from the GPLed version of libfoo.Your statement would be like saying: Well, I confined the GPL'ed code to a seperate function in my program, so that the rest of my code doesn't have to be GPL'ed.
No, that's completely different. In that situation you'd have to copy the GPLed code in order to distribute your program. You're not allowed to do that unless you accept the GPL. The same goes for static linking. My point is that one only needs to accept the GPL if one is going to copy some or all of the GPLed code. Hence code that dynamically links with GPLed code does not itself need to be GPLed. The same goes for RPC calls to GPLed servers, calls to system() on a GPLed command line tools, etc.
It's important to understand exactly what the GPL is. Have you ever seen the copyright notice on the back of a CD case or in a book? It says something like, "Copying without express written permission of the author is prohibited." Well, the GPL is exactly that "express written permission." It grants exceptions to copyright law under certain conditions. It's a broad waiver of the monopoly right.
In my thinking that is correct. More generally, that run-time linking places a barrier on what the GPL applies to. kde 1.x used this argument among others.
Consider this scenario:
Distro "A" includes shared LGPL lib "B". Company "C" releases closed-source binary "D" that dynamically links against "B".
But, wait! Distro "A"'s *latest* version uses a new version of "B" that is binary-compatible with the previous version, yet is released under the GPL.
What is company "C" to do? All of a sudden they are distributing software that *could* be in violation of the GPL. (Yes, they could statically link that lib or do version checking. But is it really their responsibility to do so? What do they do about the copies already out there?)
Am I the only one that found it funny/ironic that Vidomi used GIFs for the scanned images of the letter from the FSF? Given Stallman's opinions scattered liberally around prep.ai.mit.org (next to every image), I cracked up.
cheers,
--sam
--sam
--sam
Any technology distinguishable from magic is insufficiently advanced.
But this is completely wrong: in the vast majority of cases where someone feels wronged and threatens legal action, the case is settled (just as it was in this case), which means that the two parties reached an acceptable compromise or one side backed down (and yes, there's too much of the latter in cases where one party has far more resources than the other party).
Cases that actually go to court are the exception: cases where a compromise could not be reached.
Richard Stallman wrote the GPL, with assistance from attorneys, including, I believe, Eben Moglen.
If you were doing it responsibly, IE, leaving a mix of old and new growth standing and truly planting as much as you were cutting down, then yes, it would be okay. I really wonder whether that works in the rainforest. From all the PBS shows I've seen the rainforest looks a lot more dense than regular forests (like those in US). The canopy of trees blocking the sunlight ensures that no other foilage will be able to overtake the trees. Removing some trees will break the canopy. I'm sure trees die on a regular basis but knowing that one needs a path to remove the trees it would seem that harvesting them would have worse affects on the rainforest.
.
Suits over behavior which has stopped are rare and difficult to pursue- "Yeah, your honor, he stopped doing it, but I want to sue him anyway." This sort of thing is most likely to happen if you're suing for monetary damages, but I get the impression that no monetary harm was done, so this would be difficult. The fact that as yet there is no legal precedent for GPL cases would make such a suit doubly shaky- the first test case really ought to be on a clear-cut and unbending violator, not someone who has already (effectively) admitted defeat.
"Never let your sense of morals prevent you from doing what is right" -Salvor Hardin
The FSF registers most of their copyrights. That means that they can get punative damages if it is violated. While I'm sure the FSF would be happy to ignore past violations if you open up the code, simply stopping may not always be enough.
If your code does not perform a significant function, it is quite unlikely that it will compete well with the free GPL software that it "wraps".
On the other hand, if you want to turn a GPL program into a photoshop plugin with a couple of wrapper functions, go for it! That's a legitimate use of the GPL -- to make a new facility using shared free code, even if it's for use with non-free code. Because eventually, someone will plug your photoshop plugin into the GIMP....
Press Release from the FSA
For immediate release.
Due to the ever increasing potential for GPL code violations, the Open Source community has formed an alliance with your best interests in mind. Details below:
Keep it Legal --it is fast and easy!
Businesses copy code every day. Many of them get caught, don't let this happen to you!
Remember, all it takes is one disgruntled employee to trigger an audit.
Keep your code legal, release early and often! If in doubt about the legal issues surrounding your code just follow these three easy steps to make sure all your code is in compliance with the GPL.
1. Download a copy of our code inspector software. Its powerful search capability will find suspect code quickly and easily. Just point and click your potential problems away.
2. Contact the FSA for a free no risk consultation. Get help with your licensing problems from the people who know licenses best, the FSA.
3. Release any code through our dedicated portal and licensing service. Fast, painless and legal.
Do it today, before it is too late.
Blogging because I can...
In KDE case they forgave use of their own code if any.
But realistically, they have the lawyer power to go
after violators, so if they choose not to intervene
on behalf of the copyright holder, then the likelihood
of a lawsuit is quite small.
Well, the FSF has a history of forgiving companies
and groups for initial mistakes with the GPL so long as they choose to become compliant. The latest one
was KDE/Qt debacle. The FSF seems to use its
leniency as a bargaining chip to bring people into
GPL compliance. IMHO, not a bad tactic.
That said, I am not seeing any indication of FSF
position in this case wrt past violations. They
may yet go to court, though I'd guess they have
better use for their money. OTOH, that press release
had "Open Source" all over it, so maybe RMS will
be pissed enough...
Vidomi has splited their program into two programs
I assume they splited off the part that included the spell and grammar checker.
---------------------------------------------
Recursive: Adj. See Recursive.
Beyond incredibly simple computing tasks, like writing simple sort functions, there is little chance of inadvertantly writing code identical to code found elsewhere. Everyone's code is different.
Copyright says that the recipients don't have any ownership of the code at all. GPL says you have ownership, but with some responsibilities. Seems to me that the GPL is less restrictive (you own it and can produce derivative works, etc) than copyright. I think you have the wrong idea about copyright, including the idea of "derivative works".
#include
No, GPL does not give recipients ownership of the code. If that were the case, there would be no such thing as GPL violations.
GPL leverages copyright to keep the software free (speech, not beer). The original author of the code retains ALL rights, including the right to copy, distribute or make derivative works.
Where the GPL comes in is that the author is licensing to you the rights of copying, distribution and making of derivative works, WITH CERTAIN CONDITIONS. The conditions are of course that you can copy and distribute and even modify the software, but only so long as you make the source code available and all copies and all derivative works must be licensed under the GPL as well. Never are you given ownership of the code, except that when you make a derivative work, you own the modifications and the original author owns the original code.
My journal has hot
It seems to me that if GPL does indeed allow this than it is a definite loophole that perhaps needs to be fixed in a new version of the license.
No. This would go against everything that Free Software stands for. The only way to implement it is to restrict/prohibit/regulate the use of the software. If the FSF does this and calls it freedom, I might as well throw away my dictionary.
Do not restrict runtime linkage and call it freedom. This is absurd. Of course it's a loophole. That's why it's free. If you didn't want any loopholes stick with proprietary software!
A Government Is a Body of People, Usually Notably Ungoverned
But what about a program developed using GPL header files...
The GPL does not regulate the *development* of programs. To quote: "Activities other than copying, distribution and modification are not covered by this License."
The typical header file contains only an interface to the library, and there is already case law that you cannot copyright an interface. A binary that was created using a header file does not distribute that header file.
One possible complication is with header files that actually include code (like inlines, templates, etc). This is problematic, but is still a corner case. For many of these fair use is applicable, but for a few, the terms of the GPL apply.
A Government Is a Body of People, Usually Notably Ungoverned
GPL is designed to prohibit the use of GPLed software in close-source non-free (in GPL's sense of the world 'free') programs
If GPLd software were indeed contained *within* the closed-source software, then the GPL applies. But in the case of dynamic and runtime linkage, this is not the case. The library is not a part of the application, nor contained within it. They may reside in the same process space, but it is the end user who causes that to happen, and the GPL allows complete and total permission to run the program for any purpose.
Dependency is not derivation.
A Government Is a Body of People, Usually Notably Ungoverned
If I do not accept/assent to the GPL, then I am not allowed to distribute or modify the program. Copyright law still allows me to use the program for any purpose, to copy the program for my own personal use, to reverse engineer the program, and to publish benchmarks and reviews on the program. (fair use is a slightly different matter).
When I create a binary that is intended to dynamically link to a GPL library, and distribute that binary, I am not distributing or modifying the GPL library. No part of the GPL source is included in my application, either verbatim or translated by a compiler. (a few exceptions exist, which I noted previously)
I've already teared aprt your arument in another psot
Wow! I didn't now that I had an arument that had an aprt teared in by a psot!
A Government Is a Body of People, Usually Notably Ungoverned
Although shared/dynamic linking doesn't change the binary on the HDD, It does alter it in RAM, making it impossible to tell apart where the your program ends and the library starts, thus modifying you program.
The alteration of RAM is performed by the end user in the privacy of his or her own home. The GPL does not apply, and specifically says so ("The act of running the Program is not restricted"). I, myself, have not distributed, modified or publicly copied any GPL covered software.
And please look up the definition of "modify". Being unable to distinguish the boundaries of the library in RAM does not constitute modification.
A Government Is a Body of People, Usually Notably Ungoverned
It doesn't matter what the FSF says, or what RMS says, or what the general opinion on Slashdot is. All that matters is what copyright law and the GPL say. A program linked by the end user at run time to a GPL library is NOT a derivative work! If you disagree, please cite copyright law where I am wrong. I've searched and searched and I can't find it.
A Government Is a Body of People, Usually Notably Ungoverned
All that matters is that they use GPL'ed works.
Wrong. Usage of GPL'd works is completely unrestricted. It only restricts copying, distributing and modifying the work. To quote from the GPL: "Activities other than copying, distribution and modification are not covered by this License."
The license says "if it is linked in thus-and-such a way, you must do these things."
To quote the GPL again: "a "work based on the Program" means either the Program or any derivative work under copyright law."
The GPL is operating under copyright law. It cannot change copyright law, and copyright law is completely silent on the topic of linking. The GPL does not apply to linkage unless it can be demonstrated that the linking process copies, distributes or modifies the Program. It does none of these. (actually a copy is created during program execution by the end user, but the copyright law and the GPL already allow that).
This is no different than a MS license saying "you may not publish benchmarks of this software without consent."
The GPL does not take away any rights already granted by copyright law, and clarifies this point in section 5. The Microsoft EULA, on the other hand, takes away rights that the law has already given to the user. You already have the legal right (in the US) to publish benchmarks about Microsoft products. If you agree and assent to the MS EULA contract, however, you have agreed to waive that right.
A Government Is a Body of People, Usually Notably Ungoverned
No. You are confusing the issue.
If those who received the 'gpl-violating' code were not given it under the terms of the GPL, then they have no reason to expect source, or anything else guaranteed by the GPL.
That is a *totally seperate issue* from the fact that the company was using GPL'd code in it's products and failing to distribute it under an appropriate licensing scheme; that's up to the authors of the code in question to deal with.
Just because someone used GPL'd code, didn't license it properly, and released a binary does NOT mean that everyone should get their source; it just means they violated the license under which they were given the GPL'd code in the first.
No, the GPL does not allow _linking_, but linking is NOT the same thing as communicating via some sort of message passing.
.so (linking) and sending messages down a pipe, or using a shared file.
... or any of the other closed-source apps that are really nice to have on Linux.
On some architectures, that line can get blurry, but under Windows and Linux it's pretty clear.
It's the difference between calling a function in a DLL or
This is NOT a loophole that you would want to close. Suppoose you did, and you created an operating system and libraries that used your "improved" license. No one would even be able to RUN closed source software on it, because running a program under Unix involves _exactly_ the same mechanisms that you would have "closed". So say goodbye to Oracle or Quake 3 or Wordperfect or ViaVoice
The GPL strikes a very, very fine balance between the rights of users to have control over their software, and the ability of programmers to write closed source software and still run it on an open system.
It is true that things can become blurry. On some "message-passing" style operating systems, there's less of a distinction between a function call and interprocess communication. Luckily, that's not really an issue for any popular OS right now.
Torrey Hoffman (Azog)
Torrey Hoffman (Azog)
"HTML needs a rant tag" - Alan Cox
while, in theory, your fears do have a basis, in practice, i wouldn't worry about it. most big corporations out there are extremely paranoid about making any kind of internal legal/licensing errors. these are the same people who spend thousands on licensing C compilers and making sure that every single windows installation is 100% legit. they're just as afraid of lawyers and such as any of us (if not moreso). and chances are that their source code is constantly under review, and it is often licensed/sold to other companies and/or universities (even microsoft lets universities and such look at some of their source). for a big company, it is extremely important to make sure your source is legally self-contained, because you never know when you'll be selling it. and what if you inadvertently hired an RMS-like zealot to work on your shady source code? there's just too many risks, so its just not worth it.
what i would worry about, however, are the many small software/hardware companies who are illegally abusing, and profiting from GPL'ed code. there's no way of knowing if they're in the wrong. additionally, they have the protection of anonymity.
personally, i don't give a damn. while the GPL has its place, too many people are slapping the GPL on their projects simply because its fashionable. i release any of my personal projects under no license whatsoever, so if some poor schmuck really wants to use my code for his employer's closed source project, he can. maybe it will let him come home an hour earlier to spend time with his kids, watch tv, smoke crack, or whatever. seriously, who cares? in a truly Free world, no one should be forced to collaborate.
Well, it's that time of the year again when some randomly chosen, poorly-funded company (or misguided individual) decides to go thumbing theier noses at the generous, enlightened hackers who free their code to make the code better and to make the world better. What are they thinking? "Fuck 'em! What are they gonna do about it?" is what they're thinking.
We're smart. We have the GPL.
Hasn't stood the test of trial yet, but it looks pretty damn good. That's all we need. GPL is a technical and legal instrument and was conceived as such. But we are finding that it has an emergent property: Not even the dumbest of dumbasses is going to publically defend themselves in court for "stealing" GPL'd code. Not only are they stealing from someone who was toughtfull and kind enough to free their code for everyone but they're stealing from everyone who would ever use it.
It is P.R. suicide. It is the equivilant labeling your tuna cans with stickers that read: "This product contains 10% dolphin, we just grind 'em up and chuck 'em in with your fish cause they're too stupid to stay out of our nets. Goes great on standwiches."
well at least we have some chance to survive so we won't have to make our time!
Don't trust a bull's horn, a doberman's tooth, a runaway horse or me.
--------------------------
"Any fool can make a rule, and any fool will mind it."
"Any fool can make a rule, and any fool will mind it."
--Henry David Thoreau
Your posts on this subject really highlight how obsolete our intellectual property laws have become. For instance, in the old days, things that could be copyrighted and things that could be patented were obviously different. But computer code seems to lie in a gray area. On the face of it, code seems to be speech, and should therefore be copyrighted. But if you think about it, code also functions like a machine. Fundamentally, programs execute almost like virtual clockwork, and therefore should be patented. So which is it? No one seems to know. Maybe we need a new category, or maybe we should radically reform the whole notion of IP. I think most /.ers would prefer the latter. ;^)
I think it is clear though, that if our policy makers keep applying band-aids like the DMCA that only make the situation worse, then all IP laws will begin to lose power when almost everyone regularly violates them. I remember, about ten years ago, seeing a guy on TV (I believe he was from a think tank or something) talking about how intellectual property would be one of the most important issues our society would have to deal with in the 21st century. At the time, I thought he was crazy. I just couldn't see how ideas, and the ways they are regulated, are all that important. Man, that seems naive now.
--------------------------
"Any fool can make a rule, and any fool will mind it."
"Any fool can make a rule, and any fool will mind it."
--Henry David Thoreau
This is true, but practically speaking, patents work almost the same way. We see it all the time; someone gets handed a ridiculous patent because the USPTO does no research on prior art. The patent can later be overturned in court. Likewise, a copyright can be invalidated in court, if, for instance, the copyright holder turns out to have copied someone else's work.
In the example discussed above, let's assume that the USB specifications are so detailed that there is only one way to implement it. I would say that the code is therefore not an original work, as it is really just copied from the spec. Therefore, such a copyright could justifiably be overturned in court. Bear in mind though that IANAL, so I don't know how such proceedings would actually work. I'm just speaking hypothetically.
--------------------------
"Any fool can make a rule, and any fool will mind it."
"Any fool can make a rule, and any fool will mind it."
--Henry David Thoreau
This brings up an even larger issue: if there is something that can only be accomplished one way, and people are likely to find the solution independently, should such a thing even be copyrightable (if that's a word)?
It seems to me that the purpose of copyright is to prevent freeloaders from ruining a system. I guess I'm thinking along these lines because I've been using the gnutella network lately and there is a lot of discussion on how to keep freeloaders from ruining that system, but I digress... :-)
When looked at this way, the GPL and proprietary licenses both use copyrights to keep their respective developement systems working properly. Companies like MS charge money so they can pay their employees and shareholders, while GPL'ed projects force code users to release the code for changes or additions. Both, in their own ways, allow for the continued development of the software, while avoiding a "Tragedy of the Commons" type of situation by making freeloading difficult.
However, I think it is clear that in a situation like you have described, there is no freeloading involved, so a copyright should not apply. I'm not sure how copyright law actually works, though, so this is just speculation. I seem to remember that patents are only supposed to be granted for works that are not obvious to an expert in the field (not like this matters in practice). Perhaps copyrights work the same. Do any lawyers out there have more info?
--------------------------
"Any fool can make a rule, and any fool will mind it."
"Any fool can make a rule, and any fool will mind it."
--Henry David Thoreau
I can't decide whether this is a good or a bad thing.
Great, another company conforms to the GPL and the world is safe for (democracy|socialism) once again. And of course if this had gone to court and the notoriously short-sighted and conservative US courts had given the verdict to Vidomi, it would have opened the floodgates for cases against the GPL.
On the other hand companies may still try it on just as Vidomi did because there still hasn't been a verdict FOR the GPL. In the long run, we need to see the GPL upheld by the courts before we are really safe from the marauding pirates.
Bzzzzzt..."AAAAaaaaarrrgh!!!" Thud.
"Would it be possible to compel the company to show its source to a court in the event of a lawsuit?"
. html has a little info about that.
Of course! That's what the discovery process is all about. http://www.nolo.com/encyclopedia/articles/cm/cm11
Become a FSF associate member before the low #s are used
We take great pains to give credit to people who write good code, but pound-for-pound, the GPL seems to be doing more good for the Free Software cause than any piece of code.
So, who deserves the credit for the GPL? Is it Richard Stallman himself?
--
Patrick Doyle
I mod down every jackass who puts his moderation policy in his sig. Oh, wait a sec....
It does indeed seem so. Although the FSF seems to get a lot of mileage out of the fact that the GPL has not been tested in court - no company has yet been willing to call their bluff.
Female Prison Rape in NY
Okay, while I'm glad on general principles that there's that much more money not going into the pockets of lawyers, I was looking forward to seeing whether the GPL would actually survive a legalistic grilling from a judge.
Since it hasn't been tested, threatening GPL violations is still sorta at the bluff stage, or so it seems to me. There's still no precedent.
You cannot apply a technological solution to a sociological problem. (Edwards' Law)
>The truth is that companies do not steal the GPL code, but the software developers do.
I disagree with you here. the developer does put the GPLed code in the program that he's writing, but the choice of license is the companies choice. since the GPL allows inclusion of code, the developer did nothing wrong. The company bringing the program out as a closed source app IS infringing on copyright.
//rdj
No one can understand the truth until he drinks of coffee's frothy goodness.
--Sheikh Abd-Al-Kadir, 1587
It's nice to see that this was resolved out of court. I'm sure we will be seeing more of this in the future...
Um, this is my sig.
If the company felt it was going to win, it would've continued the case. This represents a victory by the FSF and the GPL. Remember that the company first refused to comply, went to court, and have now backed down and have agreed to comply. Someone scored a point here, and it wasn't the company that was in violation of the GPL.
No, the judge didn't rule since they settled out of court, but the solution - "fix it so it complies" - is undoubtably what the judge would've ordered if the FSF had pushed to the end and insisted on a full trial.
What do you imagine the FSF's goal to be in such a case? It appears that their notion of their goal is to force companies to comply with the license.
They've succeeded in this case.
This is true. Although for the ethical publisher, the idea of a watermark convention for GPL'd code would help then, wouldn't it? You wouldn't have to know the development details in order to have some sort of standardized check for GPL'd code.
.... I guess I was thinking that it was more worth concentrating on how to detect intentional violators. It would probably be easier to catch them, easier to prosecute, and thus fuel the neccessary awareness to reduce unintentional violations? Just a guess, tho.
.. yes, DMCA, not DCMA .. damnit, when it comes to acronyms, I just choose the one that rolls off my tongue the easiest. I hope it doesn't distract from the point of my comment. Thanks!
I guess part of my assumption, and I do admit its a big one, is that unethical violations are less significant than intentional violations. Of course, this also assumes everyone has the same measuring stick for valuing loss due to violations
And thanks from the other guy above
"Old man yells at systemd"
In this case, I'd have to say that the developer is in no way liable, since technically, the copy of the app s/he distributed included a non-GPL'd lib. If the distro then switches up libraries, it is the distro'er who is distributing binaries that violate the GPL, not the developer. If the developer provides LGPL libs with their distrobution, it is the distro'ers responsibility to ensure that that library ships along with it.
I havn't read the full GPL in some time, but I believe the key issue is in how the binary is distributed. If it is distributed with a LGPLd lib, they are not violating the GPL. If the distro then goes and switches things around, I'd imagine they would be the ones violating the GPL, and could be held liable for damages to the GPL'd lib they substituted in. It really is up to the distro'er to adhere to the licences attached to the software they plan on redistributing.
All that said, this relies on me assuming that dynamically linked libs DO fall under the umbrella of GPL? It doesn't seem like an unfair proposition, but maybe that's not true?
"Old man yells at systemd"
Considering the grey-area of what constitutes 'stolen code', I don't think there will ever be a way of being 100% sure. Is taking a clever 2 line 'for' loop from someone elses code (that doesn't contribute greatly to the core functionality of either the GPL or the code-stealer's product) stealing? This has probably been discussed at length at /. before, but I thought it was worth pointing out that nothing is black and white (or whatever colors you've set in your terminal ;).
.. with all the DCMA bruhaha going on, the core issue is trying to catch 100% of all infractions. I'd think it to be slightly hypocritical to suggest that the GPL community should go all out to ensure 100% compliance given the resistance to similar efforts from the content/media industry. I think 10% of technical infractions (and I'll argue that they are the visible, obvious, easy to detect infractions) of both the GPL and DCMA misuse constitutes 90% of the loss for both licences/acts. In the case of media, the loss is revenue and control, in the case of GPL, the benifits of collaberation, credit, and revenue to the original authors of code. In fact, if it can be prooven that not writing up tons of technical barriers and legal restrictions beyond the core purposes of the GPL doesn't damage the community to a large extent, it'd be good fodder to throw back to the backers of the DCMA .. you'd be able to say, 'Chill ... we know there is some misuse, but we're still in business and benifiting off of the existance of the GPL. Same should go for the DCMA.' You know, like J-walking .. its technically illigal but not econmically or socially viable to persure means of ensuring 100% compliance. In other words, the possible loss in value resulting from infractions of the GPL and DCMA are not worth the inconvenience of pursuing 100% compliance.
.. okay, putting on my flame retardant suit now. Interesting question tho .. I've thought about this a few times myself.
Okay, so once you can really define what is 'stolen' code, I'd imagine that it shouldn't be too hard to:
- check the symbols in the binary to see if there are any symbols that match up against the GPL'd lib in question
- check what the binaries are dynamically linking against (although I doubt you'd be so lazy as to link against a GPL library dynamically and not expect to be caught)
- check the strings in the binary to see if they contain any strings known in the GPL'd code in question
Of course, this assumes you already have a suspicion that a binary might be violating the GPL of software 'X'.
I almost wonder if it shouldn't be a convention to include some sort of static char buffer 'watermark' in GPL'd libs/APIs, so you could search a suspect binary. Granted, the stealer could recompile the GPL'd libs without the string, or just steal code verbatim, but like I said, its impossible to get 100% certainty.
You know what tho
Just a few thoughts
"Old man yells at systemd"
Use the strings program to find GPL related strings.
A long term approach could be to insure strings get into the code that do mention the GPL and copyright. For a C/C++ file, this could mean including a header file with the GPL & copyright in a string--provided that the string ends up in the executable. Then you run strings and magically the GPL and copy appear. This of course is not a perfect, but there sn't a perfect way to do this.
At the next eco-hypocrisy-meeting, count the private jets used to get to the meeting. Should be interesting to see that
What is company "C" to do? All of a sudden they are distributing software that *could* be in violation of the GPL...But is it really their responsibility to do so?
Yep. The company has three options; A patched version that does version checking, a static version against the old lib, or ask for permission from "B"'s author to continue using it under the LGPL.
What do they do about the copies already out there?
Welp, they're now potentially in violation of the license. You'd better give them all the newer version of the software that doesn't potentially infringe. (Or in the case of a special license exemption, do nothing at all.)
Before you start poo-poohing the GPL, this happens in commercial software and development tools frequently.
.sig: Now legally binding!
The "FSF Approval" is no such thing.
Despite Vidomi's characterization of the letter, this letter is very clearly and explicitly written by an attorney who HAPPENS also to be the FSF's "volunteer General Counsel", but who is writing this as counsel retained BY VIDOMI.
You read that right. The letter states quite clearly that Vidomi retained Prof. Moglen to get his educated opinion on the legality of their system. The letter is written on his Columbia letterhead. The FSF has nothing to do with this opinion letter.
It seems to me that Vidomi has the in-writing opinion of FSF's own general counsel, as well as the opinion of one of the GPL-code authors, but very much doesn't have RMS's blessing. I don't think the story ends here.
If the implementations are exactly the same, right down to the symbols, then that would definately warrant a raised eyebrow. It should still be licensable of course. Otherwise someone could write a similiar implementation to, lets say a method of sharing files between windows machines, and then because their fresh implementation resembled the preexisting item, the preexisting developers would be forced to give their code away.
That might be hard to understand. I'll try saying it again. :-) If I write a program B that performs the same as program A, does the author of A have to give his code away because A & B are so similiar? See, it doesn't make sense like that.
BTW, I once thought I'd lost some code, so I reimplemented it a few weeks later. When I did find my original code, the original and the reimplementation were near identical, right down to the variable names. :-)
Slashdot has been around for quite some time I reckon?
"Easy does it!
This comment has been submitted already, 276534 hours , 42 minutes ago. No need to try again."
Ahh, I remember the good old days, when we carved our posts into stone and sent them via Dinosaur-mail to the moderators.
You are not entitled to your opinion. You are entitled to your informed opinion. -- Harlan Ellison
To be forced into releasing the source code for Microsoft Office + Windows (due to integration of now GPLd libraries) due to a minor infraction is completely unfair.
No, it's the consequence of using GPL'd code. MS has the resources to ensure that this doesn't happen. It's really simple - if you don't use GPL'd source code, you are not subject to the GPL. So if you don't want to open your source, don't use GPL'd code. Did I mention that it's really simple? They may PRETEND not to understand that, but they do.
--
"that's not encryption - it's a new perl script that I'm working on..." - from some Matrix parody
Actually, this is exactly the main method of "getting around" the GPL. The only drawback is that this involves some increased latency so its not really suitable for high-performance software.
Since it isn't actually linked with the GPL'd code but rather uses bog-standard IPC, then there really isn't anything that can be done, unless someone wants to try and make the GPL applicable to anything that a GPL'd program talks to, which I'm pretty sure would never fly.
I don't see how they "got away with it".. Sure, they didn't end up in court, it all could get solved quietly, but the part of their program that was linked to GPL'ed code did get GPL'ed itself. So the requirements of the licence are now met by their product. What I see in this is, even though the GPL didn't get tested in court this time, the company did take the lawsuit seriously. The violation was noticed, they were asked to do something about it, and they complied. Maybe not as graciously as one could have hoped, since they kept what they could get away with out of GPL'ed, but well.. Now, what would have happened if no-one had noticed the use of GPL'ed code in their product.. well that's a problem with any licencing scheme, except maybe public domain stuff, not only GPL.. I suppose we'll have to trust the community to spot potential GPL violations. All in all, it still looks "somewhat good" to me.
How can the user infringe if the GPL supposedly has no restrictions on usage? Unless the GPL output is GPLed itself, as it was for bison, but that's a side-issue. For example, I'm perfectly within my rights/privileges gratiously handed down to puny little me, if I start linking closed source and GPL in my own projects. As long as I don't distribute it.
Personally I think the GPL has its place, but I think RMS and FSF should admit that if the GPL restricts dynamic linking, that is indeed a restriction on use. The phrase "Free software" is okay, since the software is still free, it's just that the distributors aren't. There should be no "fuzzy" areas.
Speaking of fuzzy areas, one way to judge in these cases would be see if the program can run and perform the functions within the library, adequately _without_ the dynamic library. So the user must indeed choose to use the GPL library him/herself. If it's distributed with the intention of linking with a GPLed library, it's leaning to the stance of the FSF IMHO. Remember that a licenses is not a program. It includes common sense, even though it doesn't always seem that way.
- Steeltoe
http://www.debunkingskeptics.com/
Wether if it's "okay" or not is pointless bickering. "Okayness" is subjective. You can't expect a change in behaviour by someone hitting you in your face by hitting back. That's exactly what's happening in destabilized regions of the world. Karma (the belief that someone hurt or pleased you) will just continue the fight until someone wisen up and calls it quits.
FSF doesn't have to do anything. Nobody just _have_ to react. Instead you can consider your options and figure out what's best. Bringing in analogies doesn't do anything but cloud the issue at hand and add fuel to the fire of _reaction_. When you react, you have limited sight and options. If all we do is reacting to circumstances, we're no wiser than animals.
- Steeltoe
http://www.debunkingskeptics.com/
disgruntled employees
A large number of software copyright violations are not found by audits, but by ex-employees. This won't get every company that does this, but it can get a surprising amount.
The unethical developer woould put it in on purpose in case they were let go under poor terms.
-no broken link
The original author of VirutuaDub put up a page about Vidomi where he mentioned that SloMedia infringed seven projects (VirtualDub, FlaskMPEG, DVD2AVI, MPEG2DEC, AC3DEC, XingMP3, smart deinterlacer). Does the newly GPLed source cover all the infringing projects or just VirtuaDub.
Either way the VirtuaDub author seems just as pissed as most of the Slashdotter here about how they nver released the original source.
--
The point of the GPL is to ensure that open-source programs remain open-source and freely modifiable.
Wrong. The point of the GPL is that users of software have complete and total freedom with the software they've been given not the next version or the one after but the version that was distributed to them.
I don't see why using it as a lever to get a company to release proprietary source code they never intended to open would do any good.
If the proprietary code is made up of seven different Free Software components then the users of the software are supposed to get the source for the software.
--
Nice ad for you weblog dufus!
Some people have a way with words, and some people, um, thingy.
So, to apply this to the current situation, I would tend to agree with the earlier (parent of the parent) poster that the courts would not force the company to release their source code. Their greatest liability would probably be the revenues from the sale of the software, or possibly their development costs.
The only "intuitive" interface is the nipple. After that, it's all learned.
"The question of whether a computer can think is no more interesting than that of whether a submarine can swim" -EWD
It doesn't have to be a derivative work. All that matters is that they use GPL'ed works. The license says "if it is linked in thus-and-such a way, you must do these things." This is no different than a MS license saying "you may not publish benchmarks of this software without consent."
The only "intuitive" interface is the nipple. After that, it's all learned.
"The question of whether a computer can think is no more interesting than that of whether a submarine can swim" -EWD
Imagine if everyone went around prosecuting everyone without giving them a chance to right their wrongs. That's certainly not how I'd want things to work.
The only "intuitive" interface is the nipple. After that, it's all learned.
"The question of whether a computer can think is no more interesting than that of whether a submarine can swim" -EWD
This quite good for the GPL. Now "problems" like the MySQL AB and NuSphere issue may be settled much easier then was previously thought.
Bingeldac denies any responsibility for the
spelling and/or grammatical errors above.
I don't see why using it as a lever to get a company to release proprietary source code they never intended to open would do any good. That would give Microsoft plenty of fuel for their "viral GPL" argument -- "See, if you even touch this stuff you'll be forced to release the source code for your ENTIRE PRODUCT LINE!"
Sure, Vidomi screwed up. But the gracious settlement ("Just fix it and we're cool") seems a lot better for all concerned.
No one can be forced to license their code under the GPL, even if they have violated the license. If a company violates the GPL, either deliberately or by misunderstanding the requirements, it is a copyright violation and should be handled as any other copyright violation. They really have two choices when it comes to resolving this: open up the violating code, or stop distributing it. They chose to take the second option and stop distributing the program in a manner that violates the GPL. Compliance has been enforced.
Yeah but noone wants to go after Procom for their violations.
this isn't offtopic, it is a problem
This Wiki Feeds You TV and Anime - vidwiki.org
So did they ever release the source for the earlier binary that was causing all of the trouble? It would be like Microsoft making MS-Linux, but not releasing source code, and then, in order to settle out of court, they make another different version called MS-Linux XP which has things separated to avoid lincensing issues. The point is that the issues are with a different binary and a different code base! Breaking the GPL and then releasing a different similar binary and source code can't be an accepted way to allow people to break the GPL and get away with it.
How many companies must Stallman destroy before he forgets about Symbolics.
Let's find out. A-One... A-two... A-threeee... CRUNCH! Three.
For all intensive purposes, "whom" is no longer a word. That begs the question, "who cares"?
FSF clearly thinks this is not legal, and I hope they're right about that. Otherwise this would foil the entire GPL.
<snip>
I know. And what you say of what I may or may not do, I very well know that's what FSF holds to be legally true. I was only wondering how it can be infringing to distribute a non-GPL'd program which at runtime only is linked with GPL'd code. Note that I'm not attacking GPL - I certainly hope that it holds in court one day.
Your attempt to differenciate "distrubution time" and "runtime" shoes me that you don't have alot of experience as a programmer. There is not difference.
I might have more experience as a programmer than you think, and I still maintain there's a HUGE difference between runtime and distribution time.
To me, running my program or uploading it via FTP are two very distinct things.
You make a program that is proprietary. You make in your program a mecanism that allows plugins through dynamic linking. Someone writes a GPL plugin. Who's the infringer? The user, you or the plugin writer.
Well, this is basically what I tried to ask, but you put it better than me. And again that the plugin writer is the infringer is the legal opinion of FSF. But my point was, how is he infringing? Now he doesn't do the linking, which only happens after distribution, where the license no longer can have effect.
I think about this in a way analogously to having references in a book you write. I think this is analogous because
1) In both cases, the copyright is owned by whoever wrote the thing
2) Making 'full use' of the thing requires the user to already have the linked-to material (shared libraries or other books)
3) No material under copyright from other authors' books or software ever is distributed.
Now, please tell me I'm wrong (and if you do, point out why). After all, I want to have the freedom to write GPL programs myself without the fear that they will end up in a proprietary product which "extends" the functionality of my original program, only now as a GPL'd library.
I mean, if (and only if) it would be held that without these exceptions distributing proprietary programs for Linux would be infringing, there's a little problem. It's no longer that the distributors of proprietary software are infringing the Linux kernel copyright, but that making such exceptions requires the acceptance from every contributor.
That is to say, if I wrote a GPL'd program originally to run on, say, FreeBSD, and someone ported it to Linux, this would be infringing my copyright. Let me explain why.
This way, the Linux kernel was sort of linked to my program (or vice versa, it really doesn't matter). Now, also the proprietary program, e.g. Netscape, is in similar stance. The net effect is that my program has been linked with proprietary Netscape code, albeit through an abstraction layer, and entirely without my consent, thus infringing my copyright.
Again, before flaming, please read again the word 'if' in the beginning of this post. I'm not trying to attack GPL. It's a truly great license, and the one which I have chosen for some of my programs out there.
This is where I think the logic fails. The program flow surely is transferred between the program and kernel. For example, when I open a file, I make a call which causes kernel file system (and possibly lot of other) code to be run. What you're talking about sounds like you were thinking of some byte code, or otherwise interpreted language. At least in the case of machine language, I still don't understand why this doesn't qualify as linking and libraries do.
Dynamic linking constitutes derived work because you are enhancing your program by using library functions(libc is an exception). There is nothing different about static, shared or dynamic in this sense.
Yes, the linked program is derivative, I agree on that. But this linking is done at run-time, so this makes me wonder whether only the resulting memory footprint is derivative. And licenses can only control distribution, not how you use the work. It's like potato chips and dipping sauce. Dipping sauce would be pretty much useless without chips, yet it clearly is not a derivative work. I can also think about examples in the IP field, like a data sheet and a user's manual or instruction reference for a microprocessor. Neither is very useful alone, yet they are two separate works (neither is necessarily a derivative of the other) and their copyrights can at least in theory be owned by two different legal entitites.
Correct me if I'm wrong, but I'm under the impression that linking GPL code with Motif libraries is not infringing, nor is running the program, only distributing the resulting code/binary is. That is, even if the original toolkit in your example was not LessTif but, say, GTK and I somehow managed to replace GTK with Motif, I believe I wouldn't be infringing unless I actually distributed the program.
But how about this scenario:
I write an operating system, possibly under GPL. Be it that it only includes a boot loader, memory allocator and disk access + file system routines, so I'm not talking about any end user OS. I take other people's GPL code and run it as an application (not in the kernel space). Now, I proceed to write e.g. a massive and proprietary game as just another application.
Now, I believe and hope that this would be infringing. I can almost hear the authors of that GPL'd code yell at me. Yet I think it's quite similar to what's being done with Linux.
See #300 for my reasoning about why no-one is infringing in your example, and why binary compatibility has nothing to do with this. I believe that in this case even FSF would agree this isn't infringing as long as the result is not distributed, however I can't speak for them.
I think that it's a good think that posts are not edited before posting (except occasionally for brevity).
Umm, good point, except look again... They did fix it. They may not be edited before posting, but they sure are edited after posting.
ok then your [sic] infringing on my copyright! Could you as [sic] me next time before STEALING my comments for your own?
IANACRL (IANA Copyright L) but I think that this is misconstrues current copyright law. Copyright applies to a work and derived works, not to works that happen to be similar incidentally. IOW it would be a valid copyright defense to show that you came up with your idea independently even if it did look very similar to somebody else's implimentation. You could probably do with good record keeping. CVS entries, memos about design discussions, etc. could be used as evidence that your solution came from your own decision to approach the problem in a particular way and not from copying the other guys' code. It would eventually be up to a jury to decide wether the evidence favored you, and my gut feeling is that if you actually did come up with the idea independently and had documentary evidence to prove it that you could convince a jury.
There's no point in questioning authority if you aren't going to listen to the answers.
The courts would actually use something much simpler than this. They would appoint a "Special Master" (I think that's the right term) who is basically someone who the court thinks is both knowledgable enough to tell if the code may have been swiped and honest enough not to blab any trade secrets. He is then given access to both codebases and looks them over to see if there's any evidence of wrongdoing. If he thinks that there's enough evidence to go forward, then the lawyers are allowed to subpoena the code and let their experts go over it with a fine toothed comb to find obviously snagged chunks of code. The code would probably remain under seal, though, which means that there would be very harsh penalties for letting anything slip (at least until after a determination that the code had been lifted and must be made available). If the final decision is that copyright violation has not taken place, anyone who did leak the trade secrets would be in deep trouble.
There's no point in questioning authority if you aren't going to listen to the answers.
One of the biggest dissapointments I have in the US judicial system, is that it does not generally foster an attitude of compromise.
thats not what itds really for. It's supposed to be the way to get to a final point when all other options have been exhausted
Your disappointment should lie with people and corporation that see the courts as the ONLY way to solve something, instead of looking for other solutions first.
I know this is off topic, but I think people really need to make an effort to understand the US judicial systems history, or at least an overview. Much to my surprise, in the context of history, much of it actually does make sense.
The Kruger Dunning explains most post on
Strictly speaking, the GPL cannot prevent you from distributing anything that you have written yourself, since you are responsible as the copyright holder for enforcing the license. However, you would need to add a special exception to the license giving others permission to link it against the MFC, or else nobody else would be allowed to distribute it.
Take a look at Galeon's license for an example of this. The Gecko library is under MPL, so they have to give special permission to link to it.
Explanation from the FSF's GPL FAQ.
Quantum mechanics: the dreams that stuff is made of.
This means that the GPL has passed the test.
In general, if lawyers for both sides are any good, a case should never make it to court. On the other hand, Vidomi was hardly an enemy of GPL the way Microsoft is.
FREE DMITRI!
I think the important thing to take away from all this is that Professor Moglen writes his legal documents in LaTeX.
The evaluation of an action as 'practical' . . . depends on what it is that one wishes to practice.
This is almost exactly how BeOS was able to use GPL'd drivers in their OS. By redirecting though an internal network/RPC interface.
This is funny?WTF?
WhiteWolf666 an exBush supporter. All you new-school,compassionate,save the children Republicans can rot in hell
I find it quite interesting how MySQL AB interprets the GPL. As you might know mysql was put under the GPL recently. Before this, you could download the mysql code from www.mysql.com, and use it freely for private, and some sorts of commercial use.
If you had mysql running on a server at _your_ company, and just sold the service you provided using mysql (e.g. some online mail-reader storing its mail in the db) you could use mysql for free
But if you _sold_ a product (NOT the service!), and your product needed mysql to run, you needed to obtain a mysql license. I though this restrictions of commercial use would be gone by putting mysql under the GPL, but MySQL AB seems to believe that connecting to a DB via TCP/IP is the same as linking, as long as your application can connect _only_ to mysql (via the mysql client library). If you use ODBC or some other (are there others?) general purpose DB abstraction layers, it's not "linking" I guess. Seems to quite the opposite of what Vidomi believes
Better to have to have the cancer of releasing half your source code than the quick finish of ending up in jail/bankrupt (the inevitable end of anyone using propietary code against license in their software).
:-)
What's your poison?
If you could be told what you can see or read, then it follows that you could be told what to say or think - BoC
b) You would have a tough time proving that it is actually stolen code. (Companies releasing closed source code? I don't think so.)
That's what discovery procedures in litigation are for.
--------------------
WWW.TETSUJIN.ORG
- - - -
The real Tetsujin 28 is a giant robot.
Lemme get this straight:
Company takes GPL'ed code and puts it into their product and sells said product.
People notice their use of GPL'ed code and alert the FSF.
Company then (for its next release) makes it into 2 products instead of releasing the source code of the product that is already out.
Whats to stop any other company from making a "Woops! We didnt know that... here, next release we will split it into 2 different programs, k?"
Vidomi has splited their program into two programs
This news makes me so happy, I shited my pants. The original GPL violation made me so agry I spited.
Stupid like a fox!
Looks an awful lot to me like PHP-Nuke. (Free/free)
Isn't this akin to someone having a GNU license, then changing the license and hoping to get away with restricting access to the older versions with the previous license. By including GPL code in their product, haven't they by implication made any version up to this point a GPLed product? Well, I want a copy. (Not really, I just want an answer. :))
GPL is designed to prohibit the use of GPLed software in close-source non-free (in GPL's sense of the world 'free') programs, IMHO. If you can get away with doing that via some IPC/RPC tricks, it is a loophole and probably needs to be taken care of to remain consistent with that policy.
Ok. So they wanted to link with some GPLed code, but of course that was prohibited by the license. So what they did now was create another stub open-source program which links with the GPLed code and then used IPC shared memory mechanisms to pass the information to the actual close-source program that does everything. Am I reading this right?
So then if what they did is legal than the same can be done with any other GPL application. Simply write an open-source stub that would link with the GPLed code and then use IPC/RPC/etc to communicate with the main program that you don't want to open-source. It will certainly be much slower than direct linking, but if speed is not an issue then it will work just fine. It seems to me that if GPL does indeed allow this than it is a definite loophole that perhaps needs to be fixed in a new version of the license.
I kinda like option c. Here's the chain as I see it:
With the example of this test case, companies use GPL code in seperate, linkable packages.
Mods are made to the linkable GPL code, and the changes make their way back into Linux community. Mods in the Linux community can be made in the "commercial" GPL, and another company sees the indirect benefit of open-source code
If a package gets popular, common modifications to make it more linkable, and it becomes a natural platform for future mods.
Commercial software becomes pretty interfaces on top of GPL code. Hackers take their time, making their own ugly, free interfaces.
No programmer ever has do re-invent the wheel again.
OK - it may be a leap to the last two, but the more people that get paid to work on open-source code, the better. Personally, I think businesses will love linked GPL code, as soon as they see legal barriers like the one in this lawsuit lifted.
The difference should be the expiration time. Software is good for only a few years before it loses most of its marketable value. I think the IRS says the depreciation time is 3 years for computers and software. So, just to be generous, why not make it good for 5-10 years? Regular patents are good for 20 years and copyright is good for 120(?) years. Developement of software is obviously much faster. If a shorter timer were allotted, it would ACTUALLY drive INNOVATION forward, in the real sense of the word. Companies would have to keep _really_ inovating to stay in business. Since software is so easy to reproduce, they should only be able to have a reasonable amount of time to recoup their R&D costs + some proffit.
science is a religion
Well, the basic goal of the GPL is so people can reuse code without having to reinvent the wheel.
It may rot everyone's socks, but in the very least it is preventing duplication of effort. Remember, information is something no one can own.
Paul Anderson
"I drank WHAT?!" -- Socrates
If not, I don't really see what benefit the GPL provides - companies are essentially free to take from the open source community without giving back anything other than a tiny RPC or IPC wrapper.
Aaargh! You can't do that! The GPL is a license, so the protection it offers comes from precisely what it says. "It would a shame if RPC were allowed" doesn't mean that the GPL magically and implicitly disallows it.
Although you don't think it would fly, surely the point is that they're making use of the functionality of the GPL code, and thus should be subject to all the requirements that the GPL entails.
If not, I don't really see what benefit the GPL provides - companies are essentially free to take from the open source community without giving back anything other than a tiny RPC or IPC wrapper.
(Of course this would bring up more difficulties and interesting questions - to what exent does a web browser "make use of the functionality" of Apache?).
As for the latency point, I think it's a non-issue - at least in this case. Video encoding (heck, even audio encoding) are CPU intensive things - the amount of time to transmit the data across a localhost TCP connection (or even use shared memory) is negligible in comparison to the time spent in the encoding routines.
Cheers,
Strags
Much of the debate between Vidomi and proponents of the GPL has been prolonged by Vidomi's incessant questioning of what exactly consitutes linkage. They have maintained from the very beginning that they don't think they're doing anything wrong, since the GPL code is in a separate DLL.
Of course, as many have pointed out, this is a fallacy - a DLL is, after all, another form of library - even if the code is not statically linked, it's linked nonetheless. The LGPL is designed as a less restrictive form of the GPL specifically for this purpose - enabling the distribution of a library without the "release your source" requirements of the GPL. Since Avery did not use the LGPL, we can assume that he intended the full requirements of the GPL to apply. In this case, fortunately, Vidomi has conceded.
Unfortunately, I can see future confusion arising the same question - what constitutes linkage? It's fairly trivial, for example, to write a small standalone application that links directly with a GPL library/DLL, and listens on a local TCP port. On receiving encoded commands from the TCP, it translates these to function calls into the GPL code, and returns the results back over the TCP connection - RPC style. Can the offending company, having written a trivial RPC layer, then release the source code for the server program, while keeping the client code closed-source?
Although the client is making extensive use of GPL code, it's not linked with it... it's in a completely different process. In fact, it could be on a completely different machine.
This strikes me as a relatively easy way for companies to get around the requirements of the GPL. Anyone have any thoughts on this?
Strags
...that someone would make this argument at some point. I understand it, and in some ways, I'd like to see the GPL [as well as other free/open licenses] tested in a court of law, mainly for the attention that would bring to the licenses.
But, however, the fact that Vidomi realized they screwed up and weren't going to get away with it and fixed the violation says to me, "We knew we would lose." The GPL hasn't been invalidated, and no lawyers are signficantly richer to prove that fact. Shouldn't we be happy for that? =)
-- Geof F. Morris
I'm not sure how copyright law actually works, though, so this is just speculation. I seem to remember that patents are only supposed to be granted for works that are not obvious to an expert in the field (not like this matters in practice).
IANAL, But from what I recall in class, how "obvious" something is has no bearing on it's copyright. This post, for example, is a fairly simple thing that I'm writing, and it's clearly derivitive of your post--but I still have copyright on it.
Not that this copyright gets me anything, but if some AC were to come along and post something that was awfully similar, but that could be proven to not be derivitive, I'm out of luck.
I never got the argument that code = speech. Sure, action = speech, and COMMENTS certainly = speech, and art = speech, and some code can = art, but...
I never got the argument that code = speech. I mean, it seems like an action that *can* be speech (like, say, burning the flag) but isn't *always* speech (like, oh, burning something at random.)
In all honestly, the 'net might be a better place if code wasn't "speech" at all. Think about it--if it's seen as functional, rather than art / speech, then there's a lot less of a tendancy to pamper rabid vanity (no! It's *my* code--you can't touch it!)
Aside from the freedom to break the law, I don't even get what the BENEFIT of being speech is. Buggy code, Script Kiddies, Prima Dona programmers, and elitist nerdy shmucks... and on the other side, a good number of people working to make computers do what they should do, and work.
IANAL etc.
But any owner of a GPL'd program can sue to enforce the GPL on that program. It's simply inaccurate to say that only the FSF can sue to enforce the GPL for VirtualDub. The FSF, not being the owner of the VirtualDub code, has no standing to sue. Only the author has the necessary standing--and is fully entitled to use it, with or without advice from Eben Moglen.
Please read the letter!
---
MOD THE CHILD UP!
Your take on copyright law is interesting, and something I hadn't thought about before. And this almost flies in the face of a lot of legal issues facing our community these days (eg: 2600 magazine, and their claim that the DeCSS code is "speech" and should be protected as such).
If the DeCSS code ends up being defined as free speech, or atleast protected speech (genie out of bottle, cannot place back in), and if copyright works as I believe it does (one person can write a story one way, but if someone else tries to write the same story, it's not legal), then perhaps defining code as speech isn't such a great idea afterall.
I think in an ideal legal world, the text making up code (eg: the C, C++, assembler, etc.) would be protected as speech, but the ability to stop someone else from writing the same code someone else already has written would work as patents do (if it's obvious, or in the case of USB, documented, then you can't make claims against it).
IANAL, and like you, would like some input from someone who's experienced in the subject, but it IS interesting, I think.
All I know about Bush is I had a good job when Clinton was president.
Plus this gets us into the nasty scenario of there being only one way to perform a task (or onr OPTIMAL way), and then having the code for that task (or the optimal method for said task) being GPL'd.
Example: USB code in the kernel for Linux. Someone at some embedded development company needs to make their device USB compatible, so they write their own code to work with USB-- they've never used Linux, they've never seen the source for the kernel, but the compiled binary (let's say they both run on an x86 architecture) are almost exactly the same.
Would we immediatly assume the worst as a community, ignoring the possibility that the company and/or developers wrote their own code to handle USB? Or would we assume the worst because some developer, not even on the same team as the embedded developers, ran Linux at home and was on the kernel mailing list?
I guess I'm afraid that at some point we'll start witch-hunts for people who use GPL code and demand they open the entire project. I do want the GPL enforced, but certain things are so common that they're bound to be copied (by copied, I mean duplicated through the same efforts and work as the other party) over time.
All I know about Bush is I had a good job when Clinton was president.
We learnt at school that "who" is for people, "which" is for objects and "that" can be used for both.
Maybe it's different in American English.
Wouldn't whom be more appropriate here instead of who?
Here's another (real-life) scenario:
Some time ago, I released a "Glide wrapper" under the LGPL. Glide is a proprietary 3D API created by 3dfx--my wrapper exposed the same entry points, but converted them to equivalent Direct3D calls.
Now presumably, I could have released my wrapper under the standard GPL. However, there are all these games still around that can link with my library. Obviously, it's absurd to think they need to rerelease under the GPL, just because they have the potential to link with my "implementation" of Glide, but from how I read the GPL, that's what needs to happen. So, either the GPL is broken, or it's illegal for me to license my wrapper with the GPL. The latter seems more likely, but where does that leave other library developers?
If the GPL *is* broken in this fashion, it brings up another possibility for Vidomi: to release *two* DLLs, each exposing the same pseudo-standardized interface (which would include entry points for resizing, cropping, etc.). One DLL would be developed in-house, and would just implement the functionality at the most basic (slow, buggy, but quickly developed) level. The other DLL would use the GPL code from VirtualDub and others, and would presumably do everything with much higher quality.
Now, it seems that you would be hard-pressed to fault Vidomi on this, since their package would be completely usable without the GPL code. However, most everyone would download the "enhanced" DLL, just because it would be so much better.
Of course, if it is indeed illegal to license with the GPL in this case, then the whole idea is moot.
-Scott
The problem, of course, is that no one who's technical enough to understand the closed source is allowed to look at it -- it's trade secret. One solution might be to arbitrate a demonstration, whereby a standalone computer (not connected to the internet or anything) is brought in with all the closed source code encrypted on the hard-drive. An armored vehicle and seventeen pitbulls (read: security guards) escort a skinny pale-hided hacker from Microsoft carrying a single disk with the key.
The computer, surrounded by lead, is booted off of the disk. A lead screen is placed over and under the keyboard, so that no EMF (like TEMPEST technology) can read the key clicks, and it is impenetrable to xray to determine the Microsoftian's finger motions. She or he reaches under the lead covers, types the passphrase, and the computer now has temporary access to the contents of the encrypted hard-drive.
A second floppy, which has been approved by the government as a fuzzy logic grep against key elements of XYZ source code, is run, while the first floppy, with the passphrased private key, is removed and placed under a huge magnet. (Now the only copy of the private key is in volatile ram). As the program is run, it displays and sends to a dot matrix printer lines of code which are suspiciously close algorithmically (i.e. changed variable names won't confuse it) to what's in the GPL it's comparing with, together with a likelihood that it's the same code. (100% likelihood would be many pages of text that match character to character).
This program could take exceptions into account, such as unmodified linking of LGPL'd files. (if I understand the lesser license correctly). At the end, the system is powered down (cleanly, so that random writes occur over what used to be the 'plaintext' private key), the encrypted hard-drive is removed, and the RAM chips are removed and zapped with a huge magnet to remove any residual traces of what was the private key.
The printout now can act as a basis for subpoena of specific lines of code from Microsoft, which a court-appointed council could look at, and would protect closed-source from unnecessary disclosure of its trade secrets. CRC or MD5 sums could also be printed out for the suspicious code, so that what Microsoft *actually* submits if subpoena'd is what the program originally looked at. The comparer program would be open-source and could be subjected to any Microsoftian or Other analysis beforehand to make sure that it acted as advertised.
Anyone see any problems with this arrangement? Certainly the design of the fuzzy comparer would be interesting...it might have to have a fuzzy state machine inside it to 'understand' what specific chunks of code
Come to think of it, a floppy probably isn't going to hold that...change it to a second hard-drive instead. Now does the plan sound like a plan?
~
the point is, the thing could become much more routine if nobody needed to trust a Special Master, which probably needs 'reasonable cause' or something. the thing could become routine this way.
~
Oh... a sad day.
I find this day to be much less sad than most people seem to find it. Was the Vidomi case a failure? Not really. Despite never having been tested in court, the GPL has (once again) stood its ground against a commercial company (albeit not too powerful/influential) and the commercial company in violation of the license has now released compliant software. Is that not the goal of the GPL--to keep open software open? It seems that whatever code which had been taken is now open, and that the modifications made to it have been released under the GPL. Is that not enough?
The "viral" quality of the GPL (a quality which I happen to love) cannot and should not be forced in every case. If a company wants to keep part of its software proprietary, it should have the right, as long as the software does not violate the terms of the GPL. If the author of the original software (in addition to the FSF) finds nothing wrong with the usage of his/her code, then the case against the company should be considered a victory.
--
What about if you are distributing some commercial software, which runs on Linux ? Could you distribute Linux and your software at the same time, while keeping your software free of the GPL and without violating the GPL ? Here again you could argue that your software is a distinct entity from the GPL'ed Linux, but someone else could turn around and say that it depends on Linux (as it runs on it), and as such Linux constitutes a part of the program. Maybe you could get around this by distributing Linux separately from your program, but if this latter view is valid, would it even work anyways ?
The result of this case sets the prescident that companies who wish to use GPL'd code can do so without releasing the bulk of the application in which the code is used, simply by partitioning their application and releasing under the FPL only the small partition of their app.
The Vidomi result seems fair (and was accepted by the FSF) but how small a piece of code can constitue an application for purposes of release under the GPL? Can I take GPL'd code and write a couple wrapper functions and release that piece of code and call it a plugin to my main application which would not be released under the GPL? Does the part of my code distributed under the GPL actually have to be useful or can it simply be a set of wrappers?
Conversely, if I can't release only a GPL'd plugin to my main closed source application, can I a s a developer use GPL'd code inside a plugin I write for a 3rd party commercial application such as Photoshop?
The Vidomi resolution raises a great many questions along these lines - certainly more issues than it resolves...
--CTH
--
--Got Lists? | Top 95 Star Wars Line
Vidomi isn't really that good anyway. It produced nice DivX compressed .avi files. Major problem though: The video got completely out of sync with the audio every time it changed VOB files.
Given that Microsoft has been spitting out FUD in large quantities about the viral quality of GPL and Open Source, this result actually proves them wrong, in the way that everyone always said it would:
All any developer need do, to use Open Source software, is invoke it as a separate program from the commercial program. All a company need do is keep all the stuff not part of its main line of business (the "crown jewels") in a commercial separate program and keep as GPL all the stuff that it doesn't need to control.
As an example, let's say the City of Seattle was reselling a computer program for electricity bill subrogation (a real example). They could have the really nifty stuff in a commercial program and leave most of it as GPL. The advantage is it's easier to resell - anyone who wants to can custom-code most of it, so long as it's not in the commercial section, which helps sell it, while letting the seller keep control of the proprietary code they sweated blood and research time to develop. Coders at the buyer are happy, cause they can fix bugs more often, and the seller is happy, cause more people buy their software.
End result is: GPL means more market!
--- Will in Seattle - What are you doing to fight the War?
Horrors. By not contesting the GPL, they're just putting us off our guard.
Tatsujin
In cases like this, it's pretty easy to find out a violation took place. But what about a major closed-source project that uses pieces of GPL-d code? What if an embedded OS developer decided to use some Linux kernel code, without attribution, in a proprietary system? Would it be possible to detect the violation (looking for patterns in the binary, for example)?
Hmm... and even if you find the strings in the binary which suggests that GPLed code was used illegally, there's a quick and easy way out of it. The company just has to use some chickenshit encryptuion on the binary. The person who finds the strings will have violated the DMCA in order to be able to bring up the issue of GPL vilation in the first place. Then the FBI can arrest that person, and throw him in jail without bail.
And we all now know that this isn't a paranoid delusion scenario.
-Rob
It can't be illegal to use the GPL. The question is whether the GPL would be enforceable in this case.
So even though we are destroying our rain forest, it's okay, because we're planting new tress?
If you were doing it responsibly, IE, leaving a mix of old and new growth standing and truly planting as much as you were cutting down, then yes, it would be okay.
Even though I was driving 25 mph over the limit, it's okay, because I slowed down before I got home?
If you realized you were driving 25 mph over the limit and decided to slow down rather than get a ticket, then yes, you've done the right thing. You may still get pulled over by an overzealous cop, but you can probably successfully argue the ticket in court.
The point here is that the company that makes Vidomi was forced to realize and admit that they were doing the wrong thing.
Sure they *were* doing the wrong thing, but they corrected their actions in a manner that brought them into compliance with Avery's and the FSF's interperetation of the GPL.
Remember that Avery and FSF could still have pushed the case into court if they wanted to. Obviously they thought that they were better served getting the other guys into compliance than spending big $$$ on court costs.
The next Slashdot story will be ready soon, but subscribers can beat the rush and slashdot the links early!
What makes the harvesting of the rainforest so horrible is not the fact that we're decimating trees, but the delicate ecosystems that rely on them. Worse, when those ecosystems are effectively eliminated by a day's worth of chainsaw work, they are *not* allowed to regrow. Land stripped of trees is used for farming, and becuase of the poor soil conditions caused by the canopy of trees it once supported, that land can support 2 or 3 seasons worth of crops before it's completely stripped of minerals and nutrients that the crops need to thrive.
Now, if the regions were picked selectively... say you harvested a fifteen-square mile area in a striped or checkerboard pattern, and then left the uncut trees to stand while replanting what you just cut down, you minimize a lot of the damage deforestation would cause. Unfortuneately, this is *not* happening.
The next Slashdot story will be ready soon, but subscribers can beat the rush and slashdot the links early!
Moreover, according to the letter in the link, the Free Software Foundation said precisely nothing. An attorney who has worked for the FSF issued an opinion letter that he was engaged by Vidomi to write. This is a completely different thing, and unless there is something else that I didn't read the blurb is extremely deceptive.
Here is a question that has been nagging me - how is it possible to safeguard against closed-source developers stealing GPL'd code?
In cases like this, it's pretty easy to find out a violation took place. But what about a major closed-source project that uses pieces of GPL-d code? What if an embedded OS developer decided to use some Linux kernel code, without attribution, in a proprietary system? Would it be possible to detect the violation (looking for patterns in the binary, for example)?
Would it be possible to compel the company to show its source to a court in the event of a lawsuit?
The GPL may be enforceable, but that is cold comfort unless it is possible to detect and combat the use of stolen code.
A customer service representative will be with me shortly.
I guess if open source companies [not Vidomi, FSF and all those guys] don't have a lot of cash they won't go to court.
At first I found this funny but now it seems that it makes mo' better sense. Do software companies want to visit the local court house? I doubt it.
Get your Unix fortune now!
On the other hand, if Vidoma really wants to be sure it's over, they should offer each of the authors something (say $1,000) as a settlement in full -- otherwise it would indeed be possible for one of them (if he's rich enough) to sue for those damages. The likely result of this is that each set of lawyers gets $500K, leaving the plaintiff -400K, Vidoma -600K, lawyers +1M, but there are people pigheaded enough to be happy with that!
Sounds a little harsh, but AFAIK the law lets them do it. (IANAL) If you want to complain about it, write your congressman. If he still reads anything that isn't accompanied by $$$$...
If all this should have a reason, we would be the last to know.
Let's sum it up:
a) It hasn't been tested in court.
b) You would have a tough time proving that it is actually stolen code. (Companies releasing closed source code? I don't think so.)
c) There are ways to get around it, ie to split the binaries and just show the links to libraries.
Oh... a sad day.
Screw 3...
Thats the general procedure.
To behave ethically you must always alert the wrongdoing part and then let them correct it anyway they want to.
Then if you have been harmed economically while the wrongdoing was taking place you can ask to be compensated for this. In this case the code was free so it's not the case here.
Take patents as an example. If someone is breaking your patent you must always let them fix that. You can't just sue the ass of them.
That is not morally defendable, maybe they did it by mistake or some other circumstances we don't know about.
Atlest this is the case in all western countries witch has similuar laws.
I've heard enough already about misspellings that weren't the fault of the editors. They just post the damn submissions people. If Andy Tai makes a spelling mistake but it's the best submission for this issue, kudos to Michael for printing it.
501 Not Implemented
does anybody still have a link to the original software? i remember that the conglomerates started sueing, so /. pulled them all. If its gonna be a legal liability/trouble for anyone, don't post it, but if this has been resolved, post away!
its been sed sevral times... sevral times two offten.
I guess that Vidomi has cancer for sure now, maybe GPL is not as black and white as some say...
*narf!*
One of the biggest dissapointments I have in the US judicial system, is that it does not generally foster an attitude of compromise.
I think it is great that Vidomi and the FSF were able to work together to find a middle ground that fits the definition of the GPL
One of the best ways of complying with a license, is doing just that... finding ways to comply. Perhaps not a viscerally satisfying ending, but certainly one that is in the spirit of the open source community. If only all the GPL issues could be resolved with as little intervention of the legal establishment.
In a similar vien, make sure you write to the people at linuxda.com, and make them politely aware that what they are currently doing does not conform to the behavior expected by the open source community.
"Don't worry about the problems you have in mathematics, I assure you mine are much greater." - Einstein c.1919