Open Source and .NET — Why It's Not Picking Up
Open Source and .NET — Why It's Not Picking Up
Open-source in .NET is not picking up. Despite good efforts from many good people and companies, it seems as if the Microsoft developers scene is far from embracing open-source. Why is this happening, and is there still hope for change?
Join the DZone community and get the full member experience.Join For Free
Learn how error monitoring with Sentry closes the gap between the product team and your customers. With Sentry, you can focus on what you do best: building and scaling software that makes your users’ lives better.
I have been sitting on this for a while and had dozens of discussions about it too. The things I'm about to say here are a result of a journey. Yes, this is criticism... but, from a respecting and caring place, coming from a long time OSS contributor in several software ecosystems, including .NET.
I'm posting this with the hopes it is perceived as a diagnosis, one that can lead to us getting better at this.
Open-source in .NET is not picking up. Despite good efforts from many good people and companies, it seems as if the Microsoft developers scene is far from embracing open-source. In some cases, it could appear as some bodies are even doing quite a bit to destroy what little OSS is already in .NET—probably not on purpose, but still.
Don't get me wrong, there is a quite a bit of OSS activity in .NET lately. From big projects backed by companies (Akka.NET, NServiceBus, and more), to useful libraries and tools (NancyFX, AutoMapper, AutoFac, StructureMap, and more) to influencing powers in the market who are going OSS (Microsoft, GitHub sharing love with .NET people, etc.). And OSS focused conferences, like DotNetFringe and .NET Unboxed, both of which I even attended and helped creating.
But, this doesn't seem to be enough. OSS projects in .NET are not striving; there is not much innovation happening in this space; and OSS communities aren't being formed. It is all left as a dream we keep dreaming, but never actually getting to fulfil.
In the end of the day, the Microsoft development platform was and still is a bubble. A very big and rich bubble. And, it seems like this bubble doesn't like change.
Why is this happening, and is there still hope for change? Here are two symptoms which I think are pretty much unique to the .NET ecosystem.
The Free as in Flee Syndrome
Historically, Microsoft is a product company which makes it's living from selling it's products. An operating system, word processors, development tools, databases - every product is sold, and usually not for cheap. When working or developing on the Microsoft stack, free tools never go unnoticed.
As a developer originally from the Windows platform, I still remember that feeling when I discovered a useful tool that was given out for free. Maybe this happened for others on non-Windows platforms too, I don't know, but back in the day where in Linux you had many free tools and in Windows not so many—including the operating system itself—well, you got to love free tools.
This, in turn, gets one to a dangerous state of mind where free equals someone was sucker enough to do this potentially expensive work for me. I would thank them, maybe, perhaps, but this was made for me to use—and for free. There is no notion of giving away or forming community projects. It's free as in no money involved; where the distinction between "Free as in beer" and "free as in speech" means nothing, because—hey, who cares, it's free.
While this is true historically speaking, apparently it's something that's hard to change in people. And, it still happens today way too often.
I spoke about that a few months ago at .NET Fringe, in the context of Lucene.NET. It's a project that's been around for a very long while, has a very wide array of use cases, has many users—including high profile companies and many commercial products, yet it's a project that has died more than once and never was able to progress nicely and form a strong contributors community around it.
While other reasons could be at play here as well, I still find it utterly ridiculous that well known commercial products are using Lucene.NET extensively (in some cases absolutely depending on it) and don't contribute back anything. Not a dime, not a single line of code, hardly even an attribution. Nada.
We have to overcome this. We have to be supportive, welcoming, sharing, and giving—otherwise, the .NET framework and surrounding technologies will forever be boring, grey, non-innovating corporate environments. This in turn will kill the environment. There are enough good people who left the Microsoft stack to other, more open, more sharing ecosystems. And, this is our responsibility to do so, as I will immediately explain. Don't take free stuff and flee; participate.
A good word here is due to some folks at Microsoft who made a big code contribution to Lucene.NET a while ago and helped us resurrect the project and restart development towards a 4.8 release.
The Sheep Syndrome
Developers on the Microsoft platform are, usually, used to be led. Microsoft is saying where it is going and the entire developers force are lining up with the direction like a herd. There was some opposition over the years, but all in all, the Windows platform is fundamentally different than most others platforms out there, where the communities lead and innovate. Historically, if Microsoft says it's headed somewhere, it will go there and the community will follow, often times failing altogether (Remember Windows 8? Strong naming? Silverlight?).
Microsoft is not evil or stupid, it is mostly a huge company with it's own economic interests and often times huge disorganisation. It's us, developers, who should know better. We should look around and criticize. We should open our eyes to other ecosystems and learn. We should look for good examples of success and we should adopt, not adapt. And, Microsoft will have to learn to listen.
There are very smart people in our industry. Many opinionated people and many innovators. Somehow the core of open-source developers on the stack is relatively small, in fact it is so tiny that I know most of them by name (or reputation...) and with many, I've met at least once. They all are amazing people, but why are there so few of them out there?
NancyFX is probably the best example out there for what I'm talking about. Led originally by two passionate people, it was able to form up a nice community and provide a very stable and easy to use alternative to ASP.NET MVC. It was so good that Microsoft has learned a trick or two (actually more) and implemented them all in it's more recent versions of the it's web frameworks. And, the roots of Nancy lies way outside of the Windows stack, somewhere in the Ruby lands. That's because Andreas and Steven went and looked outside, and knew better than to blindly listen to Microsoft's advice.
Let's bring more opposition. And, let's do more open source.
Do We Really Need OSS?
I was writing with two assumptions in mind. (1) We want to have a striving open source activity in the .NET ecosystem, and (2) the current situation is not good enough.
While you could argue on any of those points, I will just say this. The world is moving towards open-source because it works. There are various ways of managing, growing, and financing OSS projects and you should pick whatever works for you, or not pick one at all. But the ecosystem definitely benefits from them, and there are a lot of examples of successful business models that benefited all involved. And, the fact is that Microsoft is realizing this and moving toward that direction too.
The current situation is really bad. Without sponsorships of some sort OSS projects do die, and in .NET you don't find many sponsorships. NancyFX, which was partially supported by tretton37, is striving and indeed innovated. Lucene.NET is lagging so far behind because despite my requests to notable users, they refused sponsoring.
Let's change this.
Published at DZone with permission of Itamar Syn-hershko , DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.