Except, every time Microsoft slips a schedule they're lambasted by Open Source developers and the press for not meeting their promises, and accused of being terrible programmers because of it.
What i'm disagreeing with is your claim that it *ONLY* has to be proven that code in an older product is in a new product, and I'm pointing out that that is simply not enough. You have to prove that the code in the older product was unique.
You really don't understand much about the Windows footprint, do you?
Take a closer look. You'll notice that most of that space is taken up by virtual memory swap file, hibernate file (that's typically 4-8GB alone), and the SxS folder, which stores backups of various system files (but they're hard linked, which makes them appear to use more space than they actually do.)
The problem is significantly more complex than you seem to have considered.
Consider this. Nobody has access to all GPL'd code that's out there. The GPL does not require that you make source code available to everyone. It only requires that you make source code available to those you give the binary to.
Think about this. There is likely a lot of GPL'd code out there that isn't easily findable on the web. How exactly is one supposed to prove tha any given piece of code was not copied from GPL'd code? It's simply not possible..
Being aware of the GPL does not mean you are aware that any given piece of software is licensed under it, much less a few snippets of code from said application.
There are three possible scenarios I can think of off the top of my head that are all highly likely here, none of which would make Microsoft aware of the fact they were violating the GPL (if that is even the case, which isn't even proven yet).
1) Microsoft hired a contractor or 3rd party to produce the code. The 3rd party used GPL code, but did not tell them. Yes, Microsoft is still liable, but they're not willfully liable.
2) Microsoft produced the tool for internal use. This is a valid use of the GPL'd code and doesn't require source to be distributed with it. Some other department, unaware that GPL'd code was used, got ahold of the tool and decided to use it externally. The original developers are unaware of the new use. Again, Microsoft is not willfully infringing.
3) An employee decides to take a shortcut and use GPL'd code without telling his bosses, takes credit for the code, and thinks nobody will ever find out. Microsoft is unwillful because even thought the employee wilfully infringed, the company had no knowledge. Yes, they're still liable, just not willfully so.
There are probably many other possible scenarios too... but I can't be bothered to spend more than a couple minutes thinking about it.
So perhaps you should think your arguments through before jumping to the conclusion of "it must be willful".
No. The supreme court is very clear. Copyright infringement is the "invasion of a statutory defined privince", which makes it closer to trespassing than theft.
Would you call a trespasser a theif? No, you wouldn't.
You said, all that was necessary was to prove that code in a newer product was the same as code in the older product.
That is not the case, because that is exactly what SCO was trying to do. They were trying to prove that code in their product was the same as code in a newer Linux product, despite the fact that the code existed in even older Linux products.
SCO did produce code. That's my point. But the code in question was proven to be even older.
Thus my point is, merely proving that Microsoft has code that is in older GPL code doesn't mean Microsoft is guilty, because the older GPL code may have come from a source that wasn't encumbered by the GPL.
My point was that it's hypocritical of GPL advocates to say Microsoft is guilty without doing due dilligence on the source of that code when they were on the opposite side of the coin in the SCO case.
Most people, other than those that simply refuse to, acknowledge that if something *can* happen, it probably will. Yes, proving it is another issue, but we all know bittoreent *can* be used to commit copyright infringement, but only a fool would argue that it never happens because it's not proven that it does.
I am aware of at least 20 different incidents were GPL code was used and passed off by a programmer as his own work. This was mostly code written for internal purposes, so it doesn't matter from a GPL enforcement perspective, but it does happen.
Actually, You need to come to terms with the fact that copyright infringement is not theft. The supreme court has ruled that it is not theft.
in Dowling v United States, the supreme court made this ruling:
interference with copyright does not easily equate with theft, conversion, or fraud. The Copyright Act even employs a separate term of art to define one who misappropriates a copyright:... 'an infringer of the copyright.'... The infringer invades a statutorily defined province guaranteed to the copyright holder alone. But he does not assume physical control over the copyright; nor does he wholly deprive its owner of its use. While one may colloquially link infringement with some general notion of wrongful appropriation, infringement plainly implicates a more complex set of property interests than does run-of-the-mill theft, conversion, or fraud.
—Dowling v. United States, 473 U.S. 207, pp. 217–218
If that were the case, the SCO would have won their lawsuit, since they had code which appeared to come before code in Linux, but further investigation revealed that this was code originally from other sources or was contributed by SCO themselves. As such, you're walking on awfully thin ground claiming that things don't have to be proven. The sword cuts both ways.
You really should read the GPL. If you stop infringing, your license is reinstated. Permanently if the copyright holder does not terminate your licese explicitly.
8. Termination....
However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.
Ok, so what about when Linux advocates criticize Microsoft every time there's a flaw in Windows, but strangely consider every flaw in Linux to be evidence that many eyes works well?
You're contradicting yourself. Out of one side of your mouth you claim that the protocol has been changed and enhanced over the years by use of extensions, then you say the protocol is stable and hasn't changed, thus compatibility is ensured.
You can't have it both ways.
There is no ABI for X11, unless you want to count xlib. It's a protocol. Apps (usually via various toolkits) talk to X11 through the protocol, not through an ABI in the OS.
The point, which you seem to be ignoring and spinning around, is that apps on Windows and OSX talk to an ABI supplied by the OS. The ABI is typically a link library of some kind (GDI.dll for instance) and GDI.DLL can change the way it talks to the actual display whenever it wants without the App being aware of it or needing to change.
Yes, new features have been added over the years that have new interfaces, but existing apps can benefit from a protocol enhancement in a new OS without changing the apps.
X11 has to maintain that protocol compatibility, and thus cannot change it's protocol on a whim, though it can add new features, which the apps are required to be written to know about.
Stop squirming and admit that legacy apps have to continue to use the legacy protocol unless rewritten. This protocol cannot be changed without the apps (or the toolkits) being aware ofit.
I think you're being disingenous. Extensions have to be supported by both the client and the server.
Let's say i'm running an app written 5 years ago. My app knows how to talk to the X server using whatever was standard 10 years ago. If your new X server, via extensions, has changed the way the protocol works, the apps don't magically adjust. They still require the old protocol.
Now, true, if it's written to some intermedite X library that has changed to support the new features then that will work, but honestly the odds of that are at best 50/50 given how many different X toolkits there have been and how few of them are still actively maintained and kept mondern.
In the MacOS/Windows model, Apps talk to Quartz/GDI, so when those change to support a new model, the apps magically get those changes.
What's more, since this is a binary model, that means that the apps get the benefits without recompilation and/or upgrading to newer libraries (which may or may not be transparent.. and could require coding changes).
FYI... "get a user on the local machine" is far more trivial than you might think. For example, exploiting a flaw that allows arbitrary code execution of the current user in any internet connected application such as FireFox (and there have been a bunch of recent flaws in FF of that variety) will work just fine. This is called a blended attack and makes use of several flaws to achieve its goals.
I'm aware of that, and even mentioned it in my message, which you apparently did not actually read.
You're still stuck with X11's basic protocol though, and the extensions only help with features that are entirely new. It doesn't allow the protocol for existing functions to be changed to be more efficient.
In any event, Extensions defeat the purpose of having a "standardized protocol" since it means any two X11 implementations may not be able to talk to each other properly.
And what happens when you're in an accident in the middle of nowhere, trapped in your car, but can't make a phone call to 911 because the car blocks your signal?
The only difference between how X11 implements this and how Quartz or the Vista display server implement it is that the protocol used via the serial channel that X11 uses is well documented.
That's a very broad statement to make. While it's true that all three systems use some form of IPC, you are completely glossing over the efficiency of the protocol for various purposes. OSX and Windows can basically change their protocol whenever they want to improve efficiency on new hardware. X11 doesn't really have that luxury and is largely confined to a protocol developed for ancient displays (which works pretty well in most situations). But let's face it, having the ability to change your protocol when you see fit gives you a huge advantage. Even being able to design your protocol with modern knowledge is a huge advantage.
Yes, X11 works quite well for being a 30 year old system, and there have been lots of extensions grafted on to help modernize it. But it's still a bit like a frankensteins monster where the Doctor says "Yeah, those scars are an advantage, what are you talking about?"
Slashdot Mirror
Where is SVG in any HTML standard?
You do realize that ActiveX is an industry standard, supported by the Open Group (you now, the same people that standardized X Windows).
http://www.opengroup.org/pubs/catalog/ax01.htm
Except, every time Microsoft slips a schedule they're lambasted by Open Source developers and the press for not meeting their promises, and accused of being terrible programmers because of it.
It's damned either way.
i'm not disagreeing about any of that.
What i'm disagreeing with is your claim that it *ONLY* has to be proven that code in an older product is in a new product, and I'm pointing out that that is simply not enough. You have to prove that the code in the older product was unique.
You really don't understand much about the Windows footprint, do you?
Take a closer look. You'll notice that most of that space is taken up by virtual memory swap file, hibernate file (that's typically 4-8GB alone), and the SxS folder, which stores backups of various system files (but they're hard linked, which makes them appear to use more space than they actually do.)
And you wonder why Microsoft considers the GPL a "viral" license....
Your googlefu is not strong, my son.
Here's a few examples of SCO providing code:
http://perens.com/SCO/SCOSlideShow.html
http://www.lemis.com/grog/SCO/code-comparison.html
The problem is significantly more complex than you seem to have considered.
Consider this. Nobody has access to all GPL'd code that's out there. The GPL does not require that you make source code available to everyone. It only requires that you make source code available to those you give the binary to.
Think about this. There is likely a lot of GPL'd code out there that isn't easily findable on the web. How exactly is one supposed to prove tha any given piece of code was not copied from GPL'd code? It's simply not possible..
No, the "smart, rational thing to do" would be to validate your code and status of it in whole before you post it for the world to take..
Ok.... so tell me how you would do that. Anyone? Beuler?
How can anyone, say you, determine that any given snippet of code is not Licensed under the GPL somewhere.
Uhh.. Your logic is at best... strange.
Being aware of the GPL does not mean you are aware that any given piece of software is licensed under it, much less a few snippets of code from said application.
There are three possible scenarios I can think of off the top of my head that are all highly likely here, none of which would make Microsoft aware of the fact they were violating the GPL (if that is even the case, which isn't even proven yet).
1) Microsoft hired a contractor or 3rd party to produce the code. The 3rd party used GPL code, but did not tell them. Yes, Microsoft is still liable, but they're not willfully liable.
2) Microsoft produced the tool for internal use. This is a valid use of the GPL'd code and doesn't require source to be distributed with it. Some other department, unaware that GPL'd code was used, got ahold of the tool and decided to use it externally. The original developers are unaware of the new use. Again, Microsoft is not willfully infringing.
3) An employee decides to take a shortcut and use GPL'd code without telling his bosses, takes credit for the code, and thinks nobody will ever find out. Microsoft is unwillful because even thought the employee wilfully infringed, the company had no knowledge. Yes, they're still liable, just not willfully so.
There are probably many other possible scenarios too... but I can't be bothered to spend more than a couple minutes thinking about it.
So perhaps you should think your arguments through before jumping to the conclusion of "it must be willful".
No. The supreme court is very clear. Copyright infringement is the "invasion of a statutory defined privince", which makes it closer to trespassing than theft.
Would you call a trespasser a theif? No, you wouldn't.
Perhaps you need to re-read what you wrote.
You said, all that was necessary was to prove that code in a newer product was the same as code in the older product.
That is not the case, because that is exactly what SCO was trying to do. They were trying to prove that code in their product was the same as code in a newer Linux product, despite the fact that the code existed in even older Linux products.
SCO did produce code. That's my point. But the code in question was proven to be even older.
Thus my point is, merely proving that Microsoft has code that is in older GPL code doesn't mean Microsoft is guilty, because the older GPL code may have come from a source that wasn't encumbered by the GPL.
My point was that it's hypocritical of GPL advocates to say Microsoft is guilty without doing due dilligence on the source of that code when they were on the opposite side of the coin in the SCO case.
Most people, other than those that simply refuse to, acknowledge that if something *can* happen, it probably will. Yes, proving it is another issue, but we all know bittoreent *can* be used to commit copyright infringement, but only a fool would argue that it never happens because it's not proven that it does.
I am aware of at least 20 different incidents were GPL code was used and passed off by a programmer as his own work. This was mostly code written for internal purposes, so it doesn't matter from a GPL enforcement perspective, but it does happen.
Actually, You need to come to terms with the fact that copyright infringement is not theft. The supreme court has ruled that it is not theft.
in Dowling v United States, the supreme court made this ruling:
If that were the case, the SCO would have won their lawsuit, since they had code which appeared to come before code in Linux, but further investigation revealed that this was code originally from other sources or was contributed by SCO themselves. As such, you're walking on awfully thin ground claiming that things don't have to be proven. The sword cuts both ways.
Nevermind... i was quoting the GPLv3.. i misread your comment.
You really should read the GPL. If you stop infringing, your license is reinstated. Permanently if the copyright holder does not terminate your licese explicitly.
8. Termination. ...
Ok, so what about when Linux advocates criticize Microsoft every time there's a flaw in Windows, but strangely consider every flaw in Linux to be evidence that many eyes works well?
I'm sorry, what does "feedback"ing have to do with the GPL?
THe GPL does not require that you submit enhancements to anyone. The MPL requires that, not the GPL.
You're contradicting yourself. Out of one side of your mouth you claim that the protocol has been changed and enhanced over the years by use of extensions, then you say the protocol is stable and hasn't changed, thus compatibility is ensured.
You can't have it both ways.
There is no ABI for X11, unless you want to count xlib. It's a protocol. Apps (usually via various toolkits) talk to X11 through the protocol, not through an ABI in the OS.
The point, which you seem to be ignoring and spinning around, is that apps on Windows and OSX talk to an ABI supplied by the OS. The ABI is typically a link library of some kind (GDI.dll for instance) and GDI.DLL can change the way it talks to the actual display whenever it wants without the App being aware of it or needing to change.
Yes, new features have been added over the years that have new interfaces, but existing apps can benefit from a protocol enhancement in a new OS without changing the apps.
X11 has to maintain that protocol compatibility, and thus cannot change it's protocol on a whim, though it can add new features, which the apps are required to be written to know about.
Stop squirming and admit that legacy apps have to continue to use the legacy protocol unless rewritten. This protocol cannot be changed without the apps (or the toolkits) being aware ofit.
I think you're being disingenous. Extensions have to be supported by both the client and the server.
Let's say i'm running an app written 5 years ago. My app knows how to talk to the X server using whatever was standard 10 years ago. If your new X server, via extensions, has changed the way the protocol works, the apps don't magically adjust. They still require the old protocol.
Now, true, if it's written to some intermedite X library that has changed to support the new features then that will work, but honestly the odds of that are at best 50/50 given how many different X toolkits there have been and how few of them are still actively maintained and kept mondern.
In the MacOS/Windows model, Apps talk to Quartz/GDI, so when those change to support a new model, the apps magically get those changes.
What's more, since this is a binary model, that means that the apps get the benefits without recompilation and/or upgrading to newer libraries (which may or may not be transparent.. and could require coding changes).
FYI... "get a user on the local machine" is far more trivial than you might think. For example, exploiting a flaw that allows arbitrary code execution of the current user in any internet connected application such as FireFox (and there have been a bunch of recent flaws in FF of that variety) will work just fine. This is called a blended attack and makes use of several flaws to achieve its goals.
I'm aware of that, and even mentioned it in my message, which you apparently did not actually read.
You're still stuck with X11's basic protocol though, and the extensions only help with features that are entirely new. It doesn't allow the protocol for existing functions to be changed to be more efficient.
In any event, Extensions defeat the purpose of having a "standardized protocol" since it means any two X11 implementations may not be able to talk to each other properly.
And what happens when you're in an accident in the middle of nowhere, trapped in your car, but can't make a phone call to 911 because the car blocks your signal?
The only difference between how X11 implements this and how Quartz or the Vista display server implement it is that the protocol used via the serial channel that X11 uses is well documented.
That's a very broad statement to make. While it's true that all three systems use some form of IPC, you are completely glossing over the efficiency of the protocol for various purposes. OSX and Windows can basically change their protocol whenever they want to improve efficiency on new hardware. X11 doesn't really have that luxury and is largely confined to a protocol developed for ancient displays (which works pretty well in most situations). But let's face it, having the ability to change your protocol when you see fit gives you a huge advantage. Even being able to design your protocol with modern knowledge is a huge advantage.
Yes, X11 works quite well for being a 30 year old system, and there have been lots of extensions grafted on to help modernize it. But it's still a bit like a frankensteins monster where the Doctor says "Yeah, those scars are an advantage, what are you talking about?"