
The Weakness of the .NET OSS Ecosystem - berberich
http://www.aaronstannard.com/the-profound-weakness-of-the-net-oss-ecosystem/
======
mdpm
Really the simple issue has always been the same with MS-platform based OSS;
People look to MS to provide the canonical frameworks, tools, and libraries.
MS is far more used in corporate environments as a portion of their market,
and are more subject to business decision making; much of that focused on RAD
/ designer tooling.

There's a different philosophy in the open source world - python, perl, c -
none really have 'de facto' answers to persistence, logging, services, etc so
There's a plethora of approaches and libraries for any needs. MS provides EF,
so you have to defend any alternate solution to business; it's perceived as
risky. Even using tools not of MS origin, despite no close surrogate from the
'official' tools (ala Redis, 3rd party libs) is something you have to find
approval for. MS tooling is automatically excluded from this. This isn't great
for MS either, because they now have to produce these 'ideal' libraries, and
the strength of their platform is now judged by library implementations.

I'm really not sure what the solution to this problem is unless they really
get to sponsoring projects with effort, money, and tooling. They have programs
in place for this, and I can see there's a lot of outreach going on for this
reason.

~~~
bmir-alum-007
I've worked on open+closed source in enterprise startups with people that come
from both MSFT- and Linux-centric worlds respectively. The MSFT centric-people
tend (not all) poo-poo open source as a complete waste of time and/or lack of
business savviness (helps competitors too much). There is some open source
contributions in such shops, but usually only if it helps (and doesn't seem to
hurt) the bottom-line.

PS: Unfortunately, most Fortune 2000 enterprise (ms and non-ms shops) abuse
the fuck out of open source and give zero back (time, $ or help). I really
think there should be some "community charge" funding model which doesn't make
it nakedly for-profit but rewards people that contribute, maintain and support
useful code that is widely deployed so they're not completely abused as unpaid
crowdslaves.

~~~
pmontra
I understand your feelings but legally speaking the only abuse of that kind
would be taking GPLed software, modifying it, distributing it and not sharing
it back. If the software has been licensed with BSD or similar licenses that
don't require to share modifications, then the original developers are
perfectly fine with not seeing anything coming out from those corporations.
Their choice, no abuses.

~~~
geon
Absolutely. It is in their own interest to share contributions upstream. If
they don't, they are forced to re-apply their patches over-and-over or just
not upgrade.

------
tpetricek
I think it is important to realize that the .NET OSS ecosystem is not
something that has been around for a long time. In the F# community, it truly
started working as an "OSS ecosystem" only a couple of years ago - and the
rest of .NET is following - and I'd say it is only starting to really exist
now. Although .NET has been around for ages, people are only learning what OSS
means and I think the F# community is leading the way here.

There are definitely interesting hard problems that are being solved in the F#
community. For some larger and fully open source projects that exist out there
check out:

* [http://www.m-brace.net](http://www.m-brace.net) \- A fantastic library for doing interactive cloud computation that takes a slightly different approach than Spark (think "cloud monad" :-))

* [http://fslab.org](http://fslab.org) \- A nicely integrated collection of data science libraries with fantastic data access features and R integration (supported by OSS community and a finance company)

* [http://websharper.com](http://websharper.com) \- An open source library for doing web programming that has a pretty unique integration of client-side programming (translated to JS) with server-side programming

* Also, I would like to mention FAKE, Paket and ProjectScaffold ([http://fsprojects.github.io/ProjectScaffold](http://fsprojects.github.io/ProjectScaffold)) which enable the community build OSS libraries with smooth build process and great documentation.

Is it impressive compared with longer and more established OSS communities?
Maybe not. But those are all things that happened over the last 2 years. It's
enough to make me feel that the F# and .NET ecosystems are heading in a good
direction.

~~~
nl
Sorry, but that is a nonsense excuse.

The (now abandoned) Spring.NET project[1] was started in 2004, not too long
after (Java) Spring started.

It's easy to criticize Java Spring, but it's a good example of a long-lived
successful Open Source project. It's also easy to argue that Spring isn't as
useful in .NET as in Java.

But I can pull up many, may other examples (the .NET Lucene port etc).

My point is that the .NET OSS ecosystem is _NOT_ a new thing, but it keeps
getting killed off. The typical example is that a .NET project starts to solve
a problem, gets it 30-40% solved, then Microsoft releases a project that
solves a different 30-40% but sucks all the oxygen out of the ecosystem.

[1]
[http://springframework.net/news.html](http://springframework.net/news.html)

~~~
AdieuToLogic
> The (now abandoned) Spring.NET project

It's been abandoned? (serious question) That really is too bad. It was a solid
project used on several .NET projects in which I participated "back in the
day."

BTW, I completely agree with your summary point. There appears to be a
cultural rejection of .NET OSS projects.

~~~
batou
It slowly fell behind. I made the mistake of using it for a product pre-MVC.
When MVC came along they jumped the shark and we ended up ripping it out and
replacing bits with Autofac and some light weight abstractions we put together
ourselves.

------
vdnkh
Yes, the author is correct. There is a distinct lack of OSS in .NET. I've been
trying to find a project to contribute to among the graveyard on Github.
However, I think the author falls flat explaining the why. I have a few thory
on this. For so long C# has been a walled garden of closed source software.
This closed source software, for the most part, works damn well. Why reinvent
a square wheel when there is a shop of perfectly good OEM ones? At work, I'm
focused on Getting Stuff Done and the .NET library is great for that.

~~~
tacos
The tools and libraries from Microsoft are so solid that frankly you don't
need an entire class of open source projects.

I don't need to "contribute" and "socialize" with some Python craziness named
after a dolphin (though I did!) because Amazon provides a real .NET SDK for
talking to AWS. I don't need to wrestle with three different constantly-
patched Ruby image libraries because .NET has been able to load and save six
kinds of bitmaps via everything from C# to F# to Excel macros since the 90s.

The community around node.js in many ways is an attempt to re-write .NET from
the ground up. And they're doing an amazing job. But so am I, when I can write
three lines of code in a version of F# that shipped six years ago and issue
SQL-like data gathering queries over everything from Wikipedia to the
Department of Labor.

That said -- Microsoft's idiotic forges and weirdo repositories were total
incompetent nonsense. And the stupidity with their C compilers -- from
strategy to implementation -- presented a brick wall to anything resembling
clean cross-platform development, which DAMMIT, is a must.

There is a lot more open-source .NET code out there than you'd think. But it
tends to be very narrow and very vertical (and often, very high quality)
because the core libraries are so broad and so great.

~~~
mistermann
> when I can write three lines of code in a version of F# that shipped six
> years ago and issue SQL-like data gathering queries over everything from
> Wikipedia to the Department of Labor.

What's the name this technology goes by, and is it possible in C# (regardless
of if it's extra lines of code)?

~~~
tacos
F# type providers. Quick entry point: [http://tomasp.net/blog/fsharp-
data.aspx/](http://tomasp.net/blog/fsharp-data.aspx/)

It's kinda awesome.

C# provides similar (but somehow less fun) stuff via LINQ providers. Search
"LINQ to [noun]" and you'll find plenty of open source code.

------
batou
This is right and wrong.

Right because yes there could be a ton more open source solutions out there.
Also right because most of them are either shit, commercial or abandonware.
This is a big problem. We imported a lot of stuff and found it was mostly crap
(Nservicebus, justsaying come to mind)

Also wrong because a massive portion of what we do is a solved problem on
.net. There's not a whole load of stuff to reinvent.

What I'd like to point out though is name me one platform I can build stuff
for desktop, mobile, web, embedded, plugged into office applications, deployed
by a single click from the web, deployed to single machines, deployed to
thousands of workstations, will talk to just about anything under the sun from
REST, SOAP, WS-*, databases, spreadsheets, document models, message queues,
serial ports, pipes, TCP channels, has a request broker and distributed object
model and has several data access methods from ORM, SQL, table gateway
abstraction and has very decent tooling, provisioning, integrated deployment,
testing, profiling and backwards compatibility going back 20 years all out of
the box with no glue required?

On top of that there's support which is actually very good for everything
above.

Nope there's only one and Java doesn't come close.

------
daxfohl
A good chunk of that is the "invented here syndrome". With EF, WPF, ASP MVC,
MEF, etc, plus annual MSBuild conferences, .Net has far more internally-
developed ecosystem than Java. Which tends to promote the idea that the MS way
is the right way, and if I need something else I must be doing something wrong
(or I need to wait till next year).

Perhaps MS should just kill off all these frameworks and _force_ the community
to drive them.

~~~
brightball
That's one of my favorite things about Microsoft. Whenever they release a
framework or a product, there's a tendency to just call it whatever the name
of the technology is as if they invented the whole thing.

SQL Server - When .NET developers say SQL they mean SQL Server 90% of the time
it seems.

MVC - MVC4 is a .NET Rails clone. Named MVC as if Microsoft originated the
design pattern that was used to clone another framework.

It cracks me up every time. :-)

~~~
starik36
Actually, MVC is called ASP.NET MVC. And at this point, it is very far from a
Rails clone.

~~~
meragrin
The use of 'MVC - MVC4' seems to me to be an acknowledgement that it is no
longer a Rails clone.

------
mythz
It's due to NIH and the "power of defaults" as soon as MS recommends a
library, it effectively kills any chance that an alternative OSS will gain
enough mind-share/traction to survive on its own, which a lot of the time
given the lack of adoption, OSS Authors end up abandoning the project since
the effort to further develop, support and maintain them doesn't justify their
negligible impact.

You just need to look at the NuGet package statistics to see how pervasive
this is in .NET:
[https://www.nuget.org/stats/packages](https://www.nuget.org/stats/packages)

Out of the top 50 projects, the only packages I see that aren't prescribed
defaults shipped in VS.NET Templates are:

    
    
      - NUnit & NUnitTestAdapter
      - Moq
      - AutoMapper
      - log4net
    

NUnit and log4net were originally ported from Java and defined their
respective categories in .NET which MS's NIH alternatives aren't able to match
(e.g. they don't run on Mono).

MS doesn't offer anything comparable to Moq or AutoMapper which explains their
success.

Reasons why from my 2012 Interview on .NET OSS:
[http://www.infoq.com/articles/interview-
servicestack-2](http://www.infoq.com/articles/interview-servicestack-2)

> The .NET platform is like no other; Microsoft has PR channels, Evangelists,
> MVP Award programs and control over VS.NET that commands a strong influence
> over .NET mindshare where they're seen as the authoritative voice for the
> .NET ecosystem to most developers. Historically they've only used their
> influence to validate their own libraries and frameworks which has
> contributed to many .NET companies being reluctant to deviate from
> Microsoft's prescribed technology stacks and explore alternative solutions.

This also explains why the .NET Ecosystem is slow at adopting popular
technologies (prevalent in other platforms) where they don't gain traction
until MS PR validates them, inc: MVC, Testing, NoSQL, MQ's, etc.

------
JamesBarney
Here is some blatant speculation about the problem with .NET and OSS.

The the larger problem is one of self-selection. C# devs are not alone in not
contributing to opens source software. The vast majority of devs don't make
meaningful contributions to OSS. It's just the the few people who get really
stoked about open source software and love making a positive contribution to
world through software have been turned off by Microsoft's behavior for the
last 10-15 years. So they never entered the .NET/C# world to begin with.

The second is incentives. Java shops are much more comfortable with open
source then .NET shops. Open source is still terrifying to many enterprise
customers, and a lot of .NET shops. And the incentives besides making a
positive contribution to the world [0] for contributing to OSS are it looks
good on your resume, maybe you could consult on it, and getting to be paid to
work on your own OSS project. But with most customers not using OSS the
developers don't get a lot of personal benefits from it.

The third is how bug fixing your favorite OSS acts like a gateway drugs. In
the past .NET devs wouldn't have very much experience with any OSS. If they
found a bug in their favorite framework they would report it. End of story.
Everything they used was closed source MS stack. But if they were working with
Java(and probably working on an OSS library) they could dive into that library
and make the fix themselves. Now that all of the core libraries for MS are
being open sourced many more devs will start to get familiar with what it's
like to be able to make a change to library or framework you use on a daily
basis. And hopefully some will catch the OSS bug.

I think this will change. As Microsoft pushes more OSS, enterprise customers
will see it as less scary. Devs who are into OSS might start considering .Net
as an option. And finally devs will start to get a taste of what it's like to
get to fix a bug on a framework or library that 1000's of people use.

[0] -see point 1 why people who wanna make a positive contribution to world
through open source software shy away from being .net developers

~~~
jameshart
"Microsoft's behavior for the last 10-15 years"

The 'bad stuff' from an OSS point of view is, generally, longer ago than that.

\- "Embrace, Extend, Extinguish": 1995 \- US vs. Microsoft Corp: 1998 \-
Halloween Documents: 1998

Scraping under the 15 year bar:

\- Microsoft vs Sun settlements: 2001-2002 \- Ballmer "Linux is a Cancer":
2001

SCO vs IBM was 2003, so I guess fits into the '10-15' ballpark, but I think
"over the last 10-15 years" makes it seem more continuous than the evidence
suggests. If you were to describe Microsoft's behavior over the last 10-15
years with respect to open source software, I think a fair assessment would be
"improving".

I'm not, honestly, trying to be an apologist for this stuff - it was, clearly,
Microsoft policy for a long time to deliberately and pretty unscrupulously
undermine Linux and Java and open source adoption. It doesn't appear to be
policy to compete unfairly any more, and in some cases MS is producing
technologies which support usage of non-MS-originated open and open source
technologies. Can we begin to move on a little?

~~~
fineman
> Can we begin to move on a little?

Why? Why should we forget that the entire company (currently) is funded by the
crimes of the past?

Are they a person who made mistakes when young and now deserves a second
chance?

I'm not anti-capitalistic but I'd never deal with, for example, a consultancy
that cheated me in the past even if they had all new consultants and managers
- some things just don't change. And even if... they _might_ have turned over
a new leaf but do they deserve another try and are you obligated to give it to
them? Wouldn't it be better for everyone to offer the opportunity to a
potentially honest competitor?

As long as people are willing to forgive companies, companies are prepared to
bilk them.

~~~
jameshart
And if people never offer forgiveness, then there's no incentive for them to
improve. I guess you're just hoping that if you ignore them they'll go away?

~~~
fineman
If we all ignored them, and their products, they would go away. Capitalism.

I don't care to offer them a way to improve; their future success isn't my
problem.

Why do you feel the need to make Microsoft the victim?

------
cbsmith
Alternate title: "It's hard to build a church on top of a native american
burial ground."

~~~
lectrick
I liked this analogy. Why is it getting downvoted? It's totally true. Too much
cognitive dissonance between open-source on a for-profit foundation.

~~~
jameshart
Doesn't explain why Java developed a robust OSS ecosystem long before it went
open source. Java did benefit from the model Sun set up on J2EE of setting out
JSR 'specifications' and only providing limited capability reference
implementations, which made it possible for the Apache Java ecosystem to
spring up, initially around the Xerces and Xalan XML libraries. Maybe -
_maybe_ \- Microsoft is starting to get on board with this kind of model now.

~~~
cbsmith
I agree there was a lot of similarity between how open Java & C# were as they
evolved. However, Sun's engagement with the open source development
_community_ was much, much, much better than Microsoft's. Sun had its
problems, but they actually had worked with that community in the past. At the
time Microsoft was openly combative.

------
hokkos
The fact that until recently .Net only run correctly on windows where the
licensing is more expansive than linux, and that all the big player use linux
to develop their cloud capacities; it means that the ones who seek to develop
at scale didn't bother with .net. Now that .net is open source, MS has still
at lot of work to fix all the issues on linux, but maybe the ship has sailed
and developer won't bother to port on .net all the hard work done for java as
they are really similar.

~~~
0xCMP
There is always new stuff and C# is going to still be much faster than say a
python or ruby so just like go replaces a lot of stuff written in those
languages it wouldn't be crazy to see C# used as well.

The ship hasn't sailed, but when they get to the ship it better be good
enough.

~~~
dozzie
C# does not compete with Python or Ruby. It competes with Java, which is
already entrenched.

~~~
edgyswingset
OP is suggesting that C# is competing with languages people are picking to
_replace_ Ruby or Python. A recent example is Parse[1] moving to Go. C# and
.NET was their second choice.

[1][http://blog.parse.com/learn/how-we-moved-our-api-from-
ruby-t...](http://blog.parse.com/learn/how-we-moved-our-api-from-ruby-to-go-
and-saved-our-sanity/)

------
sremani
The level intellectual laziness is immense. Most of the developers, me
included look at Microsoft for guidance than embracing hard problems and
solving it for ourselves. This does not mean .net is filled with incompetent
programmers but it is full of "unless you pay" programmers.

~~~
JustSomeNobody
You mean the "At least I don't have to use Java" developers?

~~~
bitmapbrother
I think he meant the "developing for a locked in and dead ecosystem"
developers.

------
platz
My perception is that F# is attracting the open source folks in the .Net
community [http://tomasp.net/blog/2015/why-fsharp-
in-2015/](http://tomasp.net/blog/2015/why-fsharp-in-2015/)

~~~
daxfohl
Ironically, I love F# but still waiting for F# on JVM before beginning any
serious work.

~~~
sklogic
JVM is incapable of running anything like F# efficiently.

~~~
ectoplasm
How come?

~~~
sklogic
It's got some severe built-in limitations. Firstly and most importantly, there
is no support whatsoever for the proper tail calls (and F# is using the .tail
prefix quite a lot).

Secondly, no stack allocation (value types in .NET).

Another thing which may harm optimisation significantly (although not sure if
F# is using it - but the other functional languages most definitely would have
benefited from this) is a very low hard limit on a method size, which forbids
any extensive inlining and specialisation.

~~~
ectoplasm
Thanks for clarifying. I think tail call conversion to iteration for Java
bytecode could be added to a JVM implementation without changing the spec, and
you could also do it when converting F# to bytecode. Apparently it's on the
todo list but not high priority.

Stack allocation is trickier if it's specified in F# code, because it isn't
part of the VM spec, but automatic stack allocation for Java has been
demonstrated in a research context and I think either HotSpot or J9 can do it
too.

The method size limit is something like 2^16 bytecodes, but even if that's a
problem, JITs are free to inline beyond that as much as they want.

So, I agree it would take some work but I don't think it's fundamentally
impractical. Adding stack allocation to the class file format would be the
hardest thing to push through I think.

~~~
sklogic
> I think tail call conversion to iteration

You cannot convert a tail call to an iteration in a generic case.

Consider the following:

`let f g x = g x`

Here, call `g x` is a tail call, and you've no idea what `g` is, so you cannot
statically inline it or convert to a loop.

> JITs are free to inline beyond that as much as they want

JITs are primitive and do not have much time to do anything interesting.
Inlining is very important alongside with partial evaluation - which is very
heavyweight and must be done statically.

Anyway, without proper _tail_ calls inlining on JIT level won't help much.

> it's fundamentally impractical

Everyone who ever tried implementing any ML-like language on top of JVM failed
miserably.

~~~
dragonwriter
> Everyone who ever tried implementing any ML-like language on top of JVM
> failed miserably.

How is "ML-like" defined here? AFAIK, Haskell is usually considered "ML-like",
and Frege is a Haskell dialect implemented on the JVM.

~~~
sklogic
Haskell is nowhere near an ML-like language, it's lazy, while ML is eager. And
Frege is nice and all that, but it's very far from being efficient, nothing
close to F# performance.

~~~
codygman
I don't think you can say "Haskell is nowhere near an ML-like language" based
on just lazy vs eager evaluation.

See here[0]:

> Since Haskell is inevitably an ML (descending from Lazy ML) derivative, one
> might begin by pointing out the similarities:
    
    
        - First-class support for algebraic datatypes (disjoint unions)
        - Pattern matching on primitive and custom values
        - Arbitrarily higher order functions
        - Type synonyms
        - Hindley-Milner Type Inference
        - Parametric Polymorphism (define arbitrary Functors etc.)
        - Ad-hoc polymorphism (Haskell through type classes, SML through modules)
        - scorn of inclusion polymorphism (sub-type relations, a la object-wise inheritance)
        - Monads (and other exotic algebraic structures)—"Haskell has monads" is a common claim of superiority, but the reality is that at the language level a monad is nothing more than an abstraction pattern, and hence every language (can) have monads. Including a monad or not in any given language is a library-level decision.
    

> While the bread-and-butter language features may be similar, building
> software in Haskell vs SML is actually quite a different affair:

So we can see a _lot_ in common there.

0: [http://www.quora.com/What-are-the-key-differences-between-
Ha...](http://www.quora.com/What-are-the-key-differences-between-Haskell-and-
Standard-ML)

~~~
sklogic
> based on just lazy vs eager evaluation.

It's not "just", it's fundamental. We're talking about an efficient
implementation, remember? And therefore the underlying execution semantics is
the single most important thing for classifying languages. The rest that you
listed is very high level, consider it syntax sugar. It is all lowered down
long before any of the important optimisations start to kick in.

> So we can see a lot in common there.

Not that much. Just think of the deeply fundamental difference between SECD
and, say, STG.

------
mcguire
In addition to the various theories abounding here, I've got another one:
Microsoft has historically never been big in distributed systems specifically.

The licenses for their operating systems have always acted to make farms of
Windows machines rare. Until fairly recently, the administration approach made
it painful. Microsoft had good support for client-server systems, but you did
it their way, which wasn't "reactive".

Here's a quick question: Anyone know of any networking/distributed system
developments that came out of a Microsoft environment?

------
ams6110
_Do something mind-blowing instead – use Storm to make a real-time
recommendation app for solving the paradox of choice whenever I walk into a
7-11 and try to figure out what to eat._

I'm reaching for a word that means "an example which is almost exactly the
opposite of the concept it's used to illustrate" \-- incongruous?

------
blakeyrat
His main argument seems to center around a "reactive socket server middleware"
being absent in the .NET ecosystem.

I frankly:

1) don't know what that is, and

2) can't even _imagine_ what it could consist of other than a few lines of
code exercising System.Net.Sockets.

~~~
felixgallo
then why are you posting, instead of going and learning?

~~~
trentmb
I regularly ask questions before seeking knowledge on my own, just to check
back on my post a few hours/days/weeks later.

The point of asking the question is to leverage others experience to guide
your learning, and provide a reference for those in the future that have a
similar question.

~~~
felixgallo
The post has no question marks, nor does it seek knowledge. Instead, it makes
declarative statements implying that the knowledge is actually probably
useless.

~~~
trentmb
> The post has no question marks

Correct.

> nor does it seek knowledge.

Open to interpretation- when someone claims they don't know what something is,
I interpret that as an invitation to explanation, exposition.

------
AngusMcQuarrie
Re: the Akka.Net stuff, there is indeed an implementation of an Actor model
framework - Orleans. Now it was developed in house at Microsoft and hasn't
gotten a lot of attention from developers other than Microsoft employees, but
it's there.

[https://github.com/dotnet/orleans](https://github.com/dotnet/orleans)

~~~
platz
It hasn't gotten a lot of attention because Orleans forces you down
implementing odd boilerplate and static interfaces which feels very un-actor
like.

~~~
reubenbond
What boilerplate is that? Grain state interfaces are better now, and the
Roslyn-based runtime code generator
([https://github.com/dotnet/orleans/pull/528](https://github.com/dotnet/orleans/pull/528))
is so close to being merged (so you don't have to include anything in your
.csproj, even though that's automatic with the NuGet packages).

Whatever it is, maybe we can fix it?

------
bliti
I've been really trying to go FOSS (or even OSS) with .NET. But the community
does not seem to be very open to it. They do upvote, star or otherwise applaud
the effor. Yet nobody uses it. Or even makes the effort to try. My experience
with the Python community is quite different. People not only accept the work
provided, they actually try and use it and give feedback. It feels good to get
a pull request improving something you did. The issue might be that .NET has
been promoted as closed source by MS for so long. It might take years before
the user base warms up to these new changes.

~~~
marpstar
I work with an entire department of C# developers, and frankly I don't think
they care at all about OSS or giving back to the community. It's kind of a
bummer, but I've tried to generate enthusiasm around open sourcing some of our
components and was met with blank stares.

We've been a Microsoft shop from the start and it's obvious.

~~~
bliti
OT: What a coincidence. A friend was talking about cartegraph the other day
(talking about .NET and OMSs).

------
skc
How about maybe we've reached a point where there are very few things you
can't already do/achieve quite well in C#/.Net without having to dip into OSS
land?

I'm a C# dev and I keep close tabs on the plethora of tools that become the
new cool thing in OSS for other platforms, and maybe it's a case that I don't
work on interesting things...but I've never found myself hindered by C#/.Net.

In any case, the _major_ OSS tools out there do have .Net ports that are
actively maintained, perhaps only the bleeding edge stuff is slow on the
uptake.

------
Asbostos
I'm always disappointed when I hear about .Net being open sourced and .Net
running on Linux and so on. Because the discussion completely ignores the
existence of desktop applications. If you used Winforms or WPF or DirectX,
etc. then you're still locked in to the closed source world and Windows only.
I know desktop applications aren't cool anymore, but if you were cool, you
wouldn't have used .Net in the first place.

------
zamalek
> I was incredulous when I couldn’t find a developer-friendly implementation
> of Murmur3 in C# already.

I've got Murmur3 for you [1] - you can stream into it if that interests you at
all. Here's my unit tests [2] (which are arguably the hard part because the
reference tests are strange).

I agree with your article, though, a lot needs to be done. E.g. Frustrated
with the lack of a .Net diffing lib I went and wrote one based on patience
diff [3] and the best I've gotten is one issue. Nobody seems interested in
solving problems like the ones you are talking about.

[1]:
[https://gist.github.com/jcdickinson/4bda826eb2e3f58e38c4](https://gist.github.com/jcdickinson/4bda826eb2e3f58e38c4)
[2]:
[http://stackoverflow.com/questions/14747343/murmurhash3-test...](http://stackoverflow.com/questions/14747343/murmurhash3-test-
vectors/16796118#16796118) [3]:
[https://github.com/jcdickinson/difflib](https://github.com/jcdickinson/difflib)

------
reubenbond
The half-assed actor project mentioned by the article is _probably_ ActorFx -
which is an interesting project with some cool ideas. For exammple, you could
write actors in a mix of languages like Python, JS, & C#. It had automatic
state replication after each turn. Actors were observable, Rx-style. Actor
behavior could be specified at runtime: you could effectively throw a JS
closure into the cluster and it create an actor out of it.

I wonder, though why it became stagnant so soon and never gained momentum. I'm
don't know, but I have a theory. The team were using some tech which was semi-
secret at the time, which they weren't allowed to talk about: Service Fabric
(known as Windows Fabric at the time). Fabric was in use in projects like Lync
Server and Service Bus Server, but no one could talk openly about it.

How can you develop an open-source distributed system without being able to
mention the framework which makes it all possible? Fabric handles ActorFx'
high availability, service discovery, code distribution/upgrades, and their
state replication. It's pretty difficult... Forum posts asking what this
fabric thing was went unanswered and the people who may have been interested
in ActorFx just moved on.

Regarding Orleans, there were probably a couple of internal actor frameworks
in use at some large .NET houses, but they were never released to the public.
I think it was more of a cultural issue than a lack of devs: .NET devs weren't
used to sharing code.

Things are getting better. The community around Orleans is great (come join us
on Gitter!
[https://gitter.im/dotnet/orleans](https://gitter.im/dotnet/orleans)) and the
ecosystem as a whole feels to be gaining momentum.

------
jtwebman
The issue with this whole argument is you should use the right language for
the job instead of trying to recreate the wheel over and over again. Look at
Erlang and Elixir if you need highly scalable fault tolerant systems. It
doesn't mean you have to re-write everything in it, break up the application
into what makes sense. I guess not everyone thinks like I do.

------
achr2
This is a real problem. Not one, but two great open source WPF control
libraries I contributed to got 'taken over' (bought out I assume) by a major
component seller (XCEED). Of course the community contributions disappeared as
the company started selling updates as a pro version with their 'premium'
features.

~~~
pistle
Was AvalonDock one?

~~~
achr2
Indeed.

------
macintux
I asked on Twitter long ago for any prominent examples of open source software
that originated on Windows and transitioned to other platforms. I think after
some discussion we may have come up with an example. Maybe. I certainly can't
recall what it was.

~~~
saosebastiao
And to the other extreme, I know of quite a few open source projects on .NET
that have gone proprietary. ServiceStack anyone? Kinda leaves a little bit of
a bitter taste in the mouth.

~~~
locusm
Well, V3 is still open from memory and very capable.

------
AdeptusAquinas
Seems to me its more on the people who solve hard problems than on the current
crop of .NET developers - if you are writing a complex game/MMO, AI system or
what have you, and you choose to do so in Java, C++ or similar when C# might
be the better option, the faults on you not the .NET community.

If the whole pool of developers world wide was considered as a big pie, and a
certain section of that do these 'hard problems', the solution is to market to
them the strengths of .NET. Advocating other parts of the pie who build
enterprise apps and who already use .NET that they should suddenly start
writing actor systems 'for the good of the framework's OSS cred' seems silly.

~~~
ashmud
(Not directly addressing what you're saying.) A few MMOs have been written
using .NET.

[https://gamedev.stackexchange.com/questions/10247/mmos-
based...](https://gamedev.stackexchange.com/questions/10247/mmos-based-on-net)

~~~
AdeptusAquinas
As well as a tonne of games in general, which I'd argue are 'hard problems' as
well. Pillars of Eternity, Endless Legend etc. Though of course none of those
are OSS. Would be nice if at least parts of them were as it would certainly
help indie game devs like me :)

------
JustSomeNobody
Then don't use .Net.

While there are exceptions, the .Net community hasn't ever really been about
OSS.

------
Olivier26
What's missing is a .Net, open, powerful CMS à la Drupal 8. It's hard to
understand MS doesn't take this point seriously with its Azure strategy.
Orchard CMS is interesting but has little momentum and very few developers.

------
mcintyre1994
Hey, just a heads up - your website is completely unreadable on mobile.
[http://imgur.com/2VD1grY](http://imgur.com/2VD1grY) (can't zoom)

------
PretzelFisch
I think this is just carry over from years ago when many Enterprise level
company's legal team would not let you touch or use open source software.
Granted this was mostly do to Microsoft's FUD campaigns. Secondly Microsoft
provided a licence framework for .net and allowed third parties to sale their
solutions. Finally many .net users would wait for microsoft to provide a
solution because MS would offer a support and maintenance contract.

------
UK-AL
Because they'll stick to one solution. For distributed computing most people
use something like NServiceBus, which is by far the most popular solution.

------
bargl
Just to add to something I've seen is many places that the Microsoft stack is
used open source code is either frowned upon or completely banned.
Contributing your (company code) to that is not only against policy but
illegal if the company you work for owns the code.

I ran into this when working for the government, CSC, and another company.
They developed some cool stuff but just didn't want to share...

~~~
JustSomeNobody
And yet most of us developers learn everything we know by sharing knowledge.

So sadly, pathetically ironic.

------
MichaelGG
Edit: Perhaps this comment is gratuitously negative. Nonetheless I'm not going
to delete it because all these things contribute to why people have avoided
MS/Windows and hence .NET. (Mono's great and has worked well for me in some
scenarios, but, say, with ASP.NET/EF it hasn't been totally stable like the
CLR.) I've also invested a ton of time into using MS and promoting them (MVP
at one point), so I think I'm rather fair on my criticism.

Don't blame Microsoft? Ha, OK. MS is responsible for gimping the .net
environment to Windows with no technical reason. I'm a bit of an MS fanboy but
I'll admit deploying on Windows is a pain in the ass. Shit, it's just now
they're getting around to "Windows Server Nano'. OpenVZ's been around for a
long time, and MS just steadfastly ignored containers as long as they could.
Or DRBD - 2015, and MS ships nothing like this. Everything is commercial 3rd
party stuff.

Or look at SSH support. It's just now they decided to add that, despite
wanting to do it internally for a while. WinRM is annoying but that didn't
stop them from leaving it as the only option. And before that? Deployment was
what, exposing smb shares?

Or look at IIS. It's 2015, IIS has no real reverse proxy (ARR is a terrible
joke), and nginx only runs with limitations on Windows. Why is that? And FFS,
they're making you upgrade the OS to have HTTP2, and this whole time, you've
not been able to use SPDY. I've seen .net/win shops add Linux just for
nginx/SPDY, then realize the grass _is_ greener... Not to mention every other
thing, like Elasticsearch - Linux is the OS of choice for deployment, so why
bother dealing with it on Windows?

.NET was designed from the beginning to be cross platform and cross language.
The first book I read on targeting the CLR was for Component Pascal! The CLR
design is far better than the JVM. And around that time, MS had a version of
.net running on BSD. They _chose_ to ignore developers and thus everyone
flocked to the JVM. This is entirely MS's fault. They could have destroyed
Java (or at least started an arms race). The JVM was built solely for Java the
language, with no thought for running other languages the CLR was designed
explicitly with this in mind, yet almost no langs target the CLR. Explain that
without blaming MS.

Even now, they have F#, which is essentially better than C# in every way. How
do they promote it? By fucking up features in Visual Studio so things don't
quite work. By downplaying it as a language for "scientific" and "financial"
work. This is the team that brought generics to .net; without them they'd
probably have Java's lameass erasure model. And it looks like MS just
grudgingly throws a bit of F# support out as a bone. They don't get it.
Instead MS focuses on their line-of-business "Mort" developers. (The kind that
can pump out useless, scammy crap to get the Windows Store numbers up, or
contribute to more licenses.) They're focused on ops that suit companies that
run AD and Exchange. Excellent solutions for those companies; no real focus on
others. I'm sure it's been a great win for immediate licenses, but they
shouldn't be surprised they lost the war. (And note that via BizSpark, they're
_giving_ this stuff away and still can't make it stick.)

And it's not their fault people don't rush to implement code that will
possibly only work on Windows? Ha!

(MS has finally shifted to being open towards Linux because they wanna sell
overpriced VMs on Azure. And by overpriced, I mean 2x or more of GCE's cost,
with none of the perf benefits. And note this was not MS's first choice. They
wanted Azure to be a lock-in PaaS, and only when they realised customers
didn't want to deal with that mess did they go after IaaS and start
"embracing" open source and Linux.)

I apologize for the rant, but I do blame MS for doing all they can to drive
developers and ops away from Windows, .Net's only officially supported
platform, and thus away from .Net.

~~~
sudioStudio64
You make it sound like the ops for AD and Exchange type businesses is some bad
thing. It's a huge installed base. It's massive. they provide revenue. Open
source dev stacks build mindshare not direct revenue.

Yes, they were slow to adapt to the changes that happened in the last decade.
They seem to be turning it around. Why the emotions?

~~~
MichaelGG
I didn't mean that to sound bad. Exchange is great! Servicing those customers
is smart and fine. But MS focused on them to the point of excluding everyone
else, intentionally. (See the SSH announcement, how the tech team tried to do
it since v1, but management refused approval.) MS knew they had lock in, went
down that path _exclusively_ , and is now trying to catch up because the cool
kids left them behind.

~~~
sudioStudio64
I'll give you that. Cheers.

------
lectrick
I'm glad that Microsoft is absorbing enough young guys who went through
college realizing open-source is cool to actually influence their future
direction, but based on the entire self-interested history of Microsoft
([https://en.wikipedia.org/wiki/Embrace,_extend_and_extinguish](https://en.wikipedia.org/wiki/Embrace,_extend_and_extinguish)
or [http://www.pcworld.com/article/2901262/microsoft-tightens-
wi...](http://www.pcworld.com/article/2901262/microsoft-tightens-
windows-10s-secure-boot-screws-where-does-that-leave-linux.html) or
[http://techrights.org/2010/09/17/microsoft-management-
mocks-...](http://techrights.org/2010/09/17/microsoft-management-mocks-open-
source/)) and especially its deep insecurity around, AND open hostility
towards, open source, they can truly go fuck themselves.

I know the latter is a downvotable attitude, and I apologize because it's very
unlike me, but it is one of my few sore points, and this comes from _years_ of
web developer hell dealing with IE, _years_ of working at places which only
considered solutions that Microsoft invented, _years_ of dealing with
Microsoft BS left and right.

Before you downvote- If you _honestly_ consider yourself a developer who cares
about their craft and career, I want you to read these 2 books-
[https://en.wikipedia.org/wiki/The_Cathedral_and_the_Bazaar](https://en.wikipedia.org/wiki/The_Cathedral_and_the_Bazaar)
and
[http://www.paulgraham.com/hackpaint.html](http://www.paulgraham.com/hackpaint.html)
(yes, I just plugged a pg book on HN... It's part of why I'm here, actually!).
And THEN come back and try to downvote me.

~~~
bphogan
Lots of downvotes, but I can relate to what you are saying. 10 years of
working in a pro Microsoft organization trying to do PHP and Ruby development
showed me that developers and managers alike bought into Microsoft's ideas at
the time. Microsoft was good, Microsoft offered support, and open-source was
just for hobbyists. 10 years of working with servers that were hostile towards
openness, and 10 years of watching Microsoft blatantly steal from open-source
and not give back.

Now they're giving back. And that's great. But I was involved with IronRuby.
And I will never trust MS and open-source after that all went down. I'm a big
fan of Chocolatey.org, and I'm hearing that MS wants to do their own version
of that too.

The more things change...

~~~
lectrick
I knew I'd get downvotes, but we are real people in a real community and
feelings DO matter and have consequences which cannot simply be brushed aside,
and those are my honest feelings on it, and I lived through it and saw it all
(been a web dev, first frontend now backend, since '97). The last straw was
when Microsoft was SO guilty that the judge couldn't help but be biased, which
of course caused the antitrust case to get thrown out:
[http://www.politechbot.com/p-02198.html](http://www.politechbot.com/p-02198.html)
(note: I'm kind of against antitrust, but I am in favor of SOME punishment
when a corporation is provably just being a dick, period).

I also love Ruby (I'm now trying to get into Elixir) so the IronRuby stuff
resonates, I salute you.

> and 10 years of watching Microsoft blatantly steal from open-source and not
> give back

Oh you mean LDAP? ;) And whatever harm Outlook did to MIME or SMTP or... and
not even going to mention IE

------
FloNeu
Hmm... I only experienced one web-technology which was proprietary software
and had a strong 'opensource' community, being flash. Always seemed to me,
developers using proprietary technologies tend to not share their stuff.

------
jimmcslim
You want to see a weak OSS ecosystem, have a look at Delphi. Truly dire, but
not helped by extremely limited modularity and binary incompatibility between
versions.

------
therealmarv
An old fashioned opensource developer will not contribute to a closed source
MS foundation. Ok .net is now opensource but this step is too too late.

------
taylodl
1\. James Gosling 2\. Bill Joy 3\. Guy Steele

are why people took Java seriously and used it to solve hard problems.

------
jerven
Instead of re implementing could something like ikvm work for their
users/usecases?

~~~
hokkos
IKVM is slower than JVM and more error prone, so for big class of work why
bother if you can directly use the JVM ?

~~~
jerven
Yes and I completely agree, but a slow AKKA seems easier than rewriting if
from scratch in C#. e.g. seemed a smaller investment to me.

~~~
RogerAlsing
Akka.net wasnt really intended to be a complete port from the start, it was a
weekend hack from my part that then grew into what later became akka.net when
Aaron joined (akka.actor and akka.remote first). Then things took off and it
got a life of its own. Now there is an entire sub-ecosystem growing around it
in terms of persistence providers, testkits and dependency injection lib
integrations. AWESOME to see :)

------
platz
previous:
[https://news.ycombinator.com/item?id=7987113](https://news.ycombinator.com/item?id=7987113)

------
WorldWideWayne
To the author: Way to contribute to .NET's image problem with your negative
title. If your point is to get more people using .NET then you should have
gone with something positive that reflected the last section of your article.

To the mods here: Didn't think to change this one, did you?

~~~
dang
> To the mods here: Didn't think to change this one, did you?

We took "profound" out (we often remove superlatives and the like), but I
don't see anything else that needs changing here. It isn't gratuitously
negative to claim or discuss weakness.

~~~
WorldWideWayne
It was taken out after I said it then.

~~~
dang
Oh yes, I didn't mean to imply otherwise. If that's the bit you were objecting
to, I apologize for misreading your comment.

------
mshenfield
TLDR: .NET developers need to start tackling bigger problems and open source
the solutions.

------
bigdubs
The OSS "weaknesses" of .net are a chicken and an egg problem; the more people
who come from a community software background that use a framework, the more
community software there will be for that framework.

Having what reads as a very angry and negative blogpost about the state of
.net oss isn't really helping.

Contributing software is though, and that really should have been the focus of
the post, not how weak and terrible .net oss is.

Be the change you seek.

~~~
taco_emoji
I hate this attitude that negativity is unproductive. Pointing out a problem,
articulating its impacts, and hypothesizing about its causes are essential
steps to effective problem solving.

And I further abhor the notion that anger is not useful. Anger gets attention,
and passion elicits empathy and thoughtfulness. Anger is motivating. Anger is
a _rejection_ of despair, which is the real enemy of change.

~~~
bigdubs
Do you respond well when someone yells at you? Honest question.

In a lot of cultures anger is seen as weakness, it's the person giving into
negativity. It's also seen as hostile. I don't attribute "passion" to someone
who is angry. You can be angry without being passionate, and vice versa. Some
people are just bitter.

I'm honestly really surprised by this response.

~~~
taco_emoji
> Do you respond well when someone yells at you?

Of course not. But just because I don't like being yelled at in the moment
doesn't mean I don't need it sometimes. If someone's angry at me it's because
I've hurt them. I'm not going to scold them for yelling if I'm clearly in the
wrong.

> In a lot of cultures blah blah

Thanks for explaining that like I've only recently arrived on Earth! I'm
obviously not saying that anger is _always_ good or useful. But if the cause
is just and the pain is great, a well-articulated anger is going to be far
more effective than milquetoast pleading.

------
mkesper
The shortcomings of .NET’s open source ecosystem are your fault and my fault,
not Microsoft’s. Do not point the finger at them. Actually, maybe blame them
for Windows Server’s consumer-app-hostile licensing model. That merits some
blame.

Well, Microsoft itself created a whole ecosystem of the proprietary lock-in
type. Only very recently they seem to jump on the open source bandwagon. And
don't hold your breath for a free software MS office...

