.NET Core is open source
I couldn't believe my eyes: http://blogs.msdn.com/b/dotnet/archive/2014/11/12/net-core-is-open-source.aspx
Thankfully its under the MIT license, meaning there are no restrictions on development and deployment. It was smart to go with a permissive license instead of the GPL since these are libraries.
The reason for the core to be permissively licensed is to keep having proprietary software around. Like additional libraries that (potentially free software) applications will use (making them impossible to run in freedom). I see nothing positive in that.
And the GPL often is a good choice for libraries: https://www.gnu.org/licenses/why-not-lgpl.html
I've said this here multiple times about Mozilla Public License 2.0 being a good choice as it is copyleft at the file level.
Same problem: the core can be under the MPLv2 and everything around proprietary.
What is the problem? As long as the free software remains free software then that is a positive.
Oh wait... you won't be happy until that piece of free software forces the other bits to have their source code made open when its not supposed to be.
Isn't it true free software about giving freedoms to the developer and the user? You want to forcefully take that away from the developer.
You wrote that "it was smart to go with a permissive license instead of the GPL" and I pointed out that the main difference it makes is the possibility to surround the free core with proprietary software. Given Microsoft history, I even assumed it is their business plan. I have no sympathy for companies whose business plan is to use free software to eventually make the users fall into proprietary traps. You then suggested the "Mozilla Public License 2.0". It raises the exact same problem.
We went over that so many times that it starts to be tiresome: free software is about granting freedoms to users, not to developers. In particular, it is clearly not about granting the developers the possibility to write proprietary software with a smaller development effort! Just read the definition: https://www.gnu.org/philosophy/free-sw.html
Even reading the sole introduction is enough to get it (and I believe you got it but want to convince yourself that it is OK for you to enjoy the work put into permissively-licensed software and develop proprietary software):
“Free software” means software that respects users' freedom and community. Roughly, it means that the users have the freedom to run, copy, distribute, study, change and improve the software. Thus, “free software” is a matter of liberty, not price. To understand the concept, you should think of “free” as in “free speech,” not as in “free beer”.
We campaign for these freedoms because everyone deserves them. With these freedoms, the users (both individually and collectively) control the program and what it does for them. When users don't control the program, we call it a “nonfree” or “proprietary” program. The nonfree program controls the users, and the developer controls the program; this makes the program an instrument of unjust power.
I'm also going with the angle of the ease of integrating with other FLOSS software that may be GPL incompatible, but is still under a free software license. https://gnu.org/licenses/license-list.html#GPLIncompatibleLicenses
name at domain wrote:
> I couldn't believe my eyes:
> http://blogs.msdn.com/b/dotnet/archive/2014/11/12/net-core-is-open-source.aspx
Mono hacker and "open source" enthusiast Miguel de Icaza has announced
an intention to continue to add Microsoft's code to Mono stating "Like
we did in the past with .NET code that Microsoft open sourced, and like
we did with Roslyn, we are going to be integrating this code into Mono
and Xamarin's products." (http://tirania.org/blog/archive/2014/Nov-12.html).
But is that a wise course of action? Was it wise to do this in the past?
It's worth looking at history to see what traps Microsoft has set and if
those problems still exist.
In 2009 the FSF advised against writing software in C#
(https://www.fsf.org/news/2009-07-mscp-mono) and pointed to a practical
way out.
Neither Microsoft's Patent Promise
(https://github.com/dotnet/corefx/blob/master/PATENTS.TXT) nor
Microsoft's chosen license
(https://github.com/dotnet/corefx/blob/master/LICENSE) grant you an
irrevocable patent license. Microsoft has promised to not sue you. A
promise not to sue and an irrevocable patent license are not the same
thing because the circumstances that make the promise true today can
change tomorrow rendering the promise obsolete. The same is not true of
an irrevocable patent license.
To my reading, what you get from Microsoft here is just as risky for us
to depend on as what they offered years ago. So, as the FSF pointed out
years ago, "It only says that Microsoft will not sue you over claims in
patents that it owns or controls. If Microsoft sells one of those
patents, there's nothing stopping the buyer from suing everyone who uses
the software.".
As a result, FSF's advice from that 2009 essay is still worth heeding:
> If Microsoft genuinely wants to reassure free software users that it
> does not intend to sue them for using Mono, it should grant the
> public an irrevocable patent license for all of its patents that Mono
> actually exercises. That would neatly avoid all of the existing
> problems with the Community Promise: it's broad enough in scope that
> we don't have to figure out what's covered by the specification or
> strictly necessary to implement it. And it would still be in force
> even if Microsoft sold the patents.
>
> This isn't an unreasonable request, either. GPLv3 requires
> distributors to provide a similar license when they convey modified
> versions of covered software, and plenty of companies large and small
> have had no problem doing that. Certainly one with Microsoft's
> resources should be able to manage this, too. If they're unsure how
> to go about it, they should get in touch with us; we'd be happy to
> work with them to make sure it's satisfactory.
>
> Until that happens, free software developers still should not write
> software that depends on Mono. C# implementations can still be
> attacked by Microsoft's patents: the Community Promise is designed to
> give the company several outs if it wants them. We don't want to see
> developers' hard work lost to the community if we lose the ability to
> use Mono, and until we eliminate software patents altogether, using
> another language is the best way to prevent that from happening.
I wrote:
> To my reading, what you get from Microsoft here is just as risky for us
> to depend on as what they offered years ago. So, as the FSF pointed out
> years ago, "It only says that Microsoft will not sue you over claims in
> patents that it owns or controls. If Microsoft sells one of those
> patents, there's nothing stopping the buyer from suing everyone who uses
> the software.".
According to http://endsoftpatents.org/2014/11/ms-net/ End Software
Patents (ESP) speculates that "the 2012 'in re Spansion' case in the USA
and the judge ruled that a promise is the same as a licence". However,
this might not matter because:
- "it's not explicit in the ruling if this still applies when someone
else buys the patents" --
http://en.swpat.org/wiki/The_value_of_promises_and_estoppel_defences
- "you’re only protected if you’re distributing the code “as part of
either a .NET Runtime or as part of any application designed to run on a
.NET Runtime“. So if you add any of the code to another project, then
you lose protection and MS reserves the right to sue you or ask for
royalties" -- http://endsoftpatents.org/2014/11/ms-net/
- "the protection only applies to a “compliant implementation” of .NET.
So if you want to remove some parts and make a streamlined framework for
embedded devices, then your implementation won’t be compliant and the
protection doesn’t apply to you." --
http://endsoftpatents.org/2014/11/ms-net/
So even if Microsoft's patent promise not to sue is as good as a
license, Microsoft's promise has enough problems with it that you're
still left with the same result: you're better off not building
dependencies on .NET.
I wrote:
> To my reading, what you get from Microsoft here is just as risky for us
> to depend on as what they offered years ago. So, as the FSF pointed out
> years ago, "It only says that Microsoft will not sue you over claims in
> patents that it owns or controls. If Microsoft sells one of those
> patents, there's nothing stopping the buyer from suing everyone who uses
> the software.".
According to http://endsoftpatents.org/2014/11/ms-net/ End Software
Patents (ESP) speculates that "the 2012 'in re Spansion' case in the USA
and the judge ruled that a promise is the same as a licence". However,
this might not matter because:
- "it's not explicit in the ruling if this still applies when someone
else buys the patents" --
http://en.swpat.org/wiki/The_value_of_promises_and_estoppel_defences
- "you’re only protected if you’re distributing the code “as part of
either a .NET Runtime or as part of any application designed to run on a
.NET Runtime“. So if you add any of the code to another project, then
you lose protection and MS reserves the right to sue you or ask for
royalties" -- http://endsoftpatents.org/2014/11/ms-net/
- "the protection only applies to a “compliant implementation” of .NET.
So if you want to remove some parts and make a streamlined framework for
embedded devices, then your implementation won’t be compliant and the
protection doesn’t apply to you." --
http://endsoftpatents.org/2014/11/ms-net/
So even if Microsoft's patent promise not to sue is as good as a
license, Microsoft's promise has enough problems with it that you're
still left with the same result: you're better off not building
dependencies on .NET.
Well said.
"Covered Code" only covers what you get from Microsoft. It doesn't apply to, say, independent implementations - only to that which you get from Microsoft (reference ""Covered Code" means those Microsoft .NET libraries and runtime components as made available by Microsoft at..." and not even modifications of that code you get from them. "Oh, it's been modified - You no longer get the patent promise" (reference "that are infringed only as a consequence of modification of Covered Code"). "Oh, it's been added into Mono - you no longer get the patent promise (reference "...infringed only by the combination of Covered Code with third party code.")
Then, "currently own by Microsoft" the patent document says. Microsoft sells patents (which they have done - look it up) and guess what? It's not owned by Microsoft anymore. The whole deal's out the window.
It also only applies to "compliant implementation" - They could come & say "Oh, I'm sorry - Your implementation isn't 'compliant' for this, that and the other reason which was a requirement to get the promise not to sue." Or maybe "Oh, the source code has this bug which renders it less than 100% 'compliant' with the spec, so they don't get the promise." And then #B in the .NET Runtime section only applies to additional stuff they've published. All they need to do is not publish some part of the API. People might try to include it anyway. Try to include a non-documented API? (Because surely Microsoft documents absolutely everything about the API on its MSDN website, right?) You don't get the patent promise.
In short, patents are still a problem. They can still sue anyone that they want to even over some small technicality. The FSF's guidance that "we should discourage people from writing programs in C#" still holds. Nothing of that has changed. Microsoft could do a better job with their patent license to address the free software movement's concerns but they haven't because they don't really want to.
Don't forget that this is still the company we're dealing with starting from his description 19 seconds in: https://www.youtube.com/watch?v=6YExl9ojclo&t=0m19s
I don't code in C# and mainly a Python guy on the desktop and server side, but will this improve Wine and make it easier to port Windows programs that were heavily dependent on .NET?
I don't think much will change for Wine users. Mono is a different case though.
I am a member!
Any time you see the word "core" in an "open source" announcement such as this, it's a huge red flag. Generally it means that only one specific component is being "opened," and the majority of the framework (the actual important bits that an application requires to run) is being kept "closed." The word "core" might sound significant but we actually require the full framework to get anything done.
In this case, the blog post explains that ".NET Core" is one specific part of the .NET framework as a whole, and while they've already "opened" certain other bits of .NET, they "do not have plans on open sourcing and enabling you to build the full .NET Framework that ships in operating system."
https://github.com/dotnet/corefx/issues/82#issuecomment-63158393
Thanks, and I should point out that if someone were to try to add that stuff outside of Core into some implementation of their own (such as Mono) they don't get the patent promise because the promise only extends to "Covered Code" and it defines it that: "Covered Code means those Microsoft .NET libraries and runtime components as made available by Microsoft at https://github.com/dotnet/corefx."
So this turned out exactly how I expected it too. Sounds good at first but then all my suspicitions about it are true.
If history is anything to go by M$ pronouncements are best understood with a copy of Sun Tzu's Art of War in the other hand.
Still, free software has to fight the incumbents on their ground at some point and the .NET framework, (i.e. when M$ tried to expand to something not hardware specific) was the right criteria for when to take them on. (Because it can be implemented without reverse engineering the whole of W$).
All very messy and treacherous ground at best, but good luck to the Mono team in providing a migration path for all that existing business custom software in C# etc.