[rjbwork]

We have this problem in the .NET world. Accord.NET is written by a brilliant academic and programmer. It's well written, and has a good API, but it is largely the effort of this one dude, with minor contributions from a smattering of other fellows.

Again, it is great in general, but it has bugs and rough edges here or there, and a lot of people don't trust it for production. I wish there was a way for people to be properly compensated for building and maintaining such vital scientific and mathematical computing software.

[devoply]

That's because people don't actually value free things, until they come to depend on them, and then there is no way for that to continue unless they pay. And even then they will pay the bare minimum to keep it going. That's the whole psychology behind open source. Companies could pay for it and those using it can more than afford to do so, but it's free, and apparently it's going to stay that way so why not ride that gravy train?

[hiram112]

.Net had always had a problem with open source because Microsoft implemented APIs and kept them closed source. Users ended up paying for it via licensing, MSDN, and Visual Studio.

I often see a lot of really mice Java frameworks with a .Net clone which gets much less attention (Hibernate, some of the Spring stuff, etc).

Whole I understand Microsoft is going their best to open up .Net, I'm hesitant to believe they'll ever get to the point where original implementations are done in it, and then ported to other langs - it just has a deservedly bad rep.

[rjbwork]

I started programming C# professionally in 2013...the ecosystem has grown and been improved by leaps and bounds since then. I'm hopeful, personally.

I think one thing that keeps C# things from being implemented elsewhere is that there are just very different styles between even C# and Java. Some fancy libraries will do lots of reflectiony things, build syntax trees, and compile on the fly for performance, allowing complex configuration to be simplified and get fast code at runtime. There's also a big culture of LINQ/functional style, and fluent interfaces in libraries, etc. which doesn't seem to be present in something like the Java community (at least until streams), whereas more dynamic/weakly typed languages don't have, for obvious reasons, a culture of strong typing and letting the compiler do the work for you.

Then when you go to the hardcore functional languages like Haskell, ML, etc. you don't have a culture of OO much, not to mention they just aren't used much in production environments.

So, you see a lot of things from elsewhere ported and brought to C#/.NET, but not a lot of things moving from C# to other ecosystems.