11.22.08
Microsoft Willing to Sell Us ‘Protection’ for Use of Mono
Deal or no deal? Shall we collect donations? Or just strip Mono off?
As regular readers may know, we have been actively pursuing answers from Microsoft regarding Mono. Well, we are finally successful. With concerns about patent ambush in Mono, an answer was needed.
Our suspicions seem partially confirmed with the following reply that suggests patent licensing and mentions “Mono” by name.
From: “Mike Ward (LCA)” <Mike.Ward at microsoft.com>
To: [Anon]
Cc: “Nick Tsilas (LCA)” <ntsilas at microsoft.com>
Subject: Request for a written license for ECMA 334 implementation
[Anon],
I am responding to the e-mail string below on behalf of the
intellectual property & licensing team at Microsoft. I help companies
obtain licenses to use Microsoft’s patents and other IP. If a
license to cover Mono or other technologies is necessary, I can work
with you and/or Roy to develop a mutually beneficial agreement.
Please give me a call on 425-703-6405 to discuss your needs and to
identify next steps.
Michael W. Ward
Senior Director
Intellectual Property & Licensing
Microsoft Corporation
One Microsoft Way
8 / 1096
Redmond, WA 98052-6399
425-703-6405 Office
425-681-6946 Mobile
425-708-4293 Fax
—–Original Message—–
From: [Anon]
Sent: Monday, November 10, 2008 10:25 AM
To: Nick Tsilas (LCA)
Subject: Request for a written license for ECMA 334 implementation
From: Roy Schestowitz
To: ntsilas at microsoft.com
Date: Wed, Nov 7, 2008
Subject: Request for a written license for ECMA 334 implementation
Dear Nicos Tsilas,
I tried contacting iplg@microsoft.com a couple of times over the
past month, but was unable to receive a reply. I am therefore
expressing my determination to receive a licence for commercial
distribution of Mono, in accordance with your terms presented by Bob
Muglia:
http://www.eweek.com/article2/0,1895,2060750,00.asp
“There is a substantive effort in open source to bring such an
implementation of .Net to market, known as Mono and being driven by
Novell, and one of the attributes of the agreement we made with Novell
is that the intellectual property associated with that is available to
Novell customers.”
According to several legal analyses, Mono is not safe for those who are
not Novell customers to use. I would therefore like to purchase a licence.
Best regards,
Roy Schestowitz
Any other interpretations? █
“Tsilas [senior director of interoperability and IP policy at Microsoft] is admitting, more explicitly than implicitly, that Microsoft’s profit depends on it controlling standards and that OOXML is a product designed to do exactly that. The mask has slipped and the nature of this particular war is on display. As Ericson, captain of HMS Compass Rose, might say: we are sorry if it is too hard for you, Microsoft.”
Content is available under CC-BY-SA
RyanT said,
November 22, 2008 at 4:52 pm
“If a license to cover Mono or other technologies is necessary”
Key words here: If necessary.
I doubt he barely knows what you’re on about, and I doubt it is genuinely necessary, if you were to call him up and talk about about it more in-depth.
Dan O'Brian said,
November 22, 2008 at 7:58 pm
Wow, way to twist his words, Roy.
He didn’t say you needed patent protection for Mono at all. In fact, the way it’s worded, it sounds more like patent protection isn’t needed at all and he’s confused why you are even asking for it.
Roy Schestowitz said,
November 22, 2008 at 8:10 pm
That’s the way you choose to read it. I read it differently. Since you love to defend Microsoft/Novell, this may not be surprising.
Dan O'Brian said,
November 22, 2008 at 9:53 pm
Let’s take a look at how you are playing this:
You send a letter:
They send a response:
Nowhere does he say that you need a license.
You say I’m choosing to interpret it the way I do, and I say you are reading words that aren’t there.
How many years of experience do you have working with lawyers negotiating these sorts of contracts? 0? Let’s also note that you are DESPERATE to convince people that a license is really needed to use Mono, so you’ll twist words and phrase things as carefully as you can in order increase your chances of success in obtaining a license for Mono through Microsoft no matter whether you really need it or not.
Your ploy is similar to someone going to a car body shop with a brand new car with nothing wrong with it and telling the mechanic “I’m pretty sure I need something fixed, please find a way for me to pay you for nothing.”
If you push hard enough, the mechanic might give in and tweak something and charge you for it, whether you needed it or not.
Ziggyfish said,
November 22, 2008 at 11:31 pm
But if he had of asked if he needed a patient protection, they probably would of lied and said no. It’s like walking up to a murder suspect and asking him if he kill her.
Josh Bell said,
November 22, 2008 at 11:59 pm
Roy you can’t be serious. This doesn’t confirm anything. You asked for a license and Microsoft came back and said if you need one we can work with you and lists his number. Key word IF. The letter sounds like the Microsoft guy is absolutely confused.
If you go to Mono-project.com/license and read it, everything is covered by an OSI approved license. They use either LGPL or GPL 2.0 or MIT X11 for everything. The only time you would need the propietary license is if you can’t fullfill the terms of the GNU LGPL. So how or why would you need a license if everything is free and open source. It really doesn’t matter what Microsoft says.
AlexH said,
November 23, 2008 at 3:39 am
Guys, this was Roy’s game from the very start. He knows Microsoft won’t claim Mono needs a license, but he also knows they’re probably willing to sell him generic IP rights.
It’s a neat trick, but so is pulling a rabbit from a hat.
Roy Schestowitz said,
November 23, 2008 at 4:14 am
No, Alex. The question was, by claiming that Novell bought exclusive protection, can others too?
Dan O'Brian said,
November 23, 2008 at 8:59 am
Ziggyfish: Wow, your logic is stunning. Stunningly WRONG.
AlexH said,
November 23, 2008 at 11:44 am
@Roy: that’s not the question, and you know it.
Here’s the test: talk to your contact, get them to offer you a patent license for two pieces of software. First, ask them for one for Mono. Second, ask them for one for Samba.
I’m willing to bet you would never do that because the charade would be up.
Jose_X said,
November 23, 2008 at 11:44 am
Microsoft has stated they will deal with those serious about licensing. *Only* to those that are serious will they reveal the patents and other details. If you don’t have it, I can look for a link to a recent interview that revealed no less than this much in very explicit terms.
Roy, before closing the book on this, you may want to consider asking something similar from Linux vendors or other vendors. It’s easier to contrast responses this way. See what Red Hat offers the community, and see what Microsoft offers. Actually, we already know what Red Hat offers and what Microsoft offers, and the differences are plenty.
Just like with the benefits Microsoft gains from piracy, they gain similar and greater benefits from the spread of dotnet clones people will use for no charge.
Novell and everyone that advocates use of dotnet or clones are helping to spread Microsoft’s technological “drugs”; however, in this respect, mono is worse than Windows and Office. The extra damage arising from mono and other clones vs. from user level Microsoft “drugs” is that the former are not end products to themselves but propagate as they are used by developers to create apps. Further, a stronger “addiction”/commitment/dependency results from a complex set of API vs. what most ordinary users have to deal with when they use end products. [Do note that most developers limit themselves to a rather small set of projects, languages, etc, because of the large overhead learning curve.] Spreading dotnet or clones is a serious win for Microsoft. The battle for developers is very important.
Without an open source dotnet clone, Microsoft’s proprietary offerings would be much less attractive to businesses. Most managers and even some developers have some faith that a “second source” is possible. In any case, risks for using MSdotnet are lowered if there is something similar enough in the market that is FOSS; thus, mono has increased the attraction from managers to MSdotnet.
Mono apps are easier for Microsoft and for anyone to port to Windows. These ports help Microsoft retain their lock-in and levers through the increased value that accrues to Windows. Additionally, it’s easier for Microsoft to gain control (“manage”) FOSS apps than closed apps.
Mono (and other Novell owned code.. assuming they own mono or have a license to sublicense) is even worse than would be a different dotnet clone owned by someone esle to the degree Novell is already working very closely and is financially dependent on Microsoft so as to be that much more likely to give special nonGPL licenses to Microsoft. Thus, the GPL only hampers/checks everyone *except* Microsoft — a very clear gain in advantage for Microsoft over everyone else.
Novell developers are not naive enough to think that interop is possible. ’nuff said.
Look at the basic facts, Novell is a mostly proprietary company, helping a very powerful monopolist hold and gain ground. They aren’t fooled by the interop spiel they push. Novell is more than willing to participate and agree with Microsoft’s deceptive maneuvers (like the patent scare with customers) to grab extra money from clients.
Novell wants to eliminate Red Hat competition with full battle guns, again, helping to give a very significant strategic gain to Microsoft. They also want to weaken the strategic advantages Sun gains from Java and OO.org, thereby making Microsoft’s path to holding and growing the lock-in that much more secure.
The list can go on and on. I have to expect a lot of the developers defending Novell, eg, those developers posting here, many of whom have read all of this before, are well aware of the details… yet they continue to defend Novell.
This link duplicates much of what I said here, but some may find it useful: http://boycottnovell.com/2008/10/11/mono-2-beyond-the-hype/#comment-27135
Are any of you developers: AlexH, Josh Bell, Dan O’Brian, Ryan T?
Roy Schestowitz said,
November 23, 2008 at 11:51 am
Sun is not happy with Novell, which is slamming OpenSolaris in public (yes, the CEO) and is also fighting Java, ODF, and Sun’s office suite.
Jose_X said,
November 23, 2008 at 11:57 am
Roy, people here and elsewhere recognize that Microsoft will go after anyone they can to make a buck. Tomorrow, all dotnet apps you use will pose greater risks to patent attacks from Microsoft because that is Microsoft’s specialty area. I don’t like to overplay the patent card because anyone can sue; however, there is clearly greater monetary risk if your apps in business use are dotnet-ish and you didn’t already pay Microsoft than if you did. Also, I think many types of analysis would reveal that the threats from Microsoft for dotnet are greater than from anyone else for any other common technology. Is anyone really denying this?
Roy, there is a lot that is good in BN, but those posters that are attached to BN in order to deceive readers over the threats posed by Novell latch on like bulldogs to whatever weakness you leave them. I know you keep going and don’t spend all your time arguing since there is always more to be shown… For people reading, you should look around BN. Many posters (like some posting ahead of me here) nitpick so that they can avoid the big questions which are about (a) helping Microsoft retain their holds over the markets, and about (b) the greater risks posed when you get close to Microsoft (eg, by using technology that favors them).
Jose_X said,
November 23, 2008 at 12:02 pm
If I were a manager and had hired the people posting here, and they did a comparable tech job as they are doing here arguing on Novell’s defense, I would fire them (if I were going to fire anyone).
There are either playing dishonestly or they have a serious problem seeing the forest from the trees. They are spending hours to trim a single branch while completely avoiding tackling the spreading weeds. They are arguing about the proper way to name a few variables while completely getting the architecture incorrect.
Roy Schestowitz said,
November 23, 2008 at 12:04 pm
From
http://www.computerworlduk.com/TOOLBOX/OPEN-SOURCE/BLOGS/index.cfm?blogid=14&entryid=664
“And then I realised what the problem was. The name “Microsoft” occurs just three times in the whole interview, which runs to many thousands of words. And none of those instances refers to the Microsoft-Novell deal that has proved so divisive in the open source world.
“Now, I fully understand why Zemlin moved gingerly around this topic: it’s deeply problematic for Hovsepian, and he is understandably unwilling to explore its deleterious effects on the free software community. Equally, Zemlin is naturally unwilling to put important open source figures like Hovsepian on the spot since this will make his job much harder in the future.
“This is where cynical journalists like me come in. We have no compunction in sticking the interrogatory knife in to interviewees and twisting when we find the pain point.
“That’s why, to be frank, interviews are best carried out by those who do not have business relationships with their victims/subjects.”
AlexH said,
November 23, 2008 at 12:05 pm
@Jose: it’s all very well to look at this as “nit picking”. When the nit is the fundamental point being made, though, it’s a problem.
Roy seems to think that Mono is a patent liability because Microsoft are willing to sell him a patent license. Do you not see a problem with that argument?
(Hint: in any experiment, you have a ‘control’. Where is the control in this one?)
Roy Schestowitz said,
November 23, 2008 at 12:06 pm
That’s a big issue, Alex.
AlexH said,
November 23, 2008 at 12:12 pm
No, Roy.
What would be a big issue would be “Mono is a patent liability”.
“Microsoft willing to sell Roy an IP license” is not a big issue, for the reasons I’ve outlined time and time again, yet surprisingly you refuse to engage with the argument. Perhaps because you understand the sleight of hand trick you’re trying to pull.
Roy Schestowitz said,
November 23, 2008 at 12:15 pm
Microsoft’s staretgy here is two-fold:
AlexH said,
November 23, 2008 at 12:17 pm
Don’t change the subject.
You think Microsoft offering to sell you a license demonstrates that a license is needed. Other people here claim you’re wrong.
This isn’t “nit-picking”, this is a fundamental problem with the way you’re presenting your case.
Roy Schestowitz said,
November 23, 2008 at 12:21 pm
I left it open for other interpretations. See “Any other interpretations?”
AlexH said,
November 23, 2008 at 12:29 pm
Whether you think you left it open or not, any reader knows exactly what point of view you want them to leave with.
I have no doubt you will cite this story in the future as evidence of patent problems with Mono. In fact, I even suspect you think it is evidence of patent problems. Sad.
Roy Schestowitz said,
November 23, 2008 at 12:32 pm
Had there not been a patent problem and need for licensing (beyond Mono as well), we would not get such a response.
Roy Schestowitz said,
November 23, 2008 at 12:32 pm
In principle, in Microsoft’s view, all GNU/Linux vendors must sign deal like Novell’s. Novell’s deal with Microsoft covered Mono.
AlexH said,
November 23, 2008 at 12:35 pm
@Roy:
Ok. Ask Microsoft about getting a license for some other piece of software. I suggest Samba.
Let’s see what changes in their response, and see if Microsoft really are giving you the free legal advice you seem to think you’re getting.
Dan O'Brian said,
November 23, 2008 at 12:39 pm
Roy: what response is it that you think you got? He said IF you really do need to license any of their patents, he would be able to help you do so. He didn’t say that you were legally bound to obtain a license to use Mono, which seems to be what you think he said.
Had you replaced “Mono” with “C++”, he likely would have responded with the exact same text. “IF you need to obtain a patent license, we’ll be glad to help you”. That doesn’t prove that you need to obtain a patent license from Microsoft to write c++ programs.
Roy Schestowitz said,
November 23, 2008 at 12:40 pm
No need. There is also certainty around Samba, unlike Mono.
Roy Schestowitz said,
November 23, 2008 at 12:41 pm
Sorry, that last reply was to AlexH.
Dan O’Brian,
Yes, I see the semantics. A better answer would be that it is not necessary or that the words of Bob Muglia hold no water.
AlexH said,
November 23, 2008 at 12:42 pm
@Roy: are you being obtuse, or do you genuinely not understand?
The whole point of the test is that you and I know that Samba doesn’t need a patent license. Your claim is that if you ask Microsoft for one, they will tell you that you don’t need it.
I think that claim is bullshit and I’m calling you on it.
Doug said,
November 23, 2008 at 12:44 pm
I notice that in response to a request for a written license for ECMA 334 implementation, he responds with a reference to Microsoft’s patents and other IP. He doesn’t actually state if MONO does-or-does-not require such patent licenses.
Roy Schestowitz said,
November 23, 2008 at 12:46 pm
AlexH,
See my response to Dan.
AlexH said,
November 23, 2008 at 12:50 pm
That response doesn’t answer the question Roy.
Let me state it again, for complete clarity. You said:
Since we’re both agreed that Samba needs no patent license, we can say that your claim above can be turned into an experiment: send Microsoft your original email, but replace “Mono” with “Samba”, and show us that Microsoft’s response is different.
Jose_X said,
November 23, 2008 at 12:52 pm
Roy, I don’t think you have to add anything else. Microsoft has already said that if you run FOSS you have problems with them.
They have also said they will deal with people one-on-one. That is how they divide the opposition surely to come from customers and “partners” (divide and conquer). They don’t allow you to rely on others.
You are also NDA’d which means that the market will remain conspicuously quiet. If people can’t talk, nothing bad will be said. The typical customer will feel they are alone in their displeasure.
Those are the facts even if Microsoft *does* give *you* the license you are requesting. Were you instead asking for a universal license for everyone? If you were, I think they already dealt publicly with that question through Novell.. the except this except that clause(s) that were quoted in the other thread by jo Shields.
If you want to make a similar request of other vendors (Red Hat, IBM, etc) or otherwise do a more extensive study/analysis, you might learn something new and interesting, but I expect Microsoft to answer you very carefully.. until you go into NDA negotiations (at least if they wanted to hide anything, that would be the way to do it).
Do you have the link where an MS guy talks about how patents are only detailed (maybe perhaps) for those that want to engage in a serious conversation?
Dan O'Brian said,
November 23, 2008 at 12:53 pm
Doug: precisely, so it does not prove that Mono needs a patent license to use/distribute. In fact, I’d go so far as to say that if ECMA 334 /did/ require patent licenses, then the Microsoft IP licensing guy would have come out and directly said so, thus the response is closer to proving that Mono /doesn’t/ require a patent license than saying that it does.
Roy Schestowitz said,
November 23, 2008 at 12:54 pm
Alex, the point I was making is that they don’t falsify it and are prepared to negotiate.
Roy Schestowitz said,
November 23, 2008 at 12:56 pm
http://www.itworld.com/open-source/56391/microsoft-exec-touts-mixed-source-ventures
AlexH said,
November 23, 2008 at 1:04 pm
Of course they’re not prepared to falsify it or negate it. I could have told you that beforehand to save you bothering them:
a. they’re not going to give you legal advice. Saying “you don’t need a patent license for X” constitutes legal advice.
b. you didn’t even ask their advice. “I am [..]
expressing my determination to receive a licence” is not the same as “do I need a license?”. Hint: one is a statement, the other is a question.
c. like Microsoft, of all people, is going to turn down someone willing to give them money to license IP they don’t need.
If you’re not willing to do the Samba experiment for whatever reason, here’s another easy one.
File a bug against Mono in Debian, linking to your blog post above, and let them know that Microsoft is willing to offer you a patent license.
Debian are ardent supporters of free software, and do not distribute software which has patents actively enforced.
Jose_X said,
November 23, 2008 at 2:13 pm
Roy, that was the link. I skimmed and found part of what I was looking for on pg 3:
>> InfoWorld: So you’re not going to tell me what those patents were today?
>> Gutierrez: No, I will say this: Microsoft publishes every patent that Microsoft gets issued and we have had deeper, detailed discussions in the context of private licensing conversations, which by the way is the practice that every technology company follows. So to answer your question, yes, we have divulged them. We have talked about them with a number of companies that have shown interest in having a good faith licensing discussion with Microsoft.
..which takes place after Gutierrez refuses to list any patents having been asked a few times.
Ballmer has stated more than once that various open source have a liability. He has stated more than once that Microsoft needs to deal with this issue.
I haven’t heard of him being precise in any case.
Have you considered writing something up along the lines of the negatives (and/or positives) of mono, aside from the patent issue but perhaps along the lines of what I posted above http://boycottnovell.com/2008/11/22/protection-for-use-of-mono/#comment-39010 or also here http://boycottnovell.com/2008/10/11/mono-2-beyond-the-hype/#comment-27135 or in any of the other numerous places where I have said some of those things?
I’m thinking that everyone here perhaps agrees with what I stated in those two posts given there were no (pirahna) replies to the contrary [especially since the second link is one I have referenced possibly over 10 times by now, always without a single reply], but maybe if you post it instead of me as an official blog entry, there will be replies.
AlexH actually invoked the “don’t change the subject” when you referred to some of those items indirectly. I am not surprised. I know I can’t make him reply (it’s illegal), but somehow if he can be engaged, we might get a better sense for how he feels about those topics.
And posting those issues would also be an opportunity for everyone to bring out all the dirt they can on everyone else except Novell since I think they will need it in order to try and explain why they defend Novell and why they attack you so aggressively, often rebuking you for picking on Novell.
AlexH said,
November 23, 2008 at 2:47 pm
Jose: If you want to know what I think about something, just ask – seriously, I’m happy to defend my point of view.
However, I should correct you – I’m not defending Novell; I’m defending Mono, and there’s a huge difference. Spreading FUD about Mono in turn puts doubt on any distro which carries Mono (which means all of them, including gNewsense) and calls into question the licensing of free software in general.
If Mono is a problem, I’m happy to accept that: given proof. For example, there is a large cloud hanging over Moonlight, and I think it’s beholden on Novell to clear that up before people accept it.
There is no such demonstrable legal problem with Mono, though. There is plenty of FUD, but no actual evidence: on the contrary, the evidence is highly weighted in favour of Mono.
Roy Schestowitz said,
November 23, 2008 at 3:06 pm
http://beranger.org/index.php?page=diary&2007/05/31/08/09/05
Roy Schestowitz said,
November 23, 2008 at 3:10 pm
Jose, I’ll use your comments later (as a post) and attribute.
AlexH said,
November 23, 2008 at 3:11 pm
@Roy: ok, if Debian doesn’t meet your standard of freeness, how about gNewsense? They have a bug-tracker, file the bug there.
Or is there some other reason you won’t do any of these things?
Roy Schestowitz said,
November 23, 2008 at 3:13 pm
It’s not a priority.
AlexH said,
November 23, 2008 at 3:22 pm
But if Mono is a problem, shouldn’t you make it a priority to inform people of the new evidence you have?
Dan O'Brian said,
November 23, 2008 at 3:23 pm
“evidence”
Roy Schestowitz said,
November 23, 2008 at 3:26 pm
That’s what I do here, Alex.
AlexH said,
November 23, 2008 at 3:31 pm
Yeah, I’m sure that’s it. Mono is entirely non-free, we just have to wait for the various distros to find this page and discover it.
How long do you think that will take?
Roy Schestowitz said,
November 23, 2008 at 3:36 pm
The evidence speaks for itself. We don’t need you to spank the mono.
AlexH said,
November 23, 2008 at 3:44 pm
Yeah, just strange how you’re willing to defend it so hard yet completely unwilling to share it with those who could actually, y’know, make a difference.
Perhaps it speaks in a language only you can understand
Roy Schestowitz said,
November 23, 2008 at 3:51 pm
They read it here. Some people report bugs based on the information that’s shared as well.
AlexH said,
November 23, 2008 at 3:59 pm
I look forward to seeing the bug reports. Could use a laugh with this weather…
Roy Schestowitz said,
November 23, 2008 at 4:02 pm
I already do some with KDE.
AlexH said,
November 23, 2008 at 4:09 pm
Yeah, I doubt they have the same lulz-quotient though.
Roy Schestowitz said,
November 23, 2008 at 4:11 pm
It’s not related to Mono.
AlexH said,
November 23, 2008 at 4:16 pm
And to think, with those two off-hand posts, you’ve spent more time than it would require to file a bug and prove me wrong
I would do it myself were it not a complete waste of time for some poor triager somewhere…
Roy Schestowitz said,
November 23, 2008 at 4:19 pm
People whom I know already do this in Fedora, Ubuntu and Debian.
AlexH said,
November 23, 2008 at 4:24 pm
I look forward to the results then
Roy Schestowitz said,
November 23, 2008 at 4:34 pm
Me too, thank you.
I’m sure you wish proponents of Mono/vell luck.
AlexH said,
November 23, 2008 at 4:36 pm
No, actually – I don’t care which side is victorious. I use Tomboy lightly; if I had to remove that it wouldn’t be the end of the world, I’d go back to using Tbird.
If it’s non-free, let’s get rid of it.
Roy Schestowitz said,
November 23, 2008 at 4:41 pm
We have a new type of monster in our hands. It’s called “Free-but-Microsoft-patented(with_intimidation) software”. The GPLv2 needed to be redone/refined for this reason, among others.
In simple terms (and I’m sure you know this), the GPL in its older form (version 2) permitted companies to have it obeyed while adding patent provisions/restrictions that apply to the software (licensed under GPLv2).
Our understanding is that Novell discussed the deal with quite a few people well before it was announced in order to confirm this and conform with the licence. While the SFLC/FSF could not prevent the deal, it was able to explain the consequences in advance. The GPLv3 ‘pardoned’ Novell by ‘grandfathering’, which is incorporated into the new licence. Other companies like Xandros were not as lucky because they were not excused. GPLv3 is a deterrent to companies that ponder repeating Novell’s deeds.
Jose_X said,
November 23, 2008 at 4:56 pm
Alex, I appreciate your reply. [I'd like to think I appreciate everyone's replies when they give them.]
I am here mainly to see to it that Microsoft and anyone serving as an aid to them are not made to appear harmless except to the extent they are. I also only have so much time I’m willing to dedicate to this forum. Hopefully, we can all discover in the end that everything was just a misunderstanding so we can move forward in a way that helps FOSS. Others may feel FOSS is fine already, but I am troubled.. hence, why I am here.
>> However, I should correct you – I’m not defending Novell; I’m defending Mono, and there’s a huge difference.
There is a difference, and I’ll try to remember what you are specifying here.
To make sure I have it straight: you are here for the most part (or exclusively) to protest against patent FUD against mono, correct? [I don't think Roy is attacking the FOSS licenses currently being used.. I'm also not sure what else might be seen as a legal issue.]
>> If you want to know what I think about something, just ask – seriously, I’m happy to defend my point of view.
I will take you up on the offer but later on since I want time to think some things and word it well. I do want to know what developers using or defending mono (or those not doing so) think on some things.
AlexH said,
November 23, 2008 at 4:58 pm
No, that’s not really accurate at all.
What it did not prevent was companies simultaneously taking out patents which covered software whilst distributing it under the GPLv2. What it expressly does prevent is other people redistributing that software.
The GPLv2 actually says that if there are patents covering the software, you cannot redistribute it. Section 7, I encourage you to read it.
Roy Schestowitz said,
November 23, 2008 at 4:58 pm
I’m guessing that it’s more to do with Novell than with Mono, which is owned by Novell.
Roy Schestowitz said,
November 23, 2008 at 4:59 pm
Sorry, Alex beat me to it. This was a reply to Jose, who questioned AlexH’s motives.
AlexH said,
November 23, 2008 at 5:03 pm
@Jose: pretty much right, yes. What I protest is having Mono painted with patent problems when:
a. no example patent has been found which purports to cover it,
b. the project actively avoids patents,
c. the various distributions, commercial and otherwise, are all happy to distribute it.
Be suspicious about MS and Novell, but don’t pretend that FUD is fact, that’s all I ask.
Roy Schestowitz said,
November 23, 2008 at 5:10 pm
re: patents, see this:
AlexH said,
November 23, 2008 at 5:14 pm
Yeah. I tripped up in about the third paragraph:
Er, no, no it doesn’t.
Not worth bothering to read the rest if they cannot get basic facts like that right; the whole argument is shot.
Roy Schestowitz said,
November 23, 2008 at 5:21 pm
No, no, no… read the whole of it. Don’t try to nitpick.
AlexH said,
November 23, 2008 at 5:26 pm
Roy, are you serious? This is “nit picking”?!
For goodness’ sake. The argument begins with the assumption that Novell have a patent license and that they’re putting code known to be patent-encumbered into Mono. That argument is simply wrong, and the whole thing falls apart. Watch:
“not licensed by Microsoft to run anywhere but in SLED” – incorrect; no patents == no license needed
“When you install Mono 2 on any Linux system, you are installing software [..] without having a license” – incorrect; no license needed
“ported programs on your Linux system will include and rely upon the unlicensed Mono libraries on your system” – incorrect; no license needed.
I mean, come on.
Roy Schestowitz said,
November 23, 2008 at 5:36 pm
Bob Muglia, Microsoft:
“There is a substantive effort in open source to bring such an
implementation of .Net to market, known as Mono and being driven by
Novell, and one of the attributes of the agreement we made with Novell
is that the intellectual property associated with that is available to
Novell customers.”
http://www.eweek.com/article2/0,1895,2060750,00.asp
Dan O'Brian said,
November 23, 2008 at 5:36 pm
Roy: basic logic, man. Learn it.
Dan O'Brian said,
November 23, 2008 at 5:37 pm
Roy: that doesn’t say that it isn’t available to anyone else.
Roy Schestowitz said,
November 23, 2008 at 5:43 pm
It says nothing about anyone but Novell. Why?
Also, look at the agreement signed (redacted).
AlexH said,
November 23, 2008 at 5:43 pm
@Roy: simple yes or no answer. Are you claiming that Novell have a patent license from Microsoft?
Jose_X said,
November 23, 2008 at 5:44 pm
>> > Novell has a patent deal with Microsoft, so that Novell has a license from Microsoft to write these non-free parts of Mono
>> Er, no, no it doesn’t.
1 — I don’t track this that closely, but it’s almost impossible to know what is not being shown and this can include such a license. I don’t think you are speaking legally on behalf of Novell; hence, I don’t see how you could know that they would not have a patent deal with Microsoft for a part of mono.
2 — The added threat here is that Microsoft patents that are violated can be used to Microsoft’s advantage whenever Microsoft decides to distribute GPLv2 software (or GPLv3 if the patents were granted prior to the 2007 date). Microsoft has the greatest such potential advantage because dotnet is their baby (not to mention they provide “managed” access to mono/Novell devs so that chances of violation might be increased).
Correct what is wrong here because I have given it limited amount of thought and IANAL, etc.
I have a problem with giving advantages to Microsoft that would not bother me if they were instead bestowed to Sun or even to IBM. We’d have to look at details, of course, but keep that in mind before you reply with Sun.. patents.. Java.
Roy Schestowitz said,
November 23, 2008 at 5:46 pm
See 10-K:
AlexH said,
November 23, 2008 at 5:49 pm
@Roy: it’s a simple yes or no answer. Are you claiming they have a patent license?
Come on, this isn’t a hard question to answer.
Roy Schestowitz said,
November 23, 2008 at 5:55 pm
http://commandline.org.uk/linux/2007/aug/5/be-careful-who-you-kiss/
“If you carelessly kiss everyone then you are likely to get a different kind of mono. Microsoft are a convicted, serial and unrepentant anti-trust violator, I find it hard to trust anything they say, I am not sure we should go near them at all, let alone start kissing up to them. So if there are some distributions that can be not so heavily yoked to Mono, then if the patents turn out to be a problem, all the GNOME-based Linux distributions do not all fall at once.
“I read the agreement between Xandros and Microsoft, and one of the excluded products was Mono, so Microsoft promises to not sue Xandros over their distribution but excluding Mono and a few other products, i.e. they reserve the right to sue over Mono. I wonder if this is an interesting preview of on what basis they want to fight the free world.
“Interestingly, the Novell deal seems to be different, Mono is not excluded from the Novell deal. So Microsoft seems to be promising not to sue Novell over Mono, but keeps the option open for Xandros. Weird but true.”
Jose_X said,
November 23, 2008 at 5:55 pm
Alex, how do you know they don’t. Are you claiming they don’t?
AlexH said,
November 23, 2008 at 5:58 pm
We can never get a straight answer out of you when you know you’re full of crap.
AlexH said,
November 23, 2008 at 5:59 pm
@Jose: there’s a piece of evidence in this thread already which demonstrates whether or not there is a license.
I was hoping that Roy would actually engage on the argument rather than spin and bluster so we could argue on the merits….
Jose_X said,
November 23, 2008 at 6:00 pm
>> Roy: that doesn’t say that it isn’t available to anyone else.
You are correct, but the fall-back is trust to dealing in a business setting with Microsoft. I take their history and what they say even today as evidence of high risk. Certainly, I personally don’t trust them.
Do you want to show me how I am safe? I don’t need to prove that I am definitely cooked in order to believe there are high risks.
Roy Schestowitz said,
November 23, 2008 at 6:00 pm
Why do you insult Mr. Green? I merely gave you an informative reference.
You seem to be losing your argument and cursing.
Jose_X said,
November 23, 2008 at 6:01 pm
Alex, can you give me a better clue? .. after you are done waiting on Roy, of course.
Roy Schestowitz said,
November 23, 2008 at 6:01 pm
Microsoft Litigation Resource Page
“Those Who Forget History Are Doomed to Repeat It”
Jose_X said,
November 23, 2008 at 6:02 pm
Alex, don’t mean to appear to tease, but as stated in the slightly longer comment I made recently, I don’t see how you can know.
AlexH said,
November 23, 2008 at 6:05 pm
@Jose: Sure. Actually, the evidence is in one of Roy’s own comments
Even though he didn’t quite understand the GPLv2 correctly, his point that this agreement subverted the v2 license, and it managed it because v2 only took into account direct patent licenses.
The only reason the agreement didn’t fall foul of GPLv2 is because Novell didn’t get a patent license.
Roy Schestowitz said,
November 23, 2008 at 6:09 pm
We had this very long discussion before, Alex. You’re being pedantic and it’s just a trick question. You’re using the same tricks as Jeff Waugh now.
AlexH said,
November 23, 2008 at 6:13 pm
No, Roy, it’s not a trick question. You posted a diatribe against Mono that was predicated on Novell having a patent license and putting patented code in Mono. I’ve shown that is false: entirely, undeniably, false.
You see, this is the problem. I know we’ve had this discussion before, where you play with words like “license” and “protection”, and try to spin the Novell/MS agreement in such a way as to make people believe that it makes Mono non-free.
It’s nonsense.
Jose_X said,
November 23, 2008 at 6:16 pm
>> The only reason the agreement didn’t fall foul of GPLv2 is because Novell didn’t get a patent license
Alex, you are using circular logic here. I asked how can you know that Novell doesn’t have a license.. to which you replied that they don’t.
Did you understand what I asked?
AlexH said,
November 23, 2008 at 6:17 pm
Jose: Did you read the link I provided?
If Novell got a patent license, they would have fallen foul of the GPLv2: it explicitly doesn’t allow that. That’s not circular logic.
Roy Schestowitz said,
November 23, 2008 at 6:21 pm
You introduced a totally new argument. How come?
AlexH said,
November 23, 2008 at 6:24 pm
@Roy: No, I introduced evidence that Novell don’t have a patent license from Microsoft.
Why did I do this? Because you posted someone’s opinion attempting to insinuate that Novell are putting patented code into Mono based on this patent license.
The license is fictional and the patented code is too.
Roy Schestowitz said,
November 23, 2008 at 6:30 pm
If Microsoft agrees not to sue Novell and its customer, what does it mean for the rest then? And why is Mono in the basket?
Jose_X said,
November 23, 2008 at 6:42 pm
[Alex] >> Did you read the link I provided?
I looked over the GPL v2 (7) and v3 (11) if that is what you mean.
Novell can have a license and not share this information. Good luck suing, in a few years when mono has spread, a company that has gone bankrupt or that decides to fight from the grave or from beyond the realm of logic as SCOX has been doing.
It should be obvious that no one knows this except “Novell” and “Microsoft”.
***
Secondly, there are many ways for mono to hurt without anyone violating the law and without Novell having a license.
** In particular Novell just writes and Microsoft just smiles.
** Novell not wanting to know and not having a license is exactly what we need to worry about.
***
In practice, Novell is working for Microsoft’s gain. Why would they need a license today since it isn’t in Microsoft’s interest to sue today? If they wanted and needed a license, this is something that I think they could arrange in the future (gentleman’s agreement or maybe even a simple deferred license deal that would not affect Novell’s status today).
***
The covenant, while not a license, can easily be misunderstood to be one by laypeople. In this case, the effect (the conclusion) is roughly the same as far as you and me are concerned. So technically the person quoted by Roy and you might be wrong, but not for the effect of the general threat assessment (GPLv2 and v3). Of course, to repeat the first point, we don’t know that Novell doesn’t have a license (even if it is useless in terms of them spreading mono as Microsoft values). In other words, that person might be correct if they had access to info we didn’t. [And to repeat: I doubt Novell has a license since they don't need on in practice and they would surely prefer to be legal.. and the mono poison would take effect regardless.]
AlexH said,
November 23, 2008 at 6:46 pm
@Roy: Microsoft didn’t agree not to sue Novell. This is a basic fact you should understand by now. I don’t know what you mean by “in the basket” though: if you’re referring to exceptions to the “Clone product” parts of the covenant, they don’t in any event cover current development, only past. So, irrelevant.
@Jose: the link I provided was to a transcript of a talk RMS gave where he explained the GPLv3 and how Novell doesn’t have a patent license.
If you choose not to believe that, that’s up to you. No-one seriously claims Novell have a patent license, though.
Jose_X said,
November 23, 2008 at 6:50 pm
[Alex] >> The license is fictional and the patented code is too.
Please read the first part (and mabye the last part as well) of my previous comment before you go onward thinking Novell doesn’t have a license.
Please read the second part of my previous comment if you think mono is safe. Novell doesn’t need a license in order for mono to hurt. Plus, they aren’t about to be sued by Microsoft anytime soon as long as they do a good job helping Microsoft.
If you think the patent risks against mono are minor or similar to something else, please state that so we can take a closer look.
And surely you don’t think that anyone can guarantee that there is no patented code, do you? That is not something anyone can know unless you have read all patents and are brilliant in more ways than one. [See previous paragraph]
AlexH said,
November 23, 2008 at 6:54 pm
@Jose: two different things.
Is Mono guaranteed patent-free? No. No software is. But the project actively avoids patents as they are brought up, which is the best you can do.
Is Novell involved in putting patented code in Mono? Without evidence, sorry, I don’t buy this. And there is not a single shred of evidence: no-one has pointed to any code in Mono which is covered by a patent, Microsoft’s or otherwise.
Jose_X said,
November 23, 2008 at 6:58 pm
>> the link I provided was to a transcript of a talk RMS gave where he explained the GPLv3 and how Novell doesn’t have a patent license.
>> If you choose not to believe that, that’s up to you. No-one seriously claims Novell have a patent license, though.
OK. Thanks
Now, in consideration of the harassment Roy receives here in general, as well as on this thread in particular, the fact is that you don’t “believe” Novell has a license, but you don’t know. Is that correct?
And to finish with this point (and again only in consideration of the harassment we see here on BN), I would say that you do not have proof for saying, as you said, that “the patent license is fictional,” and you recognize that in fact it might be real, correct?
***
Now, in terms of Novell *likely not having* a patent license, I agree, because they don’t need one.
Also mono is not any safer whether they have one or not.
***
As for that person that was quoted, he might, in fact, be correct.
He likely isn’t correct about the license, however, but that doesn’t mean his risk assessment doesn’t come to a correct conclusion (btw, I would have to read it carefully again to see exactly what he concluded).
AlexH said,
November 23, 2008 at 7:04 pm
@Jose: you’re chasing ghosts.
Sure. In the same way I believe that there isn’t a monster at the bottom of Loch Ness.
These are the options:
a. Novell has no license, like they say;
b. Novell has lied to their shareholders and investors, the FSF and everyone else, and have a secret patent license from Microsoft.
For option b. to be true you’re accusing all the executives involved there of serious corporate malfeasance, and you have absolutely no evidence of it. I’m sorry, but I don’t countenance that. If you’re willing to believe that then there’s no point us discussing this, because you cannot prove a negative.
I suggest you read that piece again. It requires Novell to be putting patented code into Mono. His risk assessment is entirely wrong.
Roy Schestowitz said,
November 23, 2008 at 7:08 pm
Wrong? Or not sufficiently convincing to you (yet)?
AlexH said,
November 23, 2008 at 7:12 pm
@Roy: the argument relies on deliberate insertion of patented code. That is unjustified and unfounded.
Roy Schestowitz said,
November 23, 2008 at 7:19 pm
You mean like http://www.mono-project.com/WinForms ?
AlexH said,
November 23, 2008 at 7:24 pm
So where are these patents which apply to it?
Oh, yeah, there’s your example of a Winforms patent which by definition doesn’t apply to Mono (managed code), and the “Winforms” search you did on Google without understand the results. Been there, debunked that. Next.
G. Michaels said,
November 23, 2008 at 8:00 pm
So what about Mono applications that target GTK# and use the MySQL managed providers, for example? Like AlexH and others have argued, no software is guaranteed free of patents (a for loop might get you in trouble these days), but as I understand this, the most “dangerous” (and note the quotes here) part of Mono is ASP.NET. AFAIK ADO.NET in Mono is written against the generic ADO interface, which is part of the ECMA spec, and in any case Sybase, Oracle, CA and IBM, who all wrote managed providers against it, would conceivably be also in infringement.
Also, does anyone know if Java had this level of furious anger directed at it before it went GPL just recently? I don’t remember ever seeing anything like that directed against Sun. Apache happily produced tons of software using it, and distros included it in repositories just fine. Sometimes I think the whole Mono deal is just the uncomfortable fact that someone copied a useful Microsoft technology, and that seems to rub people the wrong way, as if it were an admittance of failure or something like that.
(disclosure time: I used to be a full-time Java coder back in the day, but nowadays my time is largely wasted on designing software rather than writing it. It does pay better…)
Note: writer of this comment adds absolutely nothing but stalking and personal attacks against readers, as documented here.
Jose_X said,
November 23, 2008 at 8:06 pm
Alex, the Lockness Monster thing was a bit over the top, especially since Novell could have taken a license after they made any statements. There are other scenarios as well.
However, I do agree they don’t need one.
***
As for putting patented code into mono, that is not something Novell need do consciously if they don’t know what patent might be involved and in what way. When you find out that you trod on ground they “owned” and you can’t break away except to break a lot of existing application compatibility plus a lot of associated work, it is going to be costly. Customers using the applications, especially for often-used API, cannot change over night. They pay. Also paying are Linux service providers that offered such code.
Microsoft does not depend on FOSS like most “FOSS” companies. They have proprietary monopolies. Any FOSS they embrace is strategic to them protecting the monopolies. Expect traps. It’s there nature to abuse or leverage contracts to their fullest extent. They made a mockery of Stock Options Income Tax Benefit. They made a mockery of contracts to many companies (like Spyglass). They made a mockery of ISO, again, all the while attempting or at least claiming that they were going by the rules.
You might end up violating many patents difficult to get out of because of the special effort put on Microsoft’s part to achieve that goal (they control lots of info.. the standard, their patents, the select code they show Novell.. which may not even be what they ship, etc).
People with knowledge of strategic violating code can also repeatedly try to sneak such code or such “fixes”.
The potential seriousness and costs to change after a patent violation comes to light depends on specifics that only Microsoft really knows at this point in time, especially since some patents may not even have been granted today.. and the pipeline is nonstop. Microsoft is not going to share strategic information ahead of time.
Microsoft can sell the patents to trolls (eg, Myrhvold, Gates,…). In fact, there might be huge resources applied to developing strategic dotnet patents. This effort can be spread across many trolls with special access from Microsoft/Gates/etc.
I am not saying that these things are guaranteed by any means. I am saying that there is potentially very significant risk.
We take into account Bilski, but that is still a recent decision whose effects are still not really known too well. Also some countries don’t have patent issues today.
However, even in partial failure by Microsoft, there is all the extra FUD that will arise when accusations start getting stronger or a patent or two are shown. Afterwards, “all” FOSS is extremely suspect in many’s eyes because one project got too close to Microsoft and got burned a little too much.
A defense that FUD will grow over time and especially as lawsuits arise might be that we can’t control fake projects — anyone can always set us up; however, if mono gets used widely, that is much more damaging than if some tiny project gets threatened. The wider mono gets used, the worse the FUD, even in partial failure by Microsoft. And mono is starting off already in the high risk category relative to most other projects because of the Microsoft factor.
Alex, I don’t want to overplay the risks. I know you insist on remaining optimistic, but you can’t look at all of this and wave it.. or I’ll have to wait and see I guess.
Jose_X said,
November 23, 2008 at 8:24 pm
>> Sybase, Oracle, CA and IBM, who all wrote managed providers against it, would conceivably be also in infringement.
They would love patent issues because it becomes a hurdle they can easily cross while many others can’t, most notably, the really open free stuff.
>> Also, does anyone know if Java had this level of furious anger directed at it
Sun is not Microsoft. It’s that simple.
Microsoft is Proprietary Monopolies incarnate. Microsoft is Leverage incarnate and mastered. Microsoft is Unethical Is Fine If Legal and Maybe Even If Not incarnate. Microsoft has many more resources than Sun put to the task of maximizing their strategic market position. Their power in the market and their actions over time to preserve it have been quite different from Sun’s.
Like I said in the prior comment, Microsoft seeks all strategic gains and actively works to keep strategic info hidden and to set contracts and code to their benefit in a way no other company attempts, much less successfully pulls off. They are the notorious ones. They are the ones that soiled unsoilable ISO, among other things they have poopoo’d.
>> Like AlexH and others have argued, no software is guaranteed free of patents
And you aren’t guaranteed to live for 100 years either, but that doesn’t imply it’s just as safe to take kids out for a stroll across lanes of the expressway as it is to let them play in the backyard. Risks always exist, but not all risks are created equal.
[I won't address your comments on specific parts of dotnet because I have no clue.]
>> Sometimes I think the whole Mono deal is just the uncomfortable fact that someone copied a useful Microsoft technology, and that seems to rub people the wrong way, as if it were an admittance of failure or something like that.
We’re just discussing possible patent risks on this thread. That is all we are discussing here. There are a lot more reasons for not spreading protocols that favor Microsoft in lieu of the options.
Roy Schestowitz said,
November 23, 2008 at 8:34 pm
Mono would be a more visible infringement.
http://boycottnovell.com/2008/09/19/why-not-mono-car-analogy/
http://boycottnovell.com/2008/09/20/mono-java-dotnet-analysis/
AlexH said,
November 24, 2008 at 3:29 am
@Jose: first, “Novell could have taken a license after they made any statements” is wrong – they’re a publicly traded company, they can’t do that kind of thing.
The problem with your other arguments is that they’re not based on any evidence, and in fact rely on Novell (& the other contributors – Novell aren’t the only people writing Mono) being much worse at avoiding patents than other people (e.g. Sun).
You also claim that things like Mono API could be affected. That’s simply not how patents work. There is no risk there, except the one you imagine.
Roy Schestowitz said,
November 24, 2008 at 3:44 am
What does Sun have to do with it? It’s no using defending this using comparisons, as you have done before.
AlexH said,
November 24, 2008 at 4:44 am
@Roy: because for the argument Jose put forward to work there needs to be a reason why Novell are much worse at avoiding patents than any other developer. I gave Sun as an example because they develop an extremely similar system which is likely to encounter many of the same patent holders and patents.
Roy Schestowitz said,
November 24, 2008 at 4:46 am
Fair enough, I missed that.
Jose_X said,
November 24, 2008 at 9:21 am
>> “Novell could have taken a license after they made any statements” is wrong – they’re a publicly traded company, they can’t do that kind of thing.
What the fsfsdf are you talking about?
Did they say they weren’t going to enter into a license agreement with Microsoft ever?
And assuming they did say that (I’ll wait for you to confirm or deny that), how did they word it? We know (a) Microsoft execs have fessed up while on the grill chair in court to having lied on various occasions publicly and as execs of publicly traded companies, (b) that SCOX, another publicly traded company was a disaster with its execs treating words like if they were Picasso painting on a canvas, (c) that execs of publicly traded companies (eg, Enron) get convicted of crimes, (d) that top brass tend to pass tricky things down to someone else (MCI?), (e) that there is always a first time for any violation though in fact white collar crime by execs of publicly traded companies has happened thousands of times.
In general, if you want to wager that none of these things will happen to hurt you, that is your call. But to say it is impossible is something else.
Finally, what exactly did I say that was incorrect in that quote? I did not specify which statements because I haven’t paid attention; however, since you are calling that incorrect, at the minimum, I expect you will now state exactly who said what wrt to this licensing issue. Once we know the specifics, we can look further. You said I was wrong, so let’s get to it and see the evidence.
Also, I am confused, as earlier you seemed to have acknowledged that you spoke too loosely before (I’m being generous with my phrasing). Are you now taking it back?
>> … and in fact rely on Novell (& the other contributors – Novell aren’t the only people writing Mono) being much worse at avoiding patents than other people (e.g. Sun).
What the fsfsdf are you talking about?
– We aren’t talking about Sun doing Java and avoiding dotnet patents. Sun came first and Java and dotnet are different enough despite more than enough potential for patent overlap. It’s possible, sure.
– We aren’t talking about Microsoft doing dotnet and avoiding Java patents. Here Microsoft came later and is more likely to violate Sun patents than vice-versa; however, Java and dotnet, while similar enough for some patents to be of issue, could certainly be closer, so there are patents that will hit one but miss the other. It’s more possible.. likely MS and Sun already dealt with this specifically in their earlier agreement.
–What we are talking about is Novell coding in time after Microsoft AND doing a clone! You must be kidding me if you don’t see the significantly higher risks here.
Also, the more specific a patent is, the more likely it is to be upheld. Java fans are somewhat threatened by Microsoft patents say around virtual machines (if MS had some). To encompass dotnet and java, you have to be a bit general for sure; however, mono and MSdotnet overlap in functionality soooo much more. They follow the same basic complex standard for goodness grief.
I have to repeat, what the sfsfasd are you talking about?
>> The problem with your other arguments is that they’re not based on any evidence,
I didn’t accuse Novell of being in violation. I stated a bunch of risks. It’s your issue if you want to ignore the risks.
What sort of evidence then did you have in mind?
I think you are confused. [You might be wrong, but you were so vague, I can't tell.]
Maybe you want to quote my other post piece by piece and we can start from there.
AlexH said,
November 24, 2008 at 9:27 am
You said that Novell could have secretly agreed a license with MS. I’m pointing out that they would have had to make a public statement, particularly wrt. their GPLv2 obligations.
As for the patents: you made the claim that patented code could be going into Mono without Novell realising it. I’m pointing out that could only be true if Novell are significantly worse at figuring that out than other developers, and I don’t see any evidence of that at all.
You’re not talking about risks: you’re talking about hypothetical and fictional scenarios which have no basis in reality. I’m not even sure you understand how patents work, at this point, given your comments about Java.
Jose_X said,
November 24, 2008 at 9:32 am
>> because for the argument Jose put forward to work there needs to be a reason why Novell are much worse at avoiding patents than any other developer.
I wish you lots of luck trying to find where I recently (or at any time come to think of it) said that.
I also noticed, again, that I post a bunch of examples and you only try to answer one at most (and a bad reply it was at that) while ignoring the rest.
Am I to take it you agreed with everything I said, except perhaps for the imagined case where you imagined I said Novell was worse than everyone else?
AlexH, you are back to disappointing me. And just when I had built some hope you were being honest, too.
Actually, I’m not disappointed. You motives aren’t an issue, and I don’t presume to know what they are or if you are being honest. But you are starting to look dishonest here. Either that of maybe you should get some sleep since perhaps your logic is slipping a bit. Or if not, you might be reading too fast. Or else you are improvising or not bothering to proof read what you write.. something’s gotta be wrong. .. I know, maybe you can’t wait to get back to attacking Roy. Sorry, to keep you. You can leave me with the last word any time you want. In fact, it doesn’t matter who gets the last word. I’m confident you are short in your analysis. I’m almost tempted to help you get a few points.
Again, I really dislike dishonesty. That’s called lying, deceit. It’s called letting everyone get hurt and screwed in the future so that you get your way or what you wanted. It’s nasty. I’d rather feel like a fool (which I don’t.. there’s no point in doing so since we all make mistakes).. than feel nasty.
Jose_X said,
November 24, 2008 at 9:35 am
>> You said that Novell could have secretly agreed a license with MS.
I’ll give you the benefit of the doubt for about 10 minutes that I can’t remember where I said that but you can.
600.. 599 .. 598 ….
AlexH said,
November 24, 2008 at 9:44 am
@Jose: First off, you did say they could have struck a secret deal:
They can’t change the terms of an agreement after the statement. If they came to a new agreement, they would need to make a new statement. That’s how the markets work.
And please, don’t accuse me of dishonesty either. If I miss points you raise, it’s because you post paragraphs and expect me to pick out everything. Just post simple, concise questions.
Jose_X said,
November 24, 2008 at 9:44 am
>> As for the patents: you made the claim that patented code could be going into Mono without Novell realising it. I’m pointing out that could only be true if Novell are significantly worse at figuring that out than other developers, and I don’t see any evidence of that at all.
Then it must be your logic that is faulty.
How can Novell safeguard against patents they don’t know exist or which they haven’t studied that well?
They can’t and neither can most “other developers”.
Do you disagree with either of these, or do you see some logical path that could lead to your conclusion?
>> I’m not even sure you understand how patents work, at this point, given your comments about Java.
Please quote and be specific.
Are you suggestion that a patent can’t cover aspects of dotnet and of java? Please tell me you aren’t saying that. These have common properties by the truckload.
567.. 566…. (waiting for all the specifics to show all of these things you have been alleging)
AlexH said,
November 24, 2008 at 9:51 am
You’re missing the point. Let’s look at something we agree on:
No, I’m saying precisely that they are extremely common, and most patents which cover one will cover the other.
For Mono to be significantly more risky than another implementation of either setup, you’re asking me to believe that Novell are doing a worse job at avoiding patents than other implementors.
I don’t see any evidence to support that, or any reason to believe it.
And please, cut out the countdown thing, it’s disrespectful.
Josh Bell said,
November 24, 2008 at 9:53 am
Jose,
I seriously think you should read the mono licensing faq to better understand. It is here http://www.mono-project.com/License.
Jose_X said,
November 24, 2008 at 10:03 am
>> And please, don’t accuse me of dishonesty either.
Like I said, your motives aren’t an issue. It’s also immaterial what I think about them. If I ever want to call you a fraud, I will. It would still not be that important. It’s tough to prove dishonesty.
Now, like I said to others, what I think should not affect you. Trust is somewhat earned anyway. You may have earned it with 1 million people, but that doesn’t include me. And that doesn’t matter because we are reasoning things out, not engaging in business transactions.
I’m taking what you say at face value. Not sure what more you expect (trust? .. like I said, that comes later).
>> First off, you did say they could have struck a secret deal:
>> > the Lockness Monster thing was a bit over the top, especially since Novell could have taken a license after they made any statements.
I said nothing about secret. Are you reading correctly? Grep for “secret” and you will only come across something you said, not me.
Alright well, I’m still waiting for a lot of evidence from you, including where I talked about a secret deal, but let’s keep adding to the pile.
>> If they came to a new agreement, they would need to make a new statement.
We can start by seeing what statement they made originally.
Second, for my statement to be incorrect, it would have to be *impossible* for them to take out a license, not simply improbable. In fact, they can take out a license in a year and make a statement shortly thereafter.
Really, there are so many problems with your claim that my quoted statement posted earlier was wrong, that I would prefer not to keep pushing this (but I’ll let you decide when you want to stop).
There are more important topics we could talk about… like patents.
Roy Schestowitz said,
November 24, 2008 at 10:02 am
You probably mean
http://www.mono-project.com/License (without the full stop)
“The .NET Framework is divided in two parts: the ECMA/ISO covered technologies and the other technologies developed on top of it like ADO.NET, ASP.NET and Windows.Forms.
“Mono implements the ECMA/ISO covered parts, as well as being a project that aims to implement the higher level blocks like ASP.NET, ADO.NET and Windows.Forms.”
We have:
http://www.mono-project.com/WinForms
http://www.mono-project.com/ASP.NET
http://www.mono-project.com/ADO.NET
So this remains sensitive to patents, regardless of all that BS about the corruptible ECMA and ISO.
AlexH said,
November 24, 2008 at 10:09 am
@Jose: seriously, come on. It’s as simple as this:
1. Novell have made no statement about taking out a license.
2. Novell have made several statements specifically saying that they have not taken out a license
3. Microsoft ditto.
4. FSF have made statements that Novell do not have a license
5. Having a license would put them in trouble with GPLv2 s.7
6. To have kept it a secret would also be corporate malfeasance.
Are you seriously suggesting that there is any possibility they have a license?
Jose_X said,
November 24, 2008 at 10:18 am
>> No, I’m saying precisely that they are extremely common, and most patents which cover one will cover the other.
You were quite vague. It’s only now that you are being clearer wrt this point. Go back and check.
Now, to address what you are now saying.
Since I don’t know dotnet, you may have to help me. Can you think of say 1 or maybe 100 classes (or even methods) in dotnet/mono that have no very similar analog in Java? If you can, you have just found 100 areas where patents could dive that would affect dotnet/mono but not java or vice-versa.
Can you find 5? 15?
This is a subjective call. I can try and rely on your technical judgment to answer this or I can eventually try and go look myself. You deal with this daily. If you can’t find, I expect it should take me months to maybe possibly find something.
>> For Mono to be significantly more risky than another implementation of either setup, you’re asking me to believe that Novell are doing a worse job at avoiding patents than other implementors.
Only if you can’t find differences. If they truly are that similar (like dotnet and mono) then yes. So can you find differences?
..something common to dotnet/mono but different in Java?
We aren’t saying Java can’t have patents. We are looking for risks of being sued or threatened. Microsoft can’t take out a patent that covers Java (or dotnet) after Java was already out (or at least the particular feature in question).
Now if you want to discuss the threats from Sun vs from Microsoft that is a different point but one I hope we eventually get to unless you agree with what I have said about it.
Jose_X said,
November 24, 2008 at 10:23 am
[Josh] >> I seriously think you should read the mono licensing faq to better understand.
I’m not sure what part of that you think is relevant.
Does Microsoft own this mono faq, btw? [not to mention that a faq is hardly something to make your lawyer relax]
Jose_X said,
November 24, 2008 at 10:51 am
>> seriously, come on. It’s as simple as this: …
>> 6. To have kept it a secret …
First, stop bringing up the “secret” license thing. I have not said that and have corrected you a few times. If I am wrong, the show me and stop ignoring my plea for you to show me.
Second, I already mentioned as an example of legal conduct that Novell can strike a deal make a statement afterwards.
Thirdly, you ignore all the possible questionable judgment calls.
Of course… Forth, you have not produced their actual statement. We have to see that to continue wasting time arguing over this point.
Back in the thread, you were saying that Novell does not have a license. Fact is they might have a license right now.
They might also have (to give another example) a contract where under certain scenarios Novell might be entitled to exercise an option to take out a license, but the execs might judge that at this point in time, such a clause is not material to their bottom line or their business. Whether right or wrong, that is a judgment call. Feel free to sue later if you want.
This point, btw, is a waste of time because I already said that a license is something Novell doesn’t need or can take a chance not getting in the near future. They are helping Microsoft. mono is still not widespread. Now would not be the best time for Microsoft to show violations.
Are you maintaining still, as you have already, that Novell cannot have a license at time T because of something they made public in the past (and which doesn’t specifically say (or so I haven’t heard) that they will not strike up a license with Microsoft over X ever)?
Have you changed you mind about this:
>> “Novell could have taken a license after they made any statements” is wrong – they’re a publicly traded company, they can’t do that kind of thing.
How about the patent comment? Do you think there aren’t 100 significant enough differences between dotnet/mono vs java so as to find material for patents?
Actually, though I already stated that I don’t think a license now is something they might be dying to get, let me indulge a little longer in this hypothetical through one more quote:
>> 5. Having a license would put them in trouble with GPLv2 s.7
Well, that’s find and dandy but that won’t make me feel better if by the time we find out (eg, bankruptcy court) mono is spread out and I am affected negatively. That Novell messed up does nothing to fight Microsoft’s patents.
AlexH said,
November 24, 2008 at 10:51 am
@Jose: honestly, I read through that three times and I don’t understand the points you’re trying to make.
Let me make some statements and tell me where you disagree:
* .net and Java are probably 95% similar in terms of the virtual machine and runtime machinery. Main difference I can think of is the security architecture.
* the two systems have extremely similar APIs. Most core APIs are almost identical, some parts – like the Ajax stuff – are quite different. Most different is probably LINQ, but only because it’s a custom language.
* .net can run Java fine, via IKVM, and Mono can even compile it to native code. Grasshopper does the reverse, from .net to Java. Given that one framework can run the other framework’s code without any work, it makes me think that there are few substantive differences in practice.
AlexH said,
November 24, 2008 at 10:59 am
@Jose:
I’m sorry, but that’s exactly what you’re saying. You said it again just now, look:
See?! No, they don’t have a license right now: there is no announcement, therefore there is no license. Please, just give it a rest – “Novell has no license or covenant not to sue from Microsoft under this agreement.“
Josh Bell said,
November 24, 2008 at 11:00 am
Jose,
Mono is open source and always has been. It uses GPL 2.0 LGPL 2.0 or MIT X11 for licensing. Where I think the mistake is made wrt Microsoft is an interpretation of the license that says “Both the Mono runtime and the Mono C# Compiler are also available under a proprietary license for those who can not use the LGPL and the GPL in their code”.
Another relevant part may be
” When do I need to obtain a license from Novell to the Mono Runtime?
We only require licensing for uses of Mono and Moonlight on embedded systems, or systems where you are unable to fulfill the obligations of the GNU LGPL.
For example, if you manufacture a device where the end user is not able to do an upgrade of the Mono virtual machine or the Moonlight runtime from the source code, you will need a commercial license of Mono and Moonlight.
Or if you ship an application that requires to statically link the Mono runtime and you are not able to provide the object code to relink Mono, you must obtain a commercial license from Novell”.
If you follow the GPL then it is free and open source without issue.
Yet another piece.
Could patents be used to completely disable Mono?
First some background information.
The .NET Framework is divided in two parts: the ECMA/ISO covered technologies and the other technologies developed on top of it like ADO.NET, ASP.NET and Windows.Forms.
Mono implements the ECMA/ISO covered parts, as well as being a project that aims to implement the higher level blocks like ASP.NET, ADO.NET and Windows.Forms.
The Mono project has gone beyond both of those components and has developed and integrated third party class libraries, the most important being: Debugging APIs, integration with the Gnome platform (Accessibility, Pango rendering, Gdk/Gtk, Glade, GnomeUI), Mozilla, OpenGL, extensive database support (Microsoft only supports a couple of providers out of the box, while Mono has support for 11 different providers), our POSIX integration libraries and finally the embedded API (used to add scripting to applications and host the CLI, or for example as an embedded runtime in Apache).
The core of the .NET Framework, and what has been patented by Microsoft falls under the ECMA/ISO submission. Jim Miller at Microsoft has made a statement on the patents covering ISO/ECMA, (he is one of the inventors listed in the patent): here (http://web.archive.org/web/20030424174805/http://mailserver.di.unipi.it/pipermail/dotnet-sscli/msg00218.html)
Basically a grant is given to anyone who want to implement those components for free and for any purpose.
For people who need full compatibility with the Windows platform, Mono’s strategy for dealing with any potential issues that might arise with ASP.NET, ADO.NET or Windows.Forms is: (1) work around the patent by using a different implementation technique that retains the API, but changes the mechanism; if that is not possible, we would (2) remove the pieces of code that were covered by those patents, and also (3) find prior art that would render the patent useless.
Not providing a patented capability would weaken the interoperability, but it would still provide the free software / open source software community with good development tools, which is the primary reason for developing Mono.
The patents do not apply in countries where software patents are not allowed.
For Linux server and desktop development, we only need the ECMA components, and things that we have developed (like Gtk#) or Apache integration.
So from what I can discern there is no problem nor can Microsoft do anything to anybody using the ISO/ECMA pieces. That’s all Mono does and all it ever has done. You may not like it and there may be issues wrt your personal preferences and why do we need such a thing but there is nothing wrong with Mono in general and it follows the GPL or other OSI approved licensing wrt Linux.
Jose_X said,
November 24, 2008 at 11:33 am
>> See?! No, they don’t have a license right now: there is no announcement,
No, no, no. They can have an agreement today and make an announcement later. This “today” can occur at any point.
I also said this:
>> They might also have (to give another example) a contract where under certain scenarios Novell might be entitled to exercise an option to take out a license, but the execs might judge that at this point in time, such a clause is not material to their bottom line or their business. Whether right or wrong, that is a judgment call. Feel free to sue later if you want.
There are probably many other scenarios where they do get a license, but the execs judge this not to be worthy of an announcement. We would need to see what they have said in the past and discuss their business plans to get a better idea.
These are possibilities that cannot be dismissed and may be significant…
However, I don’t really care whether or not Novell has a license. I don’t see why they would need one now (not to imply there wouldn’t be reasons.. I don’t know).
And I am more than fine moving on.
>> * .net and Java are probably 95% similar in terms of the virtual machine and runtime machinery. Main difference I can think of is the security architecture.
>> * the two systems have extremely similar APIs. Most core APIs are almost identical, some parts – like the Ajax stuff – are quite different. Most different is probably LINQ, but only because it’s a custom language.
Assume true. This still leaves lots of room for lots of patents. 5% of 100,000 subparts is 5,000, for example. 2% of 100,000 is 2,000.
Do you think these numbers are way off? [I am being vague.. building on the "95%" you mentioned]
Microsoft can get a patent ahead of mono implementation. They can’t get a patent ahead of Java implementation unless they get very lucky or Java copies significantly.
The fact that mono follows a plan laid out by Microsoft and is even given access to code based on Microsoft’s determination is a big red flag. Now the 5% is very real. Microsoft is aware of this 5% because they see Java and they know what they want to put into dotnet. They get patents.
Later mono comes and implements. [part of Josh's reply, from what I skimmed, comes into play at this point I think .. I'll get to it in a different posting]
>> Given that one framework can run the other framework’s code without any work, it makes me think that there are few substantive differences in practice.
This is vague. I’m not sure if you mean that Java runs 100% of dotnet code through “Grasshopper” so as to include things like “LINQ”. If you would be filling in the gaps, that amounts to implementing the differences we spoke about above into the other platform. That would be copying. That could mean patent trouble.
Let me leave you with above, but get to some things Josh quoted (from the faq I think).
RyanT said,
November 24, 2008 at 11:51 am
“!No, no, no. They can have an agreement today and make an announcement later. This “today” can occur at any point.”
I’m sorry, but that’s the worst argument ever, and doesn’t change the fact that it’s only after that would happen that any definitively patented code.
You could use the exact same logic for any company, for any project. There is little genuine or logical base to this argument, other than something *might* happen *some* day at *some* point in the future. I’m sure once that happened however, distros would stop shipping it, no different than how they don’t try to ship anything that is definitively patent encroaching.
“Microsoft can get a patent ahead of mono implementation. They can’t get a patent ahead of Java implementation unless they get very lucky or Java copies significantly.”
Sun could put out a patent ahead of Java implementation. If Microsoft were to get a patent ahead of implementation, then what would happen? I refer you to what has been already posted above.
“For people who need full compatibility with the Windows platform, Mono’s strategy for dealing with any potential issues that might arise with ASP.NET, ADO.NET or Windows.Forms is: (1) work around the patent by using a different implementation technique that retains the API, but changes the mechanism; if that is not possible, we would (2) remove the pieces of code that were covered by those patents, and also (3) find prior art that would render the patent useless.”
RyanT said,
November 24, 2008 at 11:53 am
For the end of the first paragraph I meant to put “that any definitively patented code would make it in.”
AlexH said,
November 24, 2008 at 12:09 pm
@Jose: I agree with Ryan; if your point is that Novell might enter into an agreement in the future, sure, that’s possible. I doubt they will because of the GPL: they can’t have the license and the GPL.
As for the “parts” you talk about – I’m not sure talking about those numbers makes sense. You seem to be trying to dissect the two in terms of features and/or specification; but those aren’t the lines along which a patent would run.
Let me give you an example: let’s imagine there’s a patent on SSA methods in compilers (not that hard to imagine, sadly). Mono’s main compiler would hit that immediately: it uses SSA. But so does GCC, and mono’s mcs runtime is in the clear.
Onto my Grasshopper point: yes, my understanding is that it runs basically anything, including C# v3.5 features. I could be wrong, but the principle seems to be that there’s nothing in .net which Java cannot at least emulate.
Jose_X said,
November 24, 2008 at 12:20 pm
Josh, I wrote up a reply to you, but I realize I need to go back and check the logic in the section over getting around patents without breaking interfaces.
I also have to leave for a while, so maybe I’ll post at night (US east coast) or later on.
Jose_X said,
November 24, 2008 at 12:30 pm
Ryan, I don’t have time to reply much now.
>> I’m sorry, but that’s the worst argument ever, and doesn’t change the fact that it’s only after that would happen that any definitively patented code.
I don’t think you understand the argument, here. It has nothing to do with safety of mono. It’s a minor point over what Novell can do and what they need to say to the public. That is all. To disagree with me, means you don’t believe they can enter into a license agreement with Microsoft today.
A larger question is about Novell licensing at some point into the future. You were probably addressing that indirectly, except that I don’t really care too much if Novell has a license. It’s the mono threats and not the Novell license.
Now, you said other things about mono threats, but I have to go.
AlexH, that wasn’t my point quite right. I don’t care about Novell. I don’t expect them to in fact, at least not for a while. I don’t see how that affects mono.
Remember, I continue to maintain that a Novell license is not very interesting and would hurt it in most reasonable scenarios. They are fine without it. Microsoft won’t sue them (unless some sort of surprise maneuver, but that is something for Novell to worry about). My dispute was over something(s) Alex said specifically. I am willing to leave things as they are, and I think so is Alex.
Jose_X said,
November 24, 2008 at 12:32 pm
>> As for the “parts” you talk about – I’m not sure talking about those numbers…
Alex, I addressed the patent issue along the lines I was arguing for a reply to Josh, but I need to re-evaluate it. Will post at some time in the future I imagine.
Jose_X said,
November 24, 2008 at 12:47 pm
Alex, I did mention the future cases in some examples, eg, where a license might be conditional or something like that. That would not contradict what you said that they *don’t* have a patent.
One wider point I was trying to make is that Novell can hide things. They aren’t opening their books. Some things might be disclosed, but others could surface later. This happens all the time. Companies disclose very little.
To keep arguing repetitively over specifically a license of type X or Y is tiring to me to say the least and was on-topic now perhaps only a long while back.
A major conflict, call it what you want, is that many do not want to get close to Microsoft. There are many reasons for this and many ways in which you can “get close”. mono devs likely want their platform of choice to be adopted in the FOSS world, but they copied and copy Microsoft. Personally, I don’t want to help Microsoft by spreading technology whose dissemination gives them a number of advantages. This would hurt FOSS as a whole, and with it, users everywhere.
Josh Bell said,
November 24, 2008 at 12:49 pm
Jose,
No problem. I don’t know how much time I’ll have tonight to respond but will do my best.
Jose_X said,
November 25, 2008 at 5:14 pm
Guys, this may not be news for some, but I wanted to overview for everyone else what I think is a sureproof approach where Microsoft (or anyone else in a similar position) can use patents (if enforceable) to keep others from either (a) interoperating or (b) meeting std compliance.
I’m simultaneously replying to two prior comments.
http://boycottnovell.com/2008/11/22/protection-for-use-of-mono/#comment-39213
[Josh quoting mono faq] >> (1) work around the patent by using a different implementation technique that retains the API, but changes the mechanism; if that is not possible, we would (2) remove the pieces of code that were covered by those patents, and also (3) find prior art that would render the patent useless.
http://boycottnovell.com/2008/11/22/protection-for-use-of-mono/#comment-39217
[Alex] >> As for the “parts” you talk about – I’m not sure talking about those numbers makes sense. You seem to be trying to dissect the two in terms of features and/or specification; but those aren’t the lines along which a patent would run.
>> Let me give you an example: let’s imagine there’s a patent on SSA methods in compilers (not that hard to imagine, sadly). Mono’s main compiler would hit that immediately: it uses SSA. But so does GCC, and mono’s mcs runtime is in the clear.
Keep in mind I have very limited experience with patents. If Alex, Josh, or anyone else disagrees that the described approach is likely to lead to patents that successfully apply to third party dotnet implementations, I really want to hear the reasons.
***
For Microsoft, it’s really just a matter of (a) making sure dotnet (ooxml, etc) advances as they have planned ahead of time (so that matching patents were done in anticipation of the std); (b) attempting to protect semantics that have no prior art (they can just be *very* specific to reduce odds of prior art); (c) describing all semantic associations without goofing up (ie, to accurately match the standard or their implementation) and in a legally sturdy way; and (d) washing, rinsing, and repeating as often as resources allow in case any of the steps were executed with mistakes.
[Any part of msdotnet/std next-generation that might not have been seen in the wild, they can make into one or more claims.]
Take the following approach to write the patent: Describe the semantics of components of a dotnet system that anyone wishing interop or compliance would have to implement (ie, describe any mandatory parts of dotnet that relate tightly to the parts in the claims). Make claims where you describe the semantics of other components (the protected ones) that are also needed by the (dotnet) system being described in the patent. Make sure that semantics described throughout the patent match exactly what would be required for interop or for compliance. Express claims with the goal of avoiding prior art.
The net result is that no one trying to implement dotnet (msdotnet or the std components) can implement any of the protected parts. In particular, having built portions of such a dotnet system (the non-patentable/non-patented parts or the parts where you have a license) as described in the patents, you will then not be able to build the components described in the claims. The result of these missing components would be broken interop or failed compliance as the case may be.
Hypothetical example:
Compliance: “Compliant implementations must implement a foo class that uses a bar object to raise window object.”
Patent protection: “Claim 1: Within the [dotnet] system just describe, all visual windowy items [window objects] will be “raised” with barry objects [bars] via fooy objects [foo].” [Elsewhere in the patent, you describe foo, bar, window, raised, etc, based on semantic associations and properties that exactly match what is used in msdotnet or is specified in the standard.]
AlexH said,
November 25, 2008 at 5:58 pm
@Jose: patents aren’t written in those terms; they’re written entirely generically. So the hypothesis isn’t particularly realistic.
I’m not sure it matters, though. The Mono project won’t put .net compatibility as a higher priority than being patent-free: it can’t. So if such an example was found, it would be removed and some alternative found (e.g., Ogg vs. MP3). That would suck, but that’s not a Mono-specific problem: there is no functionality I can possibly conceive of that would be only of interest to .net users.
Jose_X said,
November 25, 2008 at 6:22 pm
>> patents aren’t written in those terms; they’re written entirely generically.
My understanding is that they can be written however the writer wants.
I’m thinking more carefully about what I just wrote. Yesterday, the idea seemed fine, but I’ve been busy since and haven’t allowed myself today to fully focus on it.
The other thing I want to mention is that *if* there are problems using the API “normally” (??), and *if* mono is particularly vulnerable (assuming a weakness exists with Microsoft writing narrow patents), then it would be *very* bad to have this spread because when the attacks surface, lots of applications and maybe very important software might need rewriting.. not to mention that those that added custom dependent software could be in trouble or facing real fees.
Let’s see if there is anything to this or if it is a false alarm.
Also, I suggested an approach that can be repeated to yield results. If it is bogus/flawed, there are always “real” patents, but unless some other common approach is found, these would not be minted and may not even put mono itself in danger I suppose.
…waiting for an “aha” or for an “oh-oh”.
AlexH said,
November 25, 2008 at 6:43 pm
@Jose: well, I would say first that no, you can’t write them how you please: certainly, a lawyer is never going to write it narrowly, but also that it’s not going to cover an API. It could mention APIs which embody the invention, but the invention cannot be an API.
If you really want to get into an in-depth discussion about what can and can’t go in, maybe head over to Gauss’s top 100 and see what’s actually being patented, and how.
Jose_X said,
November 25, 2008 at 6:57 pm
>> The core of the .NET Framework, and what has been patented by Microsoft falls under the ECMA/ISO submission.
This is from the faq Josh linked. I think it’s mis-worded, but not sure what they meant. I refuse to believe that the thousands of patents Microsoft files each year all apply/relate exclusively to the standardized portions of dotnet and to nothing else.
Does the faq need updating/fixing or am I misreading this sentence? Is there important context that was not quoted. .. Let me check. ..???
Jose_X said,
November 25, 2008 at 7:27 pm
Alex,
When I said you can write a patent as you like, I was referring to the patent application.
What is important to know for this example is why such and such is not likely to get a patent. Can you give more details besides “no” and a link to a set of patents that proves very little over whether X might be patentable.
I mean, I don’t think software should be patentable, but people have tried it and gotten a patent. Over time this has encouraged more.
The patent would purport to describe a process for accomplishing something, eg, provide X security feature for Y. The system for which we are providing security would be a “dotnet-ish” system [we would detail the properties of it to match dotnet]. The we would state the properties/semantics of various objects involved in providing the security feature. These objects semantics would match what was standardized for dotnet (or match msdotnet impl).
If you then write a program that links to mono (ie, so that the dotnet-ish context is fulfilled), then you can’t use the object described in the patent for X security feature.
To further the example, X security feature may be general (eg, some general auditing or intercepting mechanism done in the background when you initialize the object or the system). The objects providing it would be crucial to dotnet, at least if you want to be compliant or “interop” with msdotnet.
I wasn’t suggesting patenting an API. In an earlier draft not posted I specifically mentioned you couldn’t patent names (an API), but, in what I did post, I very specifically used words like “semantics” “properties” “attributes” etc, and said nothing about API.
If you build a class with the same names as the standard but you change the semantics to avoid patent violation, then you aren’t following the standard.
You may be able to get the same functionality through some other way;
HOWEVER…
The problem is when everyone uses the standard way (what mono provides) inside app after app after app after app in order to get X security feature. Later, you find out all of this coding inside apps violates a patent and a work-around must be sought. Well, that is fine and dandy, but … [you see where I am going, right? .. some call this FOSS poisoned.]
I’ll keep thinking about all of this.
Jose_X said,
November 25, 2008 at 7:42 pm
Random patent violations can always occur. I am harping on mono some because of what I still think are particular vulnerabilities that exist with mono because of the Microsoft factor (along the lines described in recent replies) and because “we” are mimicking “Microsoft’s protocols” so closely.
Most issues may simply prove unenforceable depending on how courts continue to rule on software patents. I think/hope courts might keep pushing sw out especially if we keep submitting well-reasoned friend of the court briefs (as Red Hat did for Bilski).
Jose_X said,
November 25, 2008 at 7:55 pm
Even if sw patents are no longer enforced by courts, future hw may be adapted closer to the software VM’s. If dotnet ends up being the most common, this is most likely to give particular economic advantage to Microsoft. If you want X dotnet app to run really efficiently (think mesa vs advanced graphic card), then pay Microsoft’s toll and/or buy chips (semiconductor modules, etc) from authorized MS dealers.
This would be further really bad news I am not interested in hearing. The Monopolist leverage and income would just keep growing and growing…. And free no-charge Linux will find it that much harder to be competitive with MS having this extra leverage with hardware.
Not good.
Roy Schestowitz said,
November 25, 2008 at 8:00 pm
There are the issues of: 1) cost (this may include patents); 2) quality (.NET for Windows is a first-class citizen); 3) control (leader vs. follower).
Microsoft was typically a folllower, whose reactionary behaviour you find in networking, the WWW (browser), hypervisors, office suites, GUIs and many other things like OO programming (.NET).
Don’t make Microsoft a late leader.
“He who controls the API…”
Jose_X said,
November 25, 2008 at 8:39 pm
In this thread, I am trying to stick to patent issues, but not exclusively. Let’s look at how patents interplay with the spread of MS-protocol-using apps on Linux.
The patent threats tie in with “addictions”/lock-in, for example, because as desire and abilities to write dotnet applications and demand for them increases, Microsoft’s applicable patent portfolio increases in value along with our costs (to find work-arounds). People will spread and want these apps that will violate MS patents.
If the violations can manifest themselves as explained in recent comments: simply through use of particular portions of the API, then, most likely, every piece of FOSS code using those API portions would have to be rewritten so that they simply are not used.
And owning a patent gives rights for injunction. I don’t know to what degree a court might force for reasonable royalties, but for FOSS, either way might lead to the same result.. we can’t keep it, but must change it.
Costs would certainly go up for FOSS contractors and other FOSS service providers, effectively putting Microsoft at the center in real ways, even when Linux is being used and only used with other software not related to Microsoft (except that the apps use the infringing parts of MS protocols/formats/etc).
“Dump Red Hat and use Ballnux and you get a patent license to use that wonderful dotnet GPL app you crave for 3 more years.”
Microsoft has a wide field at its disposal because dotnet is large, ooxml is large, etc.The potential for extensive damage is great.
***
In case it was overlooked above, I want to stress that part of the key for Microsoft to gain the patent inside track is that Microsoft know what will be standardized in dotnet, ooxml, etc ahead of time so that they can design the patents alongside the API and other features. They must have the patent before prior art exists.. and prior art of a very specific use/feature is not likely ..until the std comes out.
And to repeat: Having quality/attractive/etc dotnet apps means the MS protocols are extra likely to spread throughout Linux.. setting the table for Microsoft to start the attacks.
Jose_X said,
November 25, 2008 at 9:13 pm
What about actually getting a license from Microsoft? What portion of mono might be fully covered completely *without a doubt* for any use for anyone etc etc, and what parts might not. The faq Josh/Roy linked earlier describes this some. It seems current versions of “base” dotnet are covered… but is this fool-proof for all scenarios? Does everyone who has studied this issue basically agree (ie, besides those that wrote the faq)?
I did mention the hardware advantage and leverage over Linux that MS can enjoy some years from now, perhaps, if FOSS dotnet apps spread widely on Linux (eg, from hardware dotnet VM support), BUT, from strictly the software pov, if we have all the licenses from Microsoft that we would need, then there might not be a problem.. at least as far as patents go [?] [but see also http://boycottnovell.com/2008/11/25/jose-on-mono/ ]
How about for extensions where we don’t get licenses? Will people really only use mono basic?
To keep up with the Windows versions of these mono apps (that will use the extras), we would have to have a safe alternative for all the extras Microsoft would be building. Remember, though, that Microsoft controls future dotnet stds, so they have a real lead on us. Windows dotnet FOSS apps will likely always be ahead of the Linux counterparts.. at least if we don’t break away to use all our capabilities.
Jose_X said,
November 25, 2008 at 10:21 pm
Bilski may really limit patent threats. In any case, here is a quote from groklaw:
http://www.groklaw.net/article.php?story=20081102011538422
>> Sam Ramji gave us another big hint last year about what kind of patents Microsoft had in mind when threatening Linux in a talk at the 2007 Olliance Group’s Open Source Think Tank conference in California, at which Ramji was asked by a member of the audience about Microsoft’s patent threats against Linux…
>> ..Ramji replied by saying that Microsoft’s claims have to do with “cloned technologies”.
Josh Bell said,
November 25, 2008 at 10:51 pm
Jose,
I am not a lawyer and I’m not an expert on patents. I think you are making a mountain out of a molehill. You are coming up with scenarios that at this point are not being used and most likely will never be used in the way you describe. Your comment posts seem to be dealing in what if. What happens now in Linux if something is found, it is removed, re-done to make it right and to look for prior art. The same rule applies to Mono in regards to patents AFAICT.
What your posts and the article your wrote seem to focus on is all this stuff about Microsoft and how Microsoft is a big evil company that is looking to destroy Linux. I won’t deny that may be true and they speak badly about their competition. That being said since .NET apps are used by many companies having a FOSS equivalent I don’t believe is that bad of an idea.
AlexH said,
November 26, 2008 at 3:53 am
@Jose: I think you’re still construing patents as being able to cover “only .net” when that’s not how they work. If the functionality is desirable, anything that would have to be removed from Mono would also have to be removed from any other system which implemented that functionality.
So, as an example, if there was an API for MP3 playback, that semantic couldn’t be implemented in Mono. You could do a similar API for Ogg, though.
Second, you’re still very focussed on the Microsoft APIs. Remember, large sections of Mono are not based on those, and many of people’s favourite Mono apps don’t use them. In that area, any patent which came up would (99.999% certain) affect key free software.
Roy Schestowitz said,
November 26, 2008 at 3:54 am
Josh,
Running existing .NET applications is one thing; developing for GNU/Linux with .NET is entirely another.
Jose_X said,
November 26, 2008 at 12:39 pm
>> You are coming up with scenarios that at this point are not being used and most likely will never be used in the way you describe. Your comment posts seem to be dealing in what if.
Sorry. Proof of concept (and if the process is incorrect, please help clue me in) is very valuable. If a gun can be made, an army is unwise to ignore it and move forward only with swords against an enemy.
If the other side looks for anything they can [*lot's* of money at stake], explain to me why they would ignore such a direct method of constructing patents that would be sure to work with some high probability (ie, if they try to be careful and repeat ..see wash, rinse, repeat comment)?
I condition my statements because we don’t know. Sometimes I am sloppy, but, before you guys here, I am trying not to be too sloppy (or to clarify if I went too far). I don’t prove they are doing X competently. No one seems to be disproving they aren’t doing X competently (or at all). It’s about threat analysis.
I also want to help put perspective by bringing up Bilski and by bringing up that some amount of protection (patent license or promise or something from Microsoft) for some thing for some people exists. I’m not interested in upsetting people unnecessarily, which is bound to happen the greater their investments are in mono, but it’s foolhardy to ignore knowledge that can determine for many people if tomorrow ends up being problematic on account of actions pursued today.
It boils down to common sense, analysis of probabilities (even if loose), etc. See the first paragraph about swords and guns. You can’t avoid probabilities (I’m resorting to qualitative examples at the moment.. and there is too much I don’t know). Few things are sure in life. ETC.
One more example: how much sense would it make for Achilles to go into battle without guarding very well his heels if that secret vulnerability was common knowledge by the opponents? Sure, they might not attempt to attack him by the heels.
The root of mono’s weakness is that it is following Microsoft to the T. Microsoft is not Sun. The companies are different in many ways. The advantages Sun gains through use of Java is different than what Microsoft gains through use of dotnet. Microsoft’s strategy and money preservation relies on holding their own monopolies which implies elimination of competitors as the fundamental strategic priority. This business strategy has been the case for decades. Linux and FOSS running on Linux are very negative for Microsoft. It’s different for Sun. Also, we have to look at the resources and at the past executive decisions of these two companies. If people want to analyze the MS vs Sun factor, we can move towards that.
>> What happens now in Linux if something is found, it is removed, re-done to make it right and to look for prior art. The same rule applies to Mono in regards to patents AFAICT.
Random patents are different. It’s lower probability chance of hit, few are immune, there are few patterns, etc.
What we have here, instead, is an effective way to arrange so that mere uses of some objects/classes/methods would be violations.
I’ll review this in more detail again but in a separate comment as a reply to Alex.
>> That being said since .NET apps are used by many companies having a FOSS equivalent I don’t believe is that bad of an idea.
This is a nice general feel good opinion with which I strongly disagree for reasons that include what I have been stating on this thread (qualitative patent risk analysis) as well as through the summary that is this blog entry http://boycottnovell.com/2008/11/25/jose-on-mono/ .
>> What your posts and the article your wrote seem to focus on is all this stuff about Microsoft and how Microsoft is a big evil company that is looking to destroy Linux. I won’t deny that may be true and they speak badly about their competition.
My posts *absolutely are* about the high threat posed by Monopolysoft against the spread of no-charge, no restriction Linux+FOSS on the desktop.
Your summary that “they speak badly about their competition” falls so short of what I have reasons to believe is reality, but it does go hand-in-hand with the view Novell is pushing.
Jose_X said,
November 26, 2008 at 1:13 pm
>> I think you’re still construing patents as being able to cover “only .net” when that’s not how they work. If the functionality is desirable, anything that would have to be removed from Mono would also have to be removed from any other system which implemented that functionality.
The more precise the patent, the more likely there will be no prior art (Java could be prior art in many cases if Microsoft got too general).
An analogy in math would be to think of the dotnet standard (or MSdotnet if the issue is “interop”) as the limit point. The wider the area around the limit point is that you analyze (large delta), the greater that odds that the epsilon condition is not met (ie, that prior art exists). In the end, mono strives to match that limit point, and, to no surprise, that is where you have the least chance of discovering prior art.
Hence Microsoft can always play it safe and be conservative and specific so that the odds are high of there being no prior art yet of still trapping all the dotnet “clones” people.
You don’t want to be specific to maximize your coverage. Microsoft will attempt to ensnare Java implementations (this is a good point since we know Sun and Microsoft put together a much publicized patent deal); however, not at the cost of hitting prior art. When in doubt, they get specific. The result is that Java and others end up being left out, but mono, by definition, gets caught.
>> So, as an example, if there was an API for MP3 playback, that semantic couldn’t be implemented in Mono. You could do a similar API for Ogg, though.
See prior section.
The more the details diverge from dotnet, the more general Microsoft would have to have been in their patents, but this means the greater the chance there is of finding prior art.
Ogg always has to worry about patents from anyone, but dotnet (mono) is special because Microsoft can almost guarantee to avoid prior art by sticking closely to a standard that was unpublished at the time they drew up the patents. Ditto for OOXML.
A precise patent would miss out on ensnaring very many.. unless those many are coming directly to you.. to the spec you have drawn up.
[Sorry if I keep repeating myself in only slightly different ways.. I just realized this while proof-reading.]
Think of putting food on a trap that has very low coverage in space vs. leaving it without any attraction. If left alone (eg, a mine in the ocean or underground) there will be hits now and then but randomly and only proportional to the number of traps you set. If you add an attraction (a precise standard you encourage others to follow, a precise map you encourage others to follow), then you can end up with a very much larger number of hits. [Assume the mines, traps, etc, are reset after every hit.. yeah, broken analogy, I know.]
Another example would be the lights used to attract bugs into an electrified cage.
Microsoft can really increase the number of hits, even while being very very specific, if mono and other dotnet implementations are grown significantly. So a problem for them to solve becomes, “OK, how do we grow these significantly.”
Anyone controlling a standard can attempt this. We can analyze from this perspective if you people want.
>> Second, you’re still very focussed on the Microsoft APIs. Remember, large sections of Mono are not based on those, and many of people’s favourite Mono apps don’t use them.
This is true only/mostly to the extent that the core stuff is safe from patent attacks because of guarantees Microsoft has given.
The problem for Microsoft to solve would be, how do I get all of these only mono core apps to be extended into unsafe territory. This is much easier to get done if you have a bunch of people already hooked on a base dotnet implementation (core mono) and if you have a fork or orig version that gets extended to cover other areas.
Notice that mono is not today avoiding the extra areas. They are leaving these dangerous sections right there for anyone curious to start using and spreading. There is no big flashing red warning sign. For the moment, it’s a bit like a dangerous drug being left out on the corner of a table at a party.
And if mono stops moving in those directions, much work was done already (mono as it stands today) so that Microsoft can hire others to keep adding things (well, Novell *is* being hired today). Microsoft is leveraging the work done already.
Jose_X said,
November 26, 2008 at 1:32 pm
>> This is true only/mostly to the extent that the core stuff is safe from patent attacks because of guarantees Microsoft has given.
I forgot to add. I don’t know the details of the guarantees. I know this has been a controversial area.
There are too many ways for small changes in an covenant to be made to remove protections without appearing to do so. Their original covenant had problems of this nature.
To believe you are safe from MS patents when using core mono version X (never mind other related issues.. see http://boycottnovell.com/2008/11/25/jose-on-mono/ ), you must consider how much you trust Microsoft. Roy, has a groklaw page to which he links to give an idea of how much Microsoft should be trusted. People sign agreements all the time and then disagree to some extent and even go to court to have the matter settled. [Some even abuse the process to scare the smaller opponents.] People overlook loopholes all the time. People draw different interpretations from the same thing all the time. Most people and courts can be reasonable, but I don’t like to put my wits against Microsoft when it comes to legal loopholes. I trust the FSF and their explained goals. That is friendly territory. I don’t trust Microsoft. FUD can kill business. Will others agree with Microsoft’s interpretation of the dangers (and they keep selling that there are dangers) or will they believe me? Alex, you have said that Red Hat and some others accept mono from legal pov, so that does help in terms of convincing customers.. yet Red Hat can afford to be wrong and strike a patent deal for their paid offerings much easier than we can defend the totally free stuff.
I don’t see the reason to dabble with the MS-protocol-based mono when there are so many safer options that accomplish nearly the same thing. If I wanted mono-isms, I would fork it and have it develop independently of the standard or, if not independent of it, at least only work on new APIs likely not to be problematic; however, even this approach ignores the content of the link from the prior paragraph. It ignores that much work was and is being done to make it easy for dotnet-w-ms-api to spread on Linux.
Roy Schestowitz said,
November 26, 2008 at 1:41 pm
Microsoft has already stabbed Novell in the back.
Microsoft Betrays Novell; Novell’s Agenda Unchanged (Updated)
http://boycottnovell.com/2007/07/06/novell-on-microsoft-gplv3/
GPLv3 Cluebat Hits Microsoft, Which Has Just Entered the ”Denial” Stage of Its Agony (Updated)
http://boycottnovell.com/2007/07/05/microsoft-in-denial/
Will Microsoft Betray a ‘Partner’ Like Novell? Ask Cisco.
http://boycottnovell.com/2007/09/22/novell-cisco-similarity/
Jose_X said,
November 26, 2008 at 1:56 pm
I want to re-emphasize something
>> If people want to analyze the MS vs Sun factor, we can move towards that.
Sun has fewer resources, but the same thing I said about Microsoft does generally apply to Sun to the extent Java and dotnet are being standardized in the same anticipated fashion and these two companies follow a similar patent development strategy with intent to use those patents similarly.
Ignoring patents, Java is a major check on Microsoft dominance of home-brewed protocols.
Sun doesn’t have the same history of fighting as aggressively for dominance or against FOSS as does Microsoft. Today, Sun has much to gain by not being despised because they are smaller (room to grow) and don’t have monopolies to the same degree as does Microsoft. They also have FOSS-friendly business models better developed than do Microsoft. Microsoft has much to lose if they allow no-charge free Linux to encroach too much. Losing a monopoly means you possibly lost market share in terms of raw total units shipped, but it does definitely mean your price controls and other controls were (probably very) eroded. Simply, total revenues = units x price.
Jose_X said,
November 26, 2008 at 2:36 pm
>> Will Microsoft Betray a ‘Partner’ Like Novell? Ask Cisco.
Investor pressures force companies to consider at least the possibility of partnerships with Microsoft. Microsoft has some attractive assets that many might also like to leverage to help them fight or gain on their competitors. The nature and success of Microsoft’s business should be a red flag, however. Remember that Microsoft can usually gain from “your” market (and very possibly has ambitions to do so). Even if other CEOs see the potential threats or conflicts of interest, investor pressures sometimes are too great. [Past MS execs spreading means we might see more companies trying to partner with Microsoft despite the growing number of red flags.]
Microsoft’s basic problem is that they are too big, strong, savvy, amoral/immoral, etc, and in a way incompatible with …
… I’m very defensive of the ability for unrestricted Linux to be able to compete on a “level playing field” and to gain market share based mostly on its overall value proposition. End users before excessive profits. No charge, unrestricted Linux and other similar FOSS platforms enable the end user in ways that closed source can’t match. The raw materials for self-empowerment are included. People should not have to overcome obstacles erected through monopoly controls in order to be able to use Linux and/or test drive it.
[I used various fairly imprecisely-defined expressions, I know.]
AlexH said,
November 26, 2008 at 5:30 pm
Well, I think there are a number of differences here worth spelling out. Obviously, Sun and Microsoft apply for patents in roughly the same numbers (I think Sun is double or something), but the standardization is very different: Java hasn’t gone through a formal standardisation process.
I’m also slightly intrigued why you think that (for example) Mono is at more risk from Microsoft by copying some stuff they do (even ignoring the areas where Mono does something different, or is ahead of Microsoft): Microsoft have patents on Java too, you know. I have no doubt Sun have .net patents either.
Roy Schestowitz said,
November 26, 2008 at 5:32 pm
It doesn’t mean jack anymore. ECMA is corrupt and ISO is corruptible.
AlexH said,
November 26, 2008 at 5:45 pm
@Roy: there are more than those two orgs. W3C, WHATWG, OASIS, etc…. standards are still important.
Roy Schestowitz said,
November 26, 2008 at 5:51 pm
These bodies have no impact on .NET.
Remember that W3C is extremely careful about patents, whereas ISO is not.
AlexH said,
November 26, 2008 at 6:00 pm
Um, the comment was about the standardisation of Java, not .net.
Not sure why you think ISO isn’t careful about patents either.
Jose_X said,
November 27, 2008 at 7:05 pm
>> Obviously, Sun and Microsoft apply for patents in roughly the same numbers (I think Sun is double or something)
If this is the case, it hardly speaks to the subject of these patents or to the business plan of the respective companies, so I am not sure why you mention it. Ie, it doesn’t seem you followed up on this fact with some sort of hypothesis or analysis. Was this a FUD statement then?
>> the standardization is very different: Java hasn’t gone through a formal standardisation process.
What specifically are you suggesting is deficient about Java, if anything, by saying it had not gone through a “formal” standardization process?
Again, what is the implication intended, if any, in mentioning this point about standardization? I see no hypothesis suggested. Were you attempting to FUD?
Much FOSS (which I value more than “Java”, for example) hasn’t gone through a “formal” standardization process, either. What then would be the implication?
Java has had success without “formal” standardization. If it ain’t broke, don’t fix it.. and.. when it breaks, fix it.
The following two articles might be of interest as a starting point to someone that wants to pursue the standardization theme.
http://findarticles.com/p/articles/mi_m0EKF/is_28_45/ai_55190525 “Java’s Path to Standardization: Sun, Microsoft square off at ISO” 1999
http://sunsite.uakom.sk/sunworldonline/swol-04-1997/swol-04-java.html “Sun offers Java to ISO” 1997
One concern that crops up in them is about control.
In Microsoft’s case, they are much more powerful (levers over industry) than is Sun. There are real risks (eg, for Sun) in putting something out there that can be snatched from you by larger major competitors (Microsoft and IBM come to mind). Microsoft was able to conquer that threat recently in ISO. Some would even say they spent a lot of money, really tapped into their network of “partners”, and showed they are still willing to stoop to industry standard lows. Microsoft had a lot more riding on them getting OOXML through ISO than did/does Sun wrt Java.
>> I’m also slightly intrigued why you think that (for example) Mono is at more risk from Microsoft by copying some stuff they do (even ignoring the areas where Mono does something different, or is ahead of Microsoft): Microsoft have patents on Java too, you know. I have no doubt Sun have .net patents either.
I’m not sure I understand everything you are asking here, but let me try to answer.
I thought I was specific and clear in saying that a group controlling a standard (to X degree) is in a unique position to take out many patents, with a high probability of avoiding prior art, against the industry that will develop around that standard. We aren’t talking about random patents but about a process to ensnare all of those trying to implement the blueprint that is the standard that was designed alongside patents being developed around it by those with the inside scoop.
See also a recent BN blog entry about Rambus.
Jose_X said,
November 27, 2008 at 7:09 pm
Some misc comments…
***
Has Microsoft gone on record that patents are a key tool in dealing with the FOSS threat? Yes.
Does Microsoft have billions in revenue quarterly at stake? Yes they do.
Sun? No and no.
I don’t want to downplay a potential Sun threat, but, more importantly, I don’t want the Microsoft threat to be unjustifiably downplayed to a comparable level.
***
If it weren’t for the bad publicity and negative market reactions (and even then?), I would expect that someone trying to abuse the standards process might want to patent an approach to developing patents while simultaneously setting/controlling standards.
And this would be an excellent patent to take out to prevent anyone else from doing it (if it would hold, which I hope would not be the case). This could be a patent to help FOSS. Whoever takes it out would not really be able to use it (bad publicity), but, unfortunately, they might license it to others privately. [Maybe this has already been done.]
***
I hope http://www.parrot.org/ makes an impact.
Roy, just went to that site and it appears the BBC and ActiveState have very recently gotten close to parrot. Should we be worried or happy? [Presumably just happy]
Roy Schestowitz said,
November 27, 2008 at 7:22 pm
I request proof. Microsoft is patenting like a motor at the moment (some of the silliest of things too).
Roy Schestowitz said,
November 27, 2008 at 7:28 pm
Yes, I saw a press release about Parrot and the BBC at the time.
I’ve heard from people at the BBC that they hate their bosses with passion and the The Great Microsoft Staff Swap can’t help, can it? The BBC still uses a lot of Solaris, IIRC.
Jose_X said,
November 27, 2008 at 8:02 pm
>> > ..Sun and Microsoft apply for patents in roughly the same numbers..
>> I request proof. Microsoft is patenting like a motor at the moment (some of the silliest of things too).
Even if he is correct, Sun (unlike Microsoft, I’d expect) likely still deals heavily with patents closer to hardware than to software;
…however, I did find this foolishness:
http://news.cnet.com/Suns-Schwartz-guns-for-patent-glories/2100-1014_3-5390714.html “Sun’s Schwartz guns for patent glories” though it’s from 2004.
>> Schwartz in 2003 introduced a new subscription pricing plan for Sun’s Java Enterprise System server software collection, charging $100 per year per employee and letting the customer use as much of the software as desired. A 1,000-employee company would pay $100,000 per year.
>> “It’s his responsibility to shareholders to try to protect business ideas,” said RedMonk analyst James Governor. “You can’t blame him for trying. Amazon tried to patent one-click (Internet purchasing), and it worked.”
Roy Schestowitz said,
November 27, 2008 at 8:12 pm
They misspelled Redmond.
AlexH said,
November 28, 2008 at 3:00 am
I already posted the link the Gauss (the swpat db). As I said, the exact numbers don’t matter, but I don’t think it’s right to say that “Sun patents Java stuff, Microsoft patents .net” – if you look at something like this, it clearly applies to .net.
Also, I didn’t say anything about the standardisation was deficient – I just said it was different. Even Sun people want it to relax control over Java, but clearly the current strategies are very different.
Jose_X said,
November 28, 2008 at 11:58 am
Alex,
– of course they can cross, but those fall outside of the churn machine described.. unless Microsoft had accurate inside scoop to Java and Sun to dotnet which I assume (based on what I have read) is not the case or is at least inferior to what the main participant would have.
– this link appears to be to *top pending sw patents* http://gauss.ffii.org/Statistics/Pending/Applicant . I don’t know what is tracked here (such as per country or eu-wide or attempt to coalesce and remove dups ?) so some of these applications might overlap in subject matter. ??
AlexH said,
November 28, 2008 at 12:07 pm
The Gauss DB tracks Europe-wide patents; these are already “de-duped” against the national databases. Whether you want to look at pending vs. granted; eh – the numbers reflect different strategies as much as anything else, but they’re all roughly the same.
The “inside scoop” thing isn’t really necessary. Technology doesn’t drive technology; needs do. So over the last 10 years there have been tonnes of patents on structured documents. At the moment, people are patenting stuff to do with web services. Patents don’t cover just specific implementations, they cover everyone else’s too.
Going back to the example of Sun, the reason they needed a patent agreement with Microsoft was because the two orgs. had patented such vastly similar areas. I don’t see any reason to think that situation has changed.
Jose_X said,
November 28, 2008 at 3:34 pm
Surely the inside scoop is necessary for maximizing use of the patent churn machine described.
Let’s overview the basic process of tapping into the patents-built-alongside-a-standardized-specification churn machine:
– The more specific the patents are, the more likely these will avoid prior art.
However, you don’t want specific patents that avoid prior art but aren’t violated by anyone because they are too specific.. hence:
– When you know what everyone will do in the future but have not done yet (eg, because they will be trying to follow a standard whose details you know *ahead of time*), you can afford to be very specific (ie, as specific as necessary to avoid prior art) **and still ensnare a bunch of fish in your patent trap.**
Jose_X said,
November 28, 2008 at 5:51 pm
A quick example .. sort of..
Someone patents quicksort generally, ie, describes the main features.
You call xx.quicksort(..);
You violate the patent.
You re-implement quicksort (change the library call implementation, macro definition, etc). With this re-implementation, you probably don’t lose the key attributes of quicksort, and you avoid patent problems in all places/apps where quicksort is called. You don’t have to change on a per app basis the lines of code where quicksort appears.
Here quicksort was the end goal (ie, the patented process description), and the way you implemented it was the patented process details, later changed to achieve the same goal but in differing details so as not to violate the patent. You can still keep the quicksort abstraction (ie, the function call) and just change the implementation behinds the scenes.
The problem starts to come in when we have a set of abstract calls that all have complex semantic relationships and which are all patented as per those relationships (ie, patented to fulfill those semantics within a software system). In differing circumstances you would use a different subset of these in code. If you had a violation, you might not be able to simply replace these items 1-1 because you would have to change the semantics of each component, which already interact in complex ways, to avoid patent violations. Remember, too, that you need to preserve the behavior of the application and maybe even interfaces you created and made public.
Now some low-detail examples and analogies.
To return briefly to the quicksort example, imagine if the quicksort is composed of primitives, many of which have semantics that are generally useful for building other quicksorts but in creative ways and which are specifically covered within a patent that covers these primitives. If you use these generally useful primitives in other combinations to achieve creative “quicksorting”, then a patent violation still results. How do you easily undo this mess? You can’t easily undo it because each violating area was constructed differently, and, to avoid patent violation, you must change the semantics of each individual item.
Another example. Say you have a 3D cube that is like a block puzzle. Think of this big cube as being a 10x10x10 structure composed of pieces that fill in some portion of that cube: each subpiece spans a contiguous section of the cube in quata that are 1x1x1. Together, all the subcomponents form the cube. Say that these subcomponents are intended to build more 3D structures. Now, say someone patents the “creation of such 3D shapes [ie, the creation of a cube or any other shape] when using this precise set of subcomponents [ie, that make up this 10x10x10 cube]“. Now, say that you used those subcomponents in building many types of 3D structures. You also used different subcomponents (other contiguous groups of 1x1x1). After you find out about the patent, you find that you have to replace every single subcomponent that came from that patent of the 10x10x10 cube model. The problem is that you can’t replace any of those subpieces with something that looks different without changing nearby safe subcomponents. You must go through on a per case basis to make adjustments. You can’t find a simple mapping that can be applied to fix all of your 3D buildings.
[Note that the patent writer avoids prior art by patenting very specific odd shapes. Naturally, if you knew there was a patent, you would not have built so many buildings with these particular set of components.]
Another example along the lines of the last one. You build tetris models, ie, you build art that is composed of tetris pieces. However, you use not just the standard tetris blocks, but many other shapes. You then find out that the tetris blocks cannot be used. Fixing all your artwork internally so that it looks the same externally will not be a simple direct task in all likelihood. [Assume that the pieces must fit snuggly.]
Can these puzzle pieces be patented? And aren’t we talking about software? Well, I think that these puzzle analogies have relation to the patent software problem partially described in earlier comments on this thread. In the case of the 1x1x1 blocks, “the process patented would be of building 3D structures such that one includes the following pieces, x, y, z,….” I think this statement can be translated directly to software. You would be describing the semantics of the pieces, not their literal representation. In other words, one would describe the semantics of function/method/procedure parts, not their literal names.
I will try to see if I can come up with an easy and specific software example to demonstrate this hypothesis being considered: describe the semantic chunks precisely, give the patent wording, and give samples of code where it would appear a human would be needed to fix the problem.. Of course, when building this example, I don’t expect to attempt to “prove” that you can’t find a mapping from this particular example violation into non-violating code for all cases ever possible; however, perhaps the example code snippets and patent definition would suggest that such a mapping might not be possible or else take long to derive. In other words, hopefully it will be clear that you can’t pull out the tetris pieces and replace them with distinct pieces except, generally, by doing extra work for every piece removed.
Anyway, so how do we then get around this if we can’t do simple 1-1 or other types of well-defined (well-understood) mappings (ie, mappings independent of the surrounding app code context that would not require human thought to unravel properly)? We do it the long way. We have to recode apps on a per app basis, at least in the general case.
AlexH said,
November 28, 2008 at 7:06 pm
@Jose: I still think that it would be worth you examining how patent application actually works. For example:
That’s not really true at all: in fact, the broader it is, the more likely it is to avoid prior art. The reason for that is that patents are split out into multiple claims, and not all claims need to stand for the patent to be effective: so in fact, they are drawn as broadly as the applicator thinks they can get away with.
Your point about quicksort() I didn’t quite understand. You seem to be saying that APIs are generally unpatentable (e.g., quicksort() could actually be bubblesort() underneath) – in that instance, I agree, but that seems to contradict your earlier argument.
Jose_X said,
November 28, 2008 at 8:00 pm
The original comment http://boycottnovell.com/2008/11/22/protection-for-use-of-mono/#comment-39291 suggested what would be a straightforward approach to force breaking standards compliance or interop.
The last reply listed various examples (eg, tetris) suggesting additionally that complex semantic relationships would need to exist; however, this would be so that besides breaking compliance or interop it would be complicated to fix the violations.
I’ll try to get some software examples later. Without a clear logical argument (maybe requiring concrete examples/ proof of concepts), it’s tough to be sure of not making a mistake and to remove doubt. Maybe we can get close.
Jose_X said,
November 28, 2008 at 8:06 pm
>> > The more specific the patents are, the more likely these will avoid prior art
>> That’s not really true at all: in fact, the broader it is, the more likely it is to avoid prior art.
Make a kaboo by spinning on your head 3454525 times exactly.
vs
Make a kaboo by spinning on your head at least one time.
The more specific is the first. The one most likely to have prior art is the more general one, the second.
Did you submit the reply too quickly or do you mean something else?
Jose_X said,
November 28, 2008 at 8:21 pm
>> ..not all claims need to stand for the patent to be effective:
An example that I think demonstrates claims (as I understand it):
Consider a single patent with two claims vs. two patents each with a single claim.
Patent 1:
To do a gurfa,
claim 1: the first step must have tunde
claim 2: the last step must be done with sery
The patent above is equivalent to two patents each with a single claim.
Patent 1:
claim 1: To do a gurfa, the first step must have tunde
Patent 2:
claim 1: To do a gurfa, the last step must be done with sery
So the first case is a short-cut to avoid writing a single patent for every single claim. Logically, each claim stands by itself as the example shows.
Jose_X said,
November 28, 2008 at 8:59 pm
>> You seem to be saying that APIs are generally unpatentable (e.g., quicksort() could actually be bubblesort() underneath) – in that instance, I agree, but that seems to contradict your earlier argument.
A patent says in part, “.. in order to achieve X, the list is presented to the user after…
– quicksort has been applied
– …”
Also, “quicksort” is defined somewhere in the patent.
Now, there may be prior art or maybe this patent is obvious. But let’s assume this isn’t the case. Then:
If you achieve X in your app, then that list (the list is presumably related to X) cannot have quicksort applied or else you violate this patent.
You can’t xx.quicksort perhaps nor even do the equivalent of quicksort.
However, if you do a bubblesort or any sort that is not as described in the patent under “quicksort”, then you are OK.
Thus a simple fix seems to be to just change the implementation of quicksort in the library and have applications relink (not a prob for dynamic linking). *No app code has to be looked at* [assuming your new quicksort has similar characteristics.. however, there may be the odd app that assumes too much about the old quicksort and that app may break].
The API is not patented. And using the call “quicksort()” within applications can be fixed automatically by reworking the quicksort library.
Contrast this quicksort example just given to the quicksort example given earlier that depended on primitives.
The patent put in play for this second case might simply be about how to use these primitive functions to create new quicksorts.
This time, the relevant API are of these primitives useful for creating new quicksort variations. If we take and scatter these primitive function calls within applications in order to create useful new quicksorts, we’ll have to (in general) change all these apps later on when we find out they violate the patent. There is no quick fix of changing the implementation of these primitives within the library because each application can intermix them differently. [In reality, we'd have to analyze the specifics, but it's believable, I think, that the more items involved and the more complex the semantics, the less chance of a 1-1 replacement mapping existing that avoids the patent violation and simultaneously doesn't break any apps after relinking]
In this case no API is patented either, BUT, effectively, we get screwed if we used those API according to the standard. It’s not that the API are patented, but the functionality achieved through those calls when used according to the standard (which is how we will use them and implement them, of course) result automatically in patent violations. The patents were designed with the standard in hand to catch people (except that this was done before the standard was finalized to avoid prior art).
Jose_X said,
November 28, 2008 at 9:07 pm
Also note that sorting is pretty general, but if we deal with API/semantics that are very particular or out of the ordinary (ie, place the glass window within the door frame while touching your nose and jumping), then prior art avoidance can almost be guaranteed. The patent and API writer might not need to resort to odd API semantics, but I simply mentioned that they can always move in that direction if they want to lower the probability of prior art existing, in which case, they can patent things that might not seem too brilliant but were done in a very unusual way no one else chose to do.
This point about precision/oddity is to show that even the common can be patented if made uncommon enough. This is useful to help increase the number of patent claims that can be made by a force of monkeys typing all through the night. And you guarantee others begin to use such uncommon methods if you enshrine them in a standard.
This contrasts with an actually clever patent that really has no prior art and is likely to be more general and cover more types of software. There are fewer of this last type. They aren’t churned. They don’t depend on a Trojan Standard to trap their fish. It’s this last type that people say “we’ll just work around it when the problem comes.”
Jose_X said,
November 28, 2008 at 9:26 pm
I am trying to feel my way around what sorts of potential manipulations might be done when on has anticipated knowledge of a standard. I think the top reply (the one starting with “Guys”) is probably mostly correct, but from there down the assumptions shift around a bit from reply to reply as I try to define things more carefully and understand them myself. For this reason, I would expect that over time the more recent replies would be more accurate than the earlier ones.
Maybe someone can figure out what is going on here and write up a more detailed example using pseudo-code before I get to it. Showing a flaw in thinking/assumptions or else showing a proof-of-concept would be very useful.
AlexH said,
November 29, 2008 at 3:52 am
@Jose: rather than fishing around attempting to make your idea work, is there some actual example you could show where an API could not be implemented because of a patent?
Jose_X said,
November 29, 2008 at 9:04 am
Taking the sample I expect I might write up one step further, maybe I will just write a patent to cover some small part of dotnet. There will probably be prior art since I’d be working after mono was built, but I can’t get any closer to the real thing since I wasn’t in on the planning of dotnet prior to it being standardized.
Now, with as little experience as I have with dotnet specifically and with patents, where do I start? Hmmm.
PS: Not being a lawyer nor having written a patent before, I hope whatever I come up with be recognized properly for what it would demonstrate rather than criticized for having i’s not dotted.
PS2: A person who dislikes this whole patent thing and dislikes dotnet and has tasks and a job to keep him plenty entertained doesn’t just decide to write up a patent to prove a point on a forum. Put differently, I’ll try to prod myself to go through with this to some degree.
PS3: I almost can’t believe you would not recognize the problem here without having someone point to a patent and a violation. If I were that far off, I can’t imagine you not recognizing that and finding a problem. Anyway, let’s see if I can work on this seriously this week.
Roy Schestowitz said,
November 29, 2008 at 9:35 am
Patents are not the sole issue. With control (Mono/.NET), however, GNU/Linux can be steered towards other patent milefields.
AlexH said,
November 29, 2008 at 9:35 am
@Jose:
No, that’s not my point. I’ve told you a number of times that you’re hypothesising about writing patents in a way which doesn’t match how they’re actually applied for. I’ve tried to explain why but I haven’t succeeded.
What I’m asking for is an example of the type of patent you’re talking about: any type, not against .net. My position is still that you cannot patent API.
Jose_X said,
November 29, 2008 at 10:51 am
I looked at a few patents. Here are some notes:
– The main section are the claims. Industry jargon is used for the most part but generalized somewhat so that in some cases you could be referring to software, a network system, a machine, an institution of humans, etc, all with the same language in one shot. Claims are to the point.. as if you were speaking to someone who had knowledge of your work and then had to state succinctly what you are inventing that is new. There is some effort to use language that would suggest machines and other language from USC Title 35.
– Claims break down with an organization so that if anyone happens to have implemented some subset of your overall “invention”, you can still gain credit for every new part you added. The result looks like a Christmas tree with the the main tree described as claim #1 and then extra ornaments added per claim thereafter.
– After the claims come the description. Here I guess you help clarify what the terms mean, discuss possible implementations, give background, etc. [I didn't look at these sections too much.]
Not sure what topic I will hit first. I think I might start by describing somewhat generally, but some claims will get down to software terms. I’ll start with English description. Then I will pick out what I think might be the claims (and clean up the language). Then I will do the description from what is left. I’ll even try to keep Bilski in mind (machine or transformation), but not that much..
This is a rough outline for writing up the “patent”. I’ll leverage some of what I have written on this thread.
I may hit dotnet in one example, and in another I may attempt the sort-primitives example.
As for violating source code, I may use pseudo-code or actually pick a language (Java, C, javascript..?).
Not sure how much dotnet or C# I want to stomach… but, since I might have to, does anyone know where the online docs are for say Winforms or Asp.net? Also a link to some core dotnet specs (API) and/or C# would be useful.
I’ll even make an attempt to cover dotnet while skipping over everything else in the world, namely, while skipping over Java. Some claims may cover Java or not, but I’ll make sure that some claims are very specific so as to not have had prior art if this patent were written before dotnet came out officially.
For reference, here are the 3 patents I super-skimmed:
7,117,214 http://www.patentstorm.us/patents/7117214/fulltext.html
7,458,090 http://www.patentstorm.us/patents/7458090/fulltext.html
7,458,079 http://www.patentstorm.us/patents/7458079/fulltext.html
Jose_X said,
November 29, 2008 at 11:12 am
possible outline for sort example…
creative/generalized sort:
–picker
–comparer
–placer
–overall alg controlling 3 top prims
define API semantics and also literal names for coding purposes.
make sample of bubblesort
analyze a bit to see if sounds legit
code up various examples in javascript
prove/show code examples violate patent.
of course, write patent.
AlexH said,
November 29, 2008 at 12:19 pm
@Jose: before you do too much, what are you actually trying to achieve? Writing a patent draft that we disagree would ever be acceptable isn’t going to resolve anything.
All I was looking for was an example of a granted patent covering a specific API. I’ve never heard of such a thing.
Jose_X said,
November 29, 2008 at 12:38 pm
The patent is not meant to be of an API, but an API can be an implementation covered by patent claims.. meaning, **if you use part of the API, you would violate a claim.**
In order to avoid prior art, the patent can become more specific in detail arbitrarily approaching the API.
If you use the API, as the API is intended to be used, you would be violating one or more claims of the patent. Semantics of the API implement one or more of the patent claims.
This issue is special because writing any old patent is not going to approach an API in all likelihood unless you design the patent with the API in mind. However, if an API exists, prior art exists; hence, you’d have to write the patent before the API exists but knowledgeable of such an API.
Make sense?
Jose_X said,
November 29, 2008 at 12:56 pm
Do you believe that calling foo() could ever be a patent violation for some foo and some patent? Eg, foo does something described in a patent claim.
If you do, then you are stuck in the sense that you can no longer adhere to the documented semantics for foo without violating the claim.
Now, how do you fix all the lines of code where foo was already used? If you change the semantics of foo’s implementation, the apps could break. If you don’t change it, you are in violation?
Changing some types of semantic information may not matter in practice, but in other cases it certainly can matter. Eg, implementing a bubblesort behind quicksort would violate the defined semantics. In this case, the application may not suffer, but in other cases it may. Generally, the type of sort should not matter, but other functions besides sort methods can prove problematic. I want to give a clear example where being forced to change semantics to something outside of a violated claim would break applications.
AlexH said,
November 29, 2008 at 12:56 pm
@Jose: well, it makes sense in so far as I understand what you’re saying, but it still doesn’t make practical sense: a patent cannot cover an API.
If it was possible, somebody would have done it by now. But there is no such example. Patent law just doesn’t cover specific embodiments: it covers methods of doing things. An API is just a group of words. They’re totally different.
Jose_X said,
November 29, 2008 at 1:06 pm
>> An API is just a group of words.
Not at all. An API implies some semantics.
Why are you even saying the foo example makes sense?
BTW, anyone now the cost for submitting a patent? [I'm assuming bypassing attorneys is allowable. Also, ignore research costs, etc.]
Jose_X said,
November 29, 2008 at 1:08 pm
>> Patent law just doesn’t cover specific embodiments: it covers methods of doing things.
Can you clarify what you mean (ie, shed light on the grayness)?
Jo Shields said,
November 29, 2008 at 1:16 pm
You can’t patent “doing foo”, you can only patent “doing foo by bar baz boz”.
You can’t patent “foosort();” you can patent “foosort(); by using this algorith” – and even that’s pretty tenuous
Jose_X said,
November 29, 2008 at 1:20 pm
yes, patent the quicksort algorithm as claim 1 of patent 3333333333
create a library call named qsort which implements the quicksort algorithm as per above claim.
Jose_X said,
November 29, 2008 at 1:25 pm
..or take some patent, then write functions that implement the claims.
How frequently in the FOSS world do people have to go back and design around patents after they have written code? I’m sure there are real costs. What if instead of this simply affecting some obscure algorithm once every blue moon, the patents get pressed against common API?
Which API might be most vulnerable?
AlexH said,
November 29, 2008 at 1:27 pm
I think you’re confusing “what an API is” with “why you use an API”. Semantics aren’t part of an API.
In terms of what patents cover and what they cost, there is a lot better information out there via Google than I could supply here.
Jo Shields said,
November 29, 2008 at 1:28 pm
No, sorry, that’s where it falls down.
An API means predicted data in, predicted data out. Nobody says your qsort() needs to use a patent-infringing implementation internally. It doesn’t even necessarily need to implement a quicksort, as long as it gives the same data
Do you really think MS have patented, say, using Gnome Data Access 2.0 (as Mono’s ADO.NET implementation does), for example? The point AlexH has been trying time and time again to make is that an API itself can’t infringe a patent – only a specific method application – and that specific method can easily not be what was originally planned as a “patent trap”
Jose_X said,
November 29, 2008 at 1:34 pm
>> I think you’re confusing “what an API is” with “why you use an API”. Semantics aren’t part of an API.
wikipedia disagrees: http://en.wikipedia.org/wiki/API
>> The software that provides the functionality described by an API is said to be an implementation of the API. The API itself is abstract, in that it specifies an interface and the behavior of the identifiers specified in that interface; it does not specify how the behavior may be implemented.
Did you get that? “interface and ..behavior”.
Also, if I had been wrong, I’d just change terminology because the fact remains that a function comes with associated API. You can’t separate the two and have something meaningful.
But, I don’t have to worry about changing terminology since wikipedia appears to agree with my usage of API.
AlexH said,
November 29, 2008 at 1:45 pm
Ok, we need to be clear about whether you’re talking about “what the code is doing” when you mean semantic.
An API includes a very weak semantic that gives you an idea of what the function does. But it doesn’t give you any idea of the actual semantics of the function: it’s not telling you what the code is actually doing, just what the results are.
A patent is the complete opposite. It says “here is a way of solving this problem” – in other words, I know what results I want, I just don’t know how to do it.
Jose_X said,
November 29, 2008 at 1:45 pm
>> Nobody says your qsort() needs to use a patent-infringing implementation internally.
The hypothetical patented quicksort algorithm can be described at a (high) level that would cover “quicksort” as defined in textbooks, assuming of course that such a thing as “quicksort” has been defined universally. Thus you couldn’t change the implementation to something non-infringing without implementing something else.
Alright, let me check wikipedia…
From wikipedia: http://en.wikipedia.org/wiki/Quicksort
>> Quicksort sorts by employing a divide and conquer strategy to divide a list into two sub-lists.
>> The steps are:
1. Pick an element, called a pivot, from the list.
2. Reorder the list so that all elements which are less than the pivot come before the pivot and so that all elements greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final position. This is called the partition operation.
3. Recursively sort the sub-list of lesser elements and the sub-list of greater elements.
>> The base case of the recursion are lists of size zero or one, which are always sorted.
So however you implement quicksort (and wikipedia does give a pseudocode example which follows these steps quoted), you would have to implement this algorithm or else you would not be implementing quicksort. Thus if this algorithm (these very steps as described on wikipedia) were patented, you could not implement quicksort.
You could implement some other sort with good average case running time, but it would not be as per this process here described.
Now, I already said that quicksort is not a good example because alternative sorts would still yield suitable results in just about all cases. But we can find many other API such that changing semantics would break apps.. or do you people not think so?
Jo Shields said,
November 29, 2008 at 1:49 pm
No, we don’t.
Look up the Freetype case for working around an aggressive patent through reworked internal semantics.
Jose_X said,
November 29, 2008 at 2:01 pm
Alex, an API’s semantic can be “weak” or not. An API can specify that other objects be affected in X or Y fashion, that certain other objects must remain constant, that certain objects need be changed as a side effect and even specify the desired result very precisely.
An API can be of something like computing the date (output: year, month, day) from an integer representing the number of seconds since some epoch. That has very precise semantics. Those semantics do not describe an algorithm, as you stated; however, any algorithm that implements this functionality will violate a patent that stated that we have a framework and within that framework, the year, month, and day will be calculated from the number of seconds since some chosen epoch.
This patent does not specify how to perform that calculation. That patent covers a wider scope and this date function is a part of it. If you rely on a particular framework (eg, some subset of dotnet) that is described by that patent and you calculate the date accordingly, you are in violation.
A patent that simply says “year, month, and day are calculated from seconds such that year, date, and month are that many seconds from Jan 1, midnight….” likely would have tons of prior art; however, a patent with larger scope can leave the smaller details undefined and overall have these claims (which include extra context) have no prior art.
Are you people saying that all patents specify all potential algorithms coverable within to full detail? Of course, not. There are varying levels of detail that different patents get into wrt it’s various components…or so that is the impression I have gotten. Are there disagreements?
Jose_X said,
November 29, 2008 at 2:03 pm
>> The point AlexH has been trying time and time again to make is that an API itself can’t infringe a patent – only a specific method application – and that specific method can easily not be what was originally planned as a “patent trap”
I skipped this section because I didn’t understand what you meant. Can you clarify (so I can respond properly)?
AlexH said,
November 29, 2008 at 2:05 pm
@Jose: I think we’ve found the fundamental problem:
It doesn’t matter the scope of the overall patent. If it doesn’t specify how to do something, that “something” – whatever it is – isn’t covered by the patent. That’s point A.
Point B: even if it does specify how to do it, that also doesn’t mean for sure that the specific implementation it mentions is covered. Take the de facto example, the patent on a rubber-curing process. Individual parts weren’t novel; the collective was.
Jose_X said,
November 29, 2008 at 2:28 pm
Alex,
wrt point A..
A patent can say that to provide “a certain type of result to users”, you take these 3 steps.
Step one is to “convert seconds since epoch into year, mo, day so that” …(vague description here without actual algorithm but very precise semantics of end result).
Step two ….
Now, if you “provide a certain type of result to users” and to carry that out you “convert seconds since epoch into year, mo, day so that” along with the other 2 steps then you are in violation.
The “algorithm” violated was the larger level one that didn’t specify in full detail how to do the date conversion [this is related to your point B].
Now, how do I link this to what I am talking about?
When you use a particular API, it might be common use to carry out these three steps. There might even be three such functions that people will use whenever they want to “provide a certain type of result to users”.
This is related to why I mentioned the sort example based on primitives. If you use that API, you will likely use all the 3 components, and these could violate a patent at that higher level (to build a sort).
In OOP, this can boil to 3 method calls perhaps.
In fact, instantiating an object, by default, might already carry out all of the steps for you but one, so that you would be in violation by calling that one method to do date conversion (at least if you didn’t change the defaults).
This is why early in this thread I was referring to “security feature X”. There is a higher level alg that is being violated. If you use these API as intended, you will likely violate such a patent that implements security feature X in such and such a way (to match the semantics for the API).
And do note that we don’t need more than one function call, eg…
Remember the general but explicit steps in the patent can be implemented behind the scenes by a single function call as per the semantics of that function call.. eg, update some other object and do X or Y other thing as side effects. ..Now if you violate a patent that does all of these side effects, you are screwed.
So when we define (high level) semantics for a function, those semantics can be violations of a patent claim that patents those semantics. [And if we change the semantics to avoid violation, we break the app in the general case.]
Look at this patent, claim number 1 http://patft.uspto.gov/netacgi/nph-Parser?Sect1=PTO2&Sect2=HITOFF&p=1&u=%2Fnetahtml%2FPTO%2Fsearch-bool.html&r=29&f=G&l=50&co1=AND&d=PALL&s1=software&OS=software&RS=software
It is vague, yet it does specify something. In fact, all the claims (as I see as I skim) are vague in many ways. Yet this was granted a patent.
You don’t have to be precise to the last drop by any means.
You can match (high-level) semantics of a function so that these satisfy at least one claim from a patent. … see that patent link above. It is vague in many ways.
Jose_X said,
November 29, 2008 at 3:08 pm
I’m going to take a break and go offline soon. Maybe I’ll work on this further at some point since a specific sample patent draft is easier to critique and compare with other patents.
AlexH said,
November 29, 2008 at 3:20 pm
@Jose: you have to be specific about what you’re claiming.
An API is an abstraction, and as such cannot be patented. There’s nothing novel or interesting in an object method call or a function.