[bad_user]

From my experience thus far the .NET community is not friendly to open-source. Yes, open-source projects do exist, but those are few and far between, being either ports from the Java world, or throwaways that failed as commercial projects. There are also instances of bait and switch, as in projects starting as open-source being closed later (e.g. ServiceStack). Also compare RoboVM.com with Xamarin.com. If you'll dig into the details, you'll see similarities (like comparable pricing), with one important difference ... RoboVM is open-source and you only need a subscription for extra goodies. Same thing with IntelliJ IDEA versus Visual Studio. I find this difference to be the essence of the .NET ecosystem versus the others.

You mentioned NuGet, which is like `gem`. Well, the build tools in .NET land suck really badly. You've got MSBuild, which is like Ant or Make and that's what everybody uses, because development in .NET-land is Visual Studio driven. What you don't have for example is something like Maven (or SBT, or Lein). There's been nothing like it in .NET land. The ASP.NET developers have been building an alternative, in the form of dnvm / dnx / dnu, but it's just getting started, being a work in progress and feeling hack-ish and incomplete. Fingers crossed.

Anyway, in spite of the fact that there are companies that have built their own build tools because the current status quo sucks so badly (and I know more than one), the .NET community is filled with closed-minded folks that will never admit that their tooling sucks and I'm even including Visual Studio itself in this mix, since an IDE that needs extra investments into ReSharper is not that good in my opinion.

And then there's Mono, the current cross-platform implementation and the answer to folks that want to develop and deploy on Linux, OS X, Android or iOS. Except that Mono is and has historically been full of bugs. Like if you want to do server side development and deploy on Mono, just forget about it. And these days Xamarin is focusing only on mobile development and the community is dead.

> Would, say, a Ruby or node.js-oriented web developer find the F#/.NET community lacking, incomplete, unfriendly, uncool? Is there even a community to speak of?

The answer in my opinion is yes. This may change, given recent efforts by Microsoft, however evolution will be slow because the whole ecosystem has to change, not just Microsoft.

[moonchrome]

>being either ports from the Java world, or throwaways that failed as commercial projects

This is blatantly false. Just on my current project I'm using :

* OpenTK - opensource API around OpenGL

* ReactiveUI - opensource MVVM framework using RX for databinding

* Command Line Parser Library - opensource, does what it says

* NLog - logging library

* sqlite-net - micro ORM for sqlite

I excluded :

* RX - opensource but comes from Microsoft so not a community, but also a nice counterexample of porting from .NET to JVM as RX was innovated on .NET and later ported to other platforms

* system.data.sqlite.org - opensource .NET sqlite implementation, arguably a port from a bigger project

And that's just the references I have in my current project, there are a bunch of open source .NET projects that do cool things, for eg. MonoGame, bunch of MVVM frameworks, etc.

[reactor]

You are just proving what OP says "the .NET community is filled with closed-minded folks that will never admit that their tooling sucks". Unfortunately, you are not seeing the whole picture.

[moonchrome]

What ? I developed web applications with Clojure/CLJS Python/Django, I did C++ development for years and a large part of the code in my current project is in Python because the tool we use (Blender) uses Python as a scripting language.

I agree that .NET has less opensource tools because a lot of things are just provided by Microsoft out of the box, and there are many areas it's not popular - but there are many OSS projects and they match the things I saw in Python and Clojure community.

I would say his posts proves another point - a lot of people in open-source are unfriendly to .NET because of Microsoft origin and they like to spread FUD. I remember when Mono was getting started and every thread on every news board would bring up how it's "patented/copyrighted" even when Microsoft gave .NET community patent promise and made CLI a standard.

When I contributed patches to Mono and talking to other .NET developers on social networks I never saw this "unfriendliness towards OSS".

[crdoconnor]

>there are many OSS projects and they match the things I saw in Python and Clojure community.

Where's the Django for .NET?

[moonchrome]

ASP.NET MVC ?

[crdoconnor]

Does the same sort of thing, but is not nearly as good.

[rattray]

Theres a lot of negativity here that I won't comment on, though I'd be curious to hear where the author is coming from (what was the source of his/her experience with .NET). They may certainly know more than I do.

As for open source community, we have real data available so there's no need for debate: http://githut.info/

As of Q4 2014, C# was number 10 in langs by number of active repos, with 56k (compared to, say, 85k for C++). Came in ahead of ObjC, R, Go, and others.

It may not be JavaScript, but it's active. If you look at the other stats you'll see these really aren't dead repos either.

[edgyswingset]

> since an IDE that needs extra investments into ReSharper is not that good in my opinion

A lot of people choose ReSharper for "nice" things that often times aren't buying them a whole lot in terms of productivity (e.g. "turn this foreach() loop into a Select() statement" really doesn't buy one much). I'd hardly say that one needs ReSharper to get the full Visual Studio experience.

[marpstar]

With the latest versions of Visual Studio (>= 2012), I agree with you, but 2010 and prior still didn't have a lot of the Go To Symbol fuzzy search features that VS now has out of box.

Regarding the LINQ refactors you mentioned, I'd say those are less about gaining productivity than it is to educate the developer in how code can be refactored. A lot of times, those LINQ refactors turn out considerably less readable, but it's a moment to learn other ways of solving problems.

[tdestan]

>... and I'm even including Visual Studio itself in this mix, since an IDE that needs extra investments into ReSharper is not that good in my opinion.

That's a fair point, but even so, I've yet to find an IDE/editor/whatever that compares favorably to the combination of Visual Studio + Resharper + NCrunch.

[rjbwork]

I'm one of those devs who is loathe to admit our tooling sucks. I hate MSBuild. Love NuGet, it's so much more than just a library package manager. Chocolatey, plugin provider for other apps, and you can even use it to dynamically download behavior at runtime and load and execute it. Love VS and ReSharper. I used VS for about 1.5 years w/o resharper and thought it was loads better than everything else i had done, and resharper just makes it better.

I am really a total C# fanboy, though was reared on unix and c/c++/python/java.

[Dn_Ab]

> > Would, say, a Ruby or node.js-oriented web developer find the F#/.NET community lacking, incomplete, unfriendly, uncool? Is there even a community to speak of?

> The answer in my opinion is yes. This may change, given recent efforts by Microsoft, however evolution will be slow because the whole ecosystem has to change, not just Microsoft.

A suspicion gnaws at me. I try to rid myself of it but alas, it holds fast and unyielding. That suspicion being: you know very little about the F# community. What statements you make, they seem descendents of generalizations from your experience with the .Net community. Happily, F# is not like the stereotypical .NET community (I must be so specific, in order that I not offend the subset to whom your claims do not apply). There is a strong culture of embracing open tools and code; Microsoft is not looked at for direction beyond what basic support they provide.

The community is neither lacking nor is it unfriendly. It is small, yes. Uncool? Opposite of! But opinions run with tastes. Incomplete is a tricky matter. Certainly it's not going to have as many libraries as Python or the JVM, but neither is it some kind of backwater.

There are excellent build tools like FAKE and paket. Awesome ideas like—why, take a look at how fantastic the HTML type provider is, and it works in real life too! Most of the time =) [http://fsharp.github.io/FSharp.Data/library/HtmlProvider.htm...]

There are tons of cool libraries available, most of them open source, with generous licensing terms. Stuff with Haskell heritage like fparsec, fscheck, the blazing fspickler combinators (serializer) or more computation oriented tools that let you target and run on the GPU or Here: Automatic Differentiation (after which, loss minimizing Machine Learning algorithms are made much easier) [http://gbaydin.github.io/DiffSharp/]. Or the DataFrames library: http://bluemountaincapital.github.io/Deedle/

Type providers also allow easy use of UI builders. Web frameworks and also, js targeting can be reached here: http://fsharp.org/guides/web/. You can target Unity3D and apparently, also the Unreal Engine.

There are interesting projects looking at distributed computation (https://github.com/fsprojects/Cricket and ilk) or light weight concurrency, in Hopac's take on the Pi Calculus.

F# was one of the earlier languages with light weight threads, a solid async story and first class events (pre-reactive trend). Active Patterns (not unique to F# but more common in) take us close to Predicate Dispatch (http://c2.com/cgi/wiki?PredicateDispatching). There is much more I could list and hopefully, I have piqued some interest.

But it's not perfect. Adding Functor support would be very useful. A while ago, in an early Active Patterns paper, there were hints that generalized algebraic datatypes might soon be introduced. Nothing came of that. Higher kindedness is nice but not as much missed—it is my suspicion that, the gains from each level of types that can be parameterized over, quickly saturates.

There are lots of cool projects going on in F#, and while, as a language it's definitely not as powerful as say Scala or Haskell; the tools, libraries and environment, alternate ideas as well as breezy syntax, do make up. Having used them all, I wouldn't say it is any less expressive, it just...prioritizes differently beyond the core functional ideas (REPL, sum/product types, currying, closures, point free application where possible, Hindley Milner inference, immutability by default, pattern matching and deconstruction, etc., etc.).

It strikes a lot of middle ground across many planes, in terms of pragmatism vs functional purity—that is its ML heritage (but perhaps even more so, bargained in exchange for the .NET ecosystem). Most functional languages focus on types in terms of algebra, F# does too but only basically, instead it focuses more on the easy bridging of types with unruly data.

[reactor]

I couldn't agree more. My experience exactly.