Slashdot Mirror
Microsoft Puts C# and the CLI Under "Community Promise"
FishWithAHammer writes "Peter Galli of Microsoft posted a blog entry on Port25 today, regarding the explicit placement of C# and the Common Language Infrastructure (the ECMA standard that underpins .NET) under their Community Promise: 'It is important to note that, under the Community Promise, anyone can freely implement these specifications with their technology, code, and solutions. You do not need to sign a license agreement, or otherwise communicate to Microsoft how you will implement the specifications. ... Under the Community Promise, Microsoft provides assurance that it will not assert its Necessary Claims against anyone who makes, uses, sells, offers for sale, imports, or distributes any Covered Implementation under any type of development or distribution model, including open-source licensing models such as the LGPL or GPL.'"
Adds reader anshulajain: "Understandably, Miguel De Icaza is jumping with joy."
"The Community Promise is an excellent vehicle and, in this situation, ensures the best balance of interoperability and flexibility for developers," Scott Guthrie, the Corporate Vice President for the .Net Developer Platform, told me July 6.
Ok, I certainly hope he received more than just that before he began proclaiming to the world that Microsoft is doing such a thing.
The optimist in me is excited. The skeptical in me is dubious, confused and does not trust blogs. It's not listed on Microsoft's list of products under the Community Promise so I'm going to refrain from breaking out the champagne until all the facts are finalized.
Anyone else got a better source for this than a loosely affiliated blog that bills itself as "Communication from the Open Source Community at Microsoft" ?
My work here is dung.
they must be up to no good.
If you mod me down, I will become more powerful than you can imagine....
Microsoft love us and want us to be happy :-)
echo -e 'global _start\n _start:\n mov eax, 2\n int 80h\n jmp _start' > a.asm; nasm a.asm -f elf; ld a.o -o a;
The 'community promise' does not extend to commercial downstream recipients of open source MONO applications !
It sounds promising, and it may end up meaning Stallman was wrong all along and that it was safe to implement .Net/C# (which GNU have done anyway). It's be useful to have somewhere slightly more authoritative to hear it from (like Microsoft themselves) but at least people don't need to worry about "arrrghh, it's a patent trap" and can get on with "hurrah! I can focus on coding for the desktop in a decent language rather than having low-level memory concerns etc".
Not that I ever cared anyway. Stick to the registered standard definition of C# and Microsoft couldn't exactly kill off Mono anyway, as they'd probably have ended up breaching the "fair and non-discriminatory" part of the patent licensing or been forced to give Mono a free license anyway.
Now Microsoft is estopped from going after people using c# and .net technologies.
This is the answer I've wanted from Miguel ever since the Novell brouhaha.
Promissory estoppel serves as a "consideration substitute" in contract law that renders certain promises otherwise lacking in consideration binding and enforceable. In such cases, the promisee's reliance is treated as an independent and sufficient basis for enforcing the promise. Promissory estoppel can be viewed as a legal device that prohibits the promissor from denying the existence of a contract for lack of consideration.
http://www.lawnix.com/cases/promissory-estoppel.html
Okay, first off - I'm a Linux user. I love FOSS. I'm also a realist - i put my trust in that my staff will be able to write C# apps in Wintendo that will function. I expect in the near future that portions may be converted over to mono so that we may host items on Linux servers:
http://www.perfectreign.com/stuff/2009/20090312_secure_submitter.jpg
http://www.perfectreign.com/stuff/2008/20080912_JEDI_Vitals_Screen.png
http://www.perfectreign.com/stuff/2008/20081205_ie6_yoda_ii_ponte.jpg
My question is this - does MS moving to a new license change my current licensing? How does it interact with those running SLES or Virtualized Windows 2008 under XEN?
The Kai's Semi-Updated Website Thingy
"Q: Is this Community Promise legally binding on Microsoft and will it be available in the future to me and to others?
.NET but not covered by the standard (like Winforms)
A: Yes, the CP is legally binding upon Microsoft. The CP is a unilateral promise from Microsoft and in these circumstances unilateral promises may be enforced against the party making such a promise. Because the CP states that the promise is irrevocable, it may not be withdrawn by Microsoft. The CP is, and will be, available to everyone now and in the future for the specifications to which it applies. As stated in the CP, the only time Microsoft can withdraw its promise against a specific person or company for a specific Covered Specification is if that person or company brings (or voluntarily participates in) a patent infringement lawsuit against Microsoft regarding Microsoft's implementation of the same Covered Specification. This type of "suspension" clause is common industry practice."
tl;dr they can't sue you, ever, unless you sue them over patents.
Also, Mono contains
1) parts that are covered by the ECMA standard (C# and the CLI)
2) original namespaces (like Mono.Simd)
3) open-sourced Microsoft stuff (like ASP.NET, under the OSI-approved MS-PL license)
4) parts that are in
which is why Miguel de Icaza says they'll be splitting their distribution up into now definitely safe (1 and 2) and potentially dodgy (3 and 4) packages, which is what already happens on Ubuntu for instance.
Why do people think C# is some new amazing language? Clearly MS took Java and gave it a MS framework.
If you would just use java you probably wouldn't have this fear of MS trying to undermine the OSS movement. When a multi-billion dollar company other than google tries to "help" OSS, you can only be suspicious.
http://www.javacamp.org/javavscsharp/getStarted.html
Here's why:
There is no mention of other components the extend .NET!
From the document...
"...We introduce instructions newdata, lddata, stdata, castdata, isdata and
switchdata to create and manipulate classunion values..." (emphasis mine).
In fact, this announcement is not much different compared to the one 7 years ago!
Watch out folks. Microsoft's classic Embrace, Extend, Extinguish paradigm is very possible here.
From the Microsoft Community Promise, with my emphasis:
Free software is often distributed to the public while in an incomplete state. This Community Promise appears not to apply to such an implementation that is published before it is completely compliant.
Maybe you pro-Mono FUDites should read what they are really promising. It only covers the core language and run-time, not anything useful like the libraries.
This is nothing new and nothing we didn't already know. It still says nothing about ASP.NET, Windows Forms and all the other parts of .NET that are not part of the ECMA standard. Mono implements many, many things outside the ECMA standard, so anybody but Novell who distributes or otherwise uses Mono is at risk of patent shenanigans.
Portable versions of Firefox, GIMP, LibreOffice, etc
Why would Miguel De Icaza be so happy if his previous assertions that there is nothing to worry about mean anything?
I love C# as a language, and .NET has been one of my favorite products from MS, it's great to use for development and seems to be what Java should have been. My concern with this announcement though is that I can't get The Lord of the Rings out of my head...
Three Rings for the Elven-kings under the sky,
Seven for the Dwarf-lords in their halls of stone,
Nine for Mortal Men doomed to die,
One for the Dark Lord on his dark throne
In the Land of Mordor where the Shadows lie.
One Ring to rule them all, One ring to find them,
One Ring to bring them all and in the darkness bind them
In the Land of Mordor where the Shadows lie.
I have been following Mono for a while but I am currently still using Java.
The question is which do I commit to?
The way I understand it is:
Java has less "patent liability" than Mono. .net are covered by the Communtiy Promise but not some of the supporting libraries (e.g. ado.net, winforms).
All of Java is under an open license including "essential" libraries (e.g. data access, gui).
Only the "core" (including the framework libraries?) of
I know that these .net libraries have been implemented in Mono but would we have to write new open-source libraries to replace thier functionality and remain "patent-threat" free?
If this is the case then I would imagine that Java would be the preferred choice IF you had to chose one.
What are the overheads of both the Java and Mono virtual machines running at the same time? Would we be better getting behind just one environment and using that.
For what it's worth I really like and prefer Mono - especially Banshee (is there an equivalent for Java?) and I want to develop for it but the Community Promise only covers the ECMA part of .net. Without the other libraries I fear Mono is hamstrung.
At least with Java I know where I stand, all the libraries are included and the functionality is already there.
OK, first off it's excellent news if MS are doing this. It would be nice if they did the same for the parts of Mono / .NET that are outside ECMA.
As far as motivation for this goes, they're a business for whom pure co-operation seems to have dubious benefits. I assume that they believe that in this case more people using .NET is good for them and that they can compete well on the quality of the implementation and debugging tools (probably true if only because they'll have a head start on new features).
But the question I'm really curious about: CLI / C# / Mono seems to have generated a massive amount of controversy and therefore a lot of noise. Some fairly popular new apps have been written using it. The whole situation seems to suggest that, whilst using the technology was generally considered to have many downsides, it must have pretty large benefits too: it's not just being suggested as a compatibility library but as a foundation for some pretty cool new stuff. So ... is this really the case? Is it that good that you'd want to write your note taking app in it (Tomboy) even though it's possible to write it in another language (i.e. Gnote)? Are the development tools that much better?
Or is it the case that a few "killer apps" happened to be written in C# as demonstrations of its abilities - even though another language would have done the job - and those apps are sufficiently desirable that Mono is getting pushed hard so that everyone can have these killer apps by default?
Personally, although I've not programmed in C#, I'm familiar with a variety of languages and implementation strategies. Different languages are certainly good for different things and more modern languages are typically less painful to work with. C# sounds quite nice. But what I'm wondering is: is the noise and push over Mono as a popular platform a result of it being particularly strong, or a result of a few particularly desirable apps depending on it? Obviously some (much!) of the noise generated is simply due to concerns over leveraging MS technology. But I do wonder how good the technology must be to justify this much noise and controversy!
The lawyers amongst us are leaping for joy. I happen to be a law convert. So ill try and explain why we're happy!
Promissory estoppel is a legal defence (a so called shield). When a party (A) intending legal relations promises not to assert their strict legal rights, and another party (B) moves to rely upon this promise, that party (A) is estopped from enforcing their rights (against B) by way way of promissory estoppel.
It goes something like this: Now MS has promised not to enforce their C#-rights , and people rely on this promise, such as start development/deploying C# applications because of this promise, if the case came to court, MS's argument would be estopped by a defence of promissory estoppel.
It's a little more complicated. For instance it must be inequitable for B if A reneges on their promise (fairly clear if they suffer a disadvantage or loss as 'one who comes into equity must come with clean hands'), the promise must be clear and unequivocal (I'd say yes), there must be a change in reliance on the promise (yes), and it is a shield not a cause of action (in other words, we can't sue MS for revoking the promise, we can simply aovid being sued).
However, things get a little confusing. MS have declared that this promise is unilateral, in other words, it is a promise to the world without the need for a formal agreement. Such things are valid in the eyes of the law, and enforced by the fact promissory estoppel acts as an equitable remedy - there is no need for consideration, a key ingreediant to the traditional offer/acceptance/consideration contractual model.
Promissory estoppel is a common law principle. It's basis in England is from Lord Denning's High Court decision in High Trees.
Law bit:
In High Trees, due to WW2, the claimant ("High Trees") agreed to reduce rent for a block of flats. After the war, the claimant brought action seeking the past and future rent. Lord Denning said "When a promise is made that is intended to be acted upon, and is acted upon, you are estopped from going back on it."
In High Trees Denning referred, not to a previous case of Foakes v Beer (about the part payment of debt), but Hughes v Metropolitan Railway to establish his basis for promissory estoppel. In Hughes, it was held that the opening of negotiations for sale of a property had an implied promise not to enforce an outstanding notice of repair that would forfeit the respondents lease.
Key to the criticism over Denning's decision is that Hughes only suspended rights, whereas High Trees may extinguish them. This position has recently been approved in the UK by the House of Lords in Tool Metal Manufacturing Co. Ltd - the promisor may revive rights by formal notice, unless it is impossible for the promisee to resume his original position.
Is it impossible to resume the original position prior to this agreement? We're talking about computers here. The agreement has come now, not several years ago. Consider Mono as it is now, as the original position. This is such a contentious area when you consider MS can revoke the promise, creating ambiguity, and because under Coombes v Coombes promissory estoppel is not a cause of action, the Mono community cannot sue MS to enforce this promise!
Matt
Thinking about it, the Community Promise is a huge win for Mono.
The Patent Trap was always a concern when I used Mono. I knew the external libraries ado.net, asp.net and winforms were "tainted" but was always unsure about the "core" on Mono itself.
Now that the "core" of Mono seems to be free from the patent threat from Microsoft Mono can take a new "patentless" path and develop equivalent versions of the libraries not mentioned in the Community Promise.
You won't be able to run Windows .net stuff (legally/safely) on Linux but you would be able to run Linux .net stuff on Windows.
GTK# seems to be a mature gui frontend the only major missing part is .ADO library for data access (unless something is already out there).
Mono does not *have to* follow Microsoft's upgrade treadmill and keep up-to-date compatibility with the latest version of .net instead concentrate on delivering applications on other systems - Linux, non-windows arm-based processors and macs.
In the end Mono could embrace, extend and extinquish Microsoft's own implementation.
This isn't meant to be helping Microsoft's competitors, such as Linux. Quite the opposite - it's meant to be helping Microsoft.
Proprietary lock-in the key to Microsoft's business model, whether we're talking about Office document formats, proprietary Internet Explorer extensions and incompatabilities or C#/CLI.
In this case it seems Microsoft accrues multiple benefits from open source developers who can't resist the free candy being offered:
1) It helps spread adoption of Microsoft's proprietary standards
2) It stops open source developers from pushing and developing alternative open source standards
3) It sets anyone (Mono) reimplementing these standards up for the future rug-pull when they change and/or extend the standard in the future, which will be done according to the needs of Microsofts business model
There's a reason the document format for Microsoft's office applications often changes from release to release, and it's not simply because new features are added. This is to force people to upgrade - which is the basis of Microsoft's business model. You can be sure that C#/CLI will be managed in the same way - don't expect Microsoft to keep these standards static now that they have "kindly" encouraged you to adopt/reimplement them. Quite the contrary, once there is significant open-source reliant upon them, then they have more incentive than ever to churn them.
It still has what one slashdot poster called 'the stench of microsoft' on it. Even if microsoft GPLs the whole stack, there will always be that feeling of disgust in those of us who are old school.
those claims of Microsoft-owned or Microsoft-controlled patents that are necessary to implement the required portions (which also include the required elements of optional portions) of the Covered Specification that are described in detail and not those merely referenced in the Covered Specification.
Of course, anyone who thinks they can "design-around" a patent will claim that the patent is not actually "necessary" to the desired function. In order to enjoy this "promise" you have to confess that the only way to achieve the standard is to infringe on a valid MS patent.
Another potentially worrying point is this exception:
If you file, maintain, or voluntarily participate in a patent infringement lawsuit against a Microsoft implementation of any Covered Specification, then this personal promise does not apply with respect to any Covered Implementation made or used by you.
So..., anyone who even "participates" in a patent suit against MS (including, presumably, a patent suit filed by MS), loses protection for not only their own products, but anything they "use." For example, if FSF got into a dust-up with MS, MS could still claim infringement by FSF (or anyone else) for using Mono, even though MS has chosen not to pursue the authors of Mono or other Mono users. Referring to it as a "personal promise" also calls into question its applicability to businesses/organizations.
I am being overly paranoid, but the fact is, like so many other legal "promises", the value of this one will only be seen in the implementation. As a cynical lawyer, I don't see anything here that absolutely precludes MS from asserting infringement by Mono or any other OSS project. If Microsoft truly wanted to be benevolent they could easily make a much broader promise with less grey area. For example, they could name the patents that they claim to cover the specs in question and offer royalty free licensing, or make a non-assert pledge with some actual teeth. All they are saying here is "we probably, maybe won't sue you unless we do."
I'm a lawyer with excellent karma. Something's gotta be wrong.
Even for a Linux enthusiast, the Visual Studio/Winforms stack is much more tempting for ambitious projects.
All Mono desktop applications that ship with Ubuntu are based on Gtk#. Winforms isn't even usually installed.
I'm a Windows developer by day and a Linux user by night, and I've got probably half and half MonoDevelop and Visual Studio projects at home. Pick the best tool for the job, they say.
VisualStudio and Winforms are proprietary and simply aren't a choice for Linux desktop applications (even if they didn't suck).
Does this announcement fall under the Embrace phase, or the Extend phase?
Java has less "patent liability" than Mono.
Sun has lots of patents on lots of aspects of Java. The only area where you *may* be safe is if you use Sun's own implementations.
I know that these .net libraries have been implemented in Mono but would we have to write new open-source libraries to replace thier functionality and remain "patent-threat" free?
Most people who develop with Mono develop using standard Linux libraries, libraries that are free of any hint of Microsoft patents. That's one of the things that makes Mono so attractive.
prefer Mono - especially Banshee ... Without the other libraries I fear Mono is hamstrung.
Banshee, like almost all Mono desktop apps, is based on Gtk#, not Winforms.
What are the overheads of both the Java and Mono virtual machines running at the same time? Would we be better getting behind just one environment and using that.
IKVM runs Java inside a CLR. It also neatly avoids Sun's patents.