This is a dramatic shift in an ecosystem that has traditionally been (fair or not) characterized as closed, often unfriendly to developers, Windows-specific (Mono is not, after all, a Microsoft project) and characterized by relatively high entry barriers (Visual Studio, lockdown to Windows Server etc).

I have a bunch of quick thoughts around this that I’d like to share.

No more poison pill licensing

Poison pill, in case you have not heard the term, is used in finance to describe various methods to deter takeover bids. An example could be the so-called “flipover rights plan”, where the company targeted with a hostile takeover, in the event of such an attempt, takes on large debts to make the debt load too high for the company to be attractive to be acquired anymore. In other words, “if you go against us and don’t play by the rules, you will go down.”

In software, a bunch of licenses are considered such “poison pills”. Affero GPL is one of them, as it effectively forces you to open source your entire system as soon as one of the components you use is AGPL licensed.

Large part of .NET framework was already openly available at ReferenceSource, but under a very restrictive license, MS-RSL – the Microsoft Reference Source License. In short, the license only allowed you to look at stuff, and only within your own company`. This was further explicitly limited by the license “for the sole purposes of debugging your products, maintaining your products, or enhancing the interoperability of your products with the software, and specifically excludes the right to distribute the software outside of your company.”

Consequently, it carried some severe repercussions when it came to open source projects such as Mono, which explicitly states on its website, under contribution guidelines:

“If you have looked at Microsoft’s proprietary implementation of .NET or their shared source code (which is also proprietary), you will not be able to contribute to Mono.”

Isn’t it crazy? That is because MS-RSL was a poison pill license.

Today’s announcement means that all this legal drama is behind us, and we can focus on being developers, making our software better, contribute to open source and not try to be lawyers. The reason is, it’s been announced the RefereneceSource is now MIT licensed. This is intended to help community port .NET framework features to .NET Core. And of course the .NET Core itself is MIT too.

.NET Core – on the way to true cross platform C#

We’ve already seen Xamarin embracing Roslyn as their C# compiler of choice – instead of having to maintain their own compiler. Now, as .NET Core emerges as true cross platform .NET framework, Mono will be able to gradually retire a large part of its codebase and reuse the open .NET Core instead.

This is fantastic news for everyone, because instead of maintaining a shadow of the entire platform, they can focus on the UI aspects of cross platform development that they are so heavily invested in. For us, developers, it means more consistency and coherence in our projects. To anyone who has ever done any work on Mono – just imagine being able to get rid of all these types of problems!

You are welcome to contribute to .NET Core yourself

As explained in this blog post by Immo Landwerth, PM on the .NET Framework team at Microsoft, the .NET Core framework is already out there on Github, and is ready to accept contributions.

As different features of the .NET Framework are going to be gradually ported to .NET Core, it will also be a terrific chance to also fix various annoyances of the existing .NET framework. One example that Immo brought up recently was working with Dictionary type, and trying to access a value by the key that doesn’t exist – you will get a KeyNotFoundException. The problem is, the exception doesn’t tell you what was the name of the key!

It’s been like that for ages, and it’s been a troubleshooting nightmare. With .NET Core, nothing will stop you, me or Immo, from dedicating a couple of hours to fix things like that straight away and PR into the framework, rather than waiting years for the MS development team to address it (or not).

In fact our Open Source junkie, Adam Ralph, has already made history with the first PR!

Open source without community involvement is not real open source

There is a fine line between open source and source open. Working on a platform the size of .NET, and staying committed to open source is a challenging task. It requires a mindset change for the people involved, changes in everyday workflows, commitment and discipline, and most importantly, treating the community like equal partners, rather than a tolerated evil.

I’m sure there will be some friction, some understatements and a learning curve, but at the same time I know for a fact (first hand), that Microsoft is committed to making this work, and that the people in charge really believe in the value of open source.

One trap that’s easy to fall into, is the “we built the platform, we got this” mentality. I am sure the .NET framework team will build upon the experiences of other teams at Microsoft that have been out in the open for a while – the ASP.NET team, the Roslyn team, the F# team – and really engages with the community. In fact, Immo’s post I mentioned earlier already outlines a very robust, professional approach to committing to open source.

One thing that ASP.NET does really well is that it now goes beyond just having it’s code out in the open. It also publicizes its sprint boards (!), so you know exactly what they are doing, when they are doing that and what are the plans going forward. They also hold publicly broadcasted weekly stand up meetings, which is another excellent way to communicate with and engage the community. On top of all that, a large portion of ASP.NET MVP Summit events, traditionally under NDA, were broadcasted publicly too.

Here’s a model for an open Microsoft we all want.

Open Microsoft is for real

Which leads me to another point.

While I don’t really know what happened internally at Microsoft that led to this shift from a closed company to embracing OSS, and how many political battles were fought, but my perception as a bystander is that this rapid push towards an open Microsoft was really sparked by the ASP.NET folks under Scott Gu (if you know otherwise, please correct me), and it spread from there.

They opened the ASP.NET MVC framework, then followed with plenty of other open projects – Web API, Entity Framework, Project Katana, NuGet. In parallel Azure (also under Scott Gu) was open sourcing or simply building lots of its components out in the open.

Now ASP.NET team is about to release ASP.NET vNext, which introduces not only new versions of the web frameworks, but also a completely new ASP.NET managed runtime – all of which is obviously open source.

It seems that the overwhelmingly positive public reaction ignited changes in other places, which ultimately led to the open sourcing of the Roslyn compiler at Build earlier this year, so one of the most critical pieces of the .NET ecosystem.

At the same time Microsoft announced the .NET Foundation, an independent body responsible for stewarding the open development and collaboration for the projects involved in the foundation. .NET Core is now also part of the .NET Foundation, so it’s really owned by the independent body now, not by Microsoft, which is wonderful news.

In many ways recent developments at Microsoft, go completely against the image the company has gained (rightfully or not) over the years – an ultra powerful company, surrounded by an army of lawyers, with no respect for open source.

I saw this tweet the other day, and it illustrates the situation quite well:

The code is (or rather soon will be) free

While I’m not a fan of GPL license, I would like to close this with a quote from GPL’s creator and founder of the Free Software Foundation, Richard Stallman who once said:

“(…) making a program proprietary is wrong. To liberate the code, if it is possible, would not be theft, any more than freeing a slave is theft (which is what the slave owner would surely call it).”

While the quote is quite controversial, and you can read a lot into it, it has a simple message. Free code is better code.

And I’m really happy today, because Microsoft has decided to set the code free. The .NET slavery is being abolished.

“The problem is, the exception doesn’t tell you what was the name of the key!”

Please don’t jump into this without evaluating it It can be an attach vector – if the key was received from the user and not sanitized, it could be a 2GB string, or HTML, or Javascript… changing that part of the core library could be problematic

http://abatishchev.ru abatishchev

What had changed? Nothing really.
Microsoft is still Microsoft, the corporation of 120k employees and infinite layers of mid-level managers of their own culture of doing nothing except increasing their own value and securing their work place.
You’re welcome to contribute? Not exactly. You’re welcome to send a pull request. Any obligations to accept it? Even review after few months of silence? Not at all.
Microsoft products are still Microsoft products. With their own roadmap and management. Will try to influence them? You can try of course. I don’t think it’s worth the efforts.
This is just marketing, don’t buy it.

http://amanek.com Alexander Manekovskiy

Well, I agree that Microsoft is still Microsoft and nothing will change there in near future and it is not the “AWWWYEAH!! Lets write .NET together! Send PRs everyone!!!oneone!!1″ type of news.

One point: Despite what some MS blogs are suggesting I’m fairly sure most of the ReferenceSource is still under MS-RSL. I think it’s just the bits of it released in https://github.com/Microsoft/referencesource that is MIT licensed (that is, most of System.dll, mscorlib and System.core.dll – System.Net for instance is part of System.dll but not included in that repo.) Note the license here: http://referencesource.microsoft.com/ remains MS-RSL. This means WCF, Winforms and smaller APIs like System.Data are still not MIT.