
F# Survey 2015 Results - bursurk
https://docs.google.com/forms/d/1Ly_W1ZUH3x_ph4H6I_64uvEib2brDx34j-FoaZkeYLI/viewanalytics
======
saosebastiao
I've been working with the language for a few months. Overall, I love pretty
much every single aspect of the language. I am even starting to feel like the
few things that I would like to have aren't necessary (such as HKTs and ML-
style functors). In terms of platform support, F# has done almost everything
right (I feel like Scala made boat loads of bad compromises to support Java
interop, which I don't find at all with F#). There are entire classes of
frameworks for web and mobile development in C# that are made obsolete even by
the simplest language-level features like Agents, ADTs, Computation
Expressions, Active Patterns, Type Providers, etc.

My disappointments so far are super frustrating though. Like Jarcane, I've
found quantity of documentation to be an issue. Most tutorials assume that you
a) already know C# and b) are using VisualStudio, and the whole ecosystem is
still very Windows-centric. It is nearly impossible to learn the language
without an IDE, and all of the non-VS IDEs are pretty crappy in terms of F#
support. The whole msbuild or whatever it is behind the scenes doing the
building is completely opaque and incomprehensible. The compilation order
issue (you basically have to tell the build system the order of compilation,
with no cyclical dependencies) is pretty difficult to understand and sometimes
very difficult to work with. It also makes code organization very unintuitive
(you can't put code in directories?!).

All in all, it is pretty frustrating, but at least they got the language
right. The frustrations will likely go away in time, so I'm willing to put up
with them for now. Maybe I'll get good enough at the language to actually fix
them :)

~~~
muraiki
Something that's kept me from pursuing learning F# is whether I need to know
C# and/or Windows development, plus concerns about lacking access to Visual
Studio.

I'm learning Scala now and found that it's relatively approachable without
knowing Java, but Clojure was definitely easier to approach from the "never
used Java" perspective. But it seems like F# is a much bigger leap to make for
someone with no MS stack experience than Scala/Clojure for someone with no JVM
experience.

It seems like Scala and F# are the only real choices for typed functional
languages in relatively common use in industry (in comparison to Haskell and
OCaml).

~~~
jackfoxy
You definitely do not need to know C#. Knowledge of the .NET Framework or Mono
is however desirable (which if you do not know C#, you are unlikely to have)
in order to get things done.

Learning on anything other than Visual Studio will probably be challenging.
You know you can get full Visual Studio 203 for free now?
[https://www.visualstudio.com/en-us/products/visual-studio-
co...](https://www.visualstudio.com/en-us/products/visual-studio-community-
vs.aspx)

------
jarcane
It's interesting to see that a lot of the respondents wrote basically the same
thing I did: the documentation for actually making even a simple application
in pure F# is basically non-existent.

~~~
nbevans
That's not true. There are loads of web learning resources for it.

~~~
jarcane
I literally know of only a single pure F# application tutorial on the
internet, Scott W.'s Calculator, and the style reads more like Java than any
idiomatic FP code I've ever seen.

There's scattered bits here and there elsewhere, but none actually present a
complete picture of the process. They wind up resembling, as one survey
respondant suggested, feeling like the old "how to draw an owl": Step 1) draw
the eyes, Step 2) Draw everything else.

~~~
pjmlp
From Microsoft itself

"Real World Functional Programming" \- [https://msdn.microsoft.com/en-
us/library/vstudio/hh314518%28...](https://msdn.microsoft.com/en-
us/library/vstudio/hh314518%28v=vs.100%29.aspx)

Some higher level presentations -
[https://channel9.msdn.com/Tags/fsharp](https://channel9.msdn.com/Tags/fsharp)

Then there are the Erik Meijer teaching FP series, even though they are based
on Haskell, given their ML common roots is also a good series to follow.

[http://channel9.msdn.com/Series/C9-Lectures-Erik-Meijer-
Func...](http://channel9.msdn.com/Series/C9-Lectures-Erik-Meijer-Functional-
Programming-Fundamentals)

~~~
mineo
This might sound a bit stupid, but I was looking into F# a while ago (26 days
ago, if the timestamps of the few files I wrote don't lie :-) ) and now I'm
wondering I could have found those things (especially RWFP because I usually
don't like learning from videos) if I start on fhsarp.org?

[http://fsharp.org/about/learning.html](http://fsharp.org/about/learning.html)
does not list them, and going from
[http://fsharp.org/about/index.html](http://fsharp.org/about/index.html) via
the "Language Reference" link to [https://msdn.microsoft.com/en-
us/library/dd233181.aspx](https://msdn.microsoft.com/en-
us/library/dd233181.aspx) doesn't list RWFP in the sidebar anymore.

------
MichaelGG
That hiring myth is a killer. Project I'm helping on would have been much
better off with F#. But the CTO is very scared they wouldn't find "F#
developers". Despite any C# dev worth hiring would not have a problem
learning. Despite that his second hire just happens to know F# anyways.

There was also concern that "valuation of the company might tank due to use of
non-standard code".

I think these are incorrect ideas. I'd take some pay cut to work on F# code
instead of C#. Everytime I write anything in C#, I keep thinking how easier
and shorter it'd be in F#. Just this week, we lost a whole day to a mutation
bug:

    
    
      inputParam.Bar = Baz // oops, now we just updated the callers notion of that .Bar property
    

Yeah, we coulda caught it in code review. We could have tried to make things
readonly, but C# 5 still doesn't have a simple readonly record concept like
F#.

I'd guess that if you advertise an F# job you're going to get more good
replies, because people want to work on F#. And you can still leverage
someone's knowledge of .NET, the frameworks and libraries and all that. So
it's less risky than using, say, Haskell, where you're all alone - F#'s still
compiling and consuming IL even with all its magic on top.

When I was 7 years younger, I predicted that obviously F# will take over at
least 20% of C# development 2010 - it was just too awesome for people to
ignore. There was no reason _not_ to use it apart from legacy or bad
management, but no one could ignore such benefits. I have, uh, recalibrated
since.

(The biggest technical hurdle I had was frameworks that didn't target .NET,
but targeted C#. They'd depend on undocumented output of the C# compiler
expression trees. Those were a bit of a pain to fix, but not too hard. Another
annoying thing is the MVC teams decision, since C# doesn't have tuples, and
dictionary creation syntax is too clunky, to pass arbitrary types as
parameters (@Html.Foo(new { this="is", just="some", anon="type" }). Then they
go using reflection to inspect the properties of the type. That's just dumb
and has caused tons of bugs. And would have been avoided had C# a nice way to
write lists or tuples or something. But the MVC team wanted it to "feel like
Ruby". This isn't _hard_ in F#, it just looks as bad as it is.

~~~
IndianAstronaut
I have tried to convince my manager to let us implement chunks of F# code into
our projects. It would make development times much shorter and reduce
complexities in our application. Despite his personal interest in functional
programming, he is still hesitant to incorporate it.

------
aurora72
Interesting note from TIOBE about F# just yesterday:

March Headline: All time high for F# at position 11

Microsoft's programming language F# is about to sneak into the top 10. It is
not clear why F# is gaining popularity. Possible reasons might be the F# web-
programming framework WebSharper and the promotional work of the F# Software
Foundation as Tomas Petricek (author of "F# Deep Dives") stated in an
interview about 2 weeks ago.

~~~
sago
Except that the April data is out now, and it dropped to 14, so 'about to
sneak into the top 10' seems a bit premature, in hindsight.

~~~
igouy
Except that #14 is for April 2014.

The Tiobe score for F# improved by +0.23% (which might be from March 2015 to
April 2015).

 _afaict_ the data tables for previous months are unavailable, and not
recoverable from the Internet Archive because of the way the data is
displayed.

~~~
aurora72
Yes they are not recoverable but try google cache. Actually I've used google
cache to bring back the headline article.

------
_stephan
If you have used F#, you can take the survey here:
[http://fsharpworks.com/survey.html](http://fsharpworks.com/survey.html)

------
donkeyd
> How would you classify your day job? - Data or anal

I guess you gotta be anal to do data.

~~~
stinos
:] Actually came here to ask if anal is really the typically use abbreviation
of analysis/analytics/... For _some_ reason I doubt it.

------
jskonhovd
I have only used F# for a couple months, but I have a decent background in ML
thanks to the Dan Grossman's incredible programming languages course.

[https://www.coursera.org/course/proglang](https://www.coursera.org/course/proglang)

I would say that if I can use F# Data or Deedle on a project, I will. Those
tools totally make it worth learning a little F#.

[http://bluemountaincapital.github.io/Deedle/](http://bluemountaincapital.github.io/Deedle/)
[http://fsharp.github.io/FSharp.Data/](http://fsharp.github.io/FSharp.Data/)

------
thanley
[https://sergeytihon.wordpress.com/](https://sergeytihon.wordpress.com/) is a
good resource for F#

------
JackMorgan
I made a language safety score to help explain F# to myself and coworkers, and
its helped make strong inroads with them. With the defaults, F# is as close to
C# in safety as C# is to JavaScript. [http://deliberate-
software.com/programming-language-safety-a...](http://deliberate-
software.com/programming-language-safety-algorithm/)

~~~
junkyarddog
I would say F# is much safer than C# as it has immutability by default, non-
nullable reference types, Option types, units of measure, and stricter casting
rules.

