
F# 2014 – A Retrospective and Call to Action - plurby
http://reedcopsey.com/2014/12/31/fsharp-2014-a-retrospective-and-call-to-action/
======
jackfoxy
I'm sure I was in that room with Reed (the OP) a year ago in November.
Although I don't recall the details of the conversation, I do recall the
feeling within the F# community of accomplishment up until then (Nov. 2013),
and excitement looking forward. As the post summarizes, 2014 was a year of
great progress for both the F# language and the community. On the community
side I used to know personally or through social media most of the movers and
shakers. Today it seems like there is a steady stream of new contributors
posting OSS projects and technical articles, far too many for me to remember
or keep up with. Sergy Tihon's _F# Weekly_
[https://sergeytihon.wordpress.com/category/f-weekly/](https://sergeytihon.wordpress.com/category/f-weekly/)
covers more F# news than I can possibly track.

If you believe the future of software engineering includes strongly typed
functional languages, then F# is the place to be for many reasons:

1) Microsoft has settled into the role of corporate curator of the language,
core libraries, and core tools. I personally know the small MS team supporting
F#, and I can tell you they are motivated, enthusiastic, and very capable in
this role. I can also tell you the major players in the other MS language and
tooling teams take an interest in following the progress of F#. Not to mention
the world's most advanced quantum computing simulation compiler is written in
F#.
[http://research.microsoft.com/apps/pubs/default.aspx?id=2096...](http://research.microsoft.com/apps/pubs/default.aspx?id=209634)

2) F# is Microsoft's longest running major OSS effort, and the experience no
doubt played a role in how MS roled out the recent open sourcing of .NET and
commitment to making .NET cross-platform. Keep an eye on developments in this
area, it will strengthen F# as a cross platform language.

3) And finally if you have an interest in hacking on functional languages,
core components, libraries, tooling, etc., this is the place to be. You can
make OSS contributions which will make a difference to users around the world.

~~~
MichaelGG
It'd be nice though if MS would provide the F# team with more resources, or
actually do pro-F# marketing, instead of pushing the inferior-but-with-far-
better-tooling C#. For instance, it's embarrassing that MS doesn't have a
comprehensive web toolkit for F#, and instead just pushes a mashup of
TypeScript and ASP.NET. No doubt the community is great, but the effort that
goes into first class VS support seems to require a much larger team doing
rather unfun work. To date, it seems only MS has pulled this off.

------
fsloth
This sounds swell!

BTW: Tomas Petricek's "Real-world functional progamming" as well as "Expert
F#" by Don Syme are excellent introductions to the language.

~~~
melling
Are there any guides to getting started quickly on Mac and Linux? Is F# baked
enough in Mono to be useful?

~~~
mmavnn
There are definitely people using F# on Mono in production, but it is the
smaller brother still.

Having said that, nearly all of the "core" projects are now being CI tested on
mono as well as windows, and the fsharpbindings project provides
autocompletion for Vim and Emacs (+ powers the MonoDevelop/Xamarin Studio F#
support as well).

I'm having great fun writing F# code in Linux with Vim - now that .fsx (F#
script) files have proper #! support you can just write fsx files with full
highlighting, error checking and autocompletion in place and then run them
with supervisord.

~~~
vosper
What are the pain points (if any) that you've encountered? I've been wanting
to use F# on Linux for a while now.

~~~
mmavnn
The lack of good instructions is definitely one!

(Edit: although [http://fsharp.org/use/linux/](http://fsharp.org/use/linux/)
covers the absolute basics pretty well)

Up until recently, packaging was a bit of an issue, but recently the official
Mono repositories have started being much more up to date again, and now
include recent versions of F# as well: [http://www.mono-
project.com/download/#download-lin](http://www.mono-
project.com/download/#download-lin)

Getting vim support is still a case of cloning the project from github
[https://github.com/fsharp/fsharpbinding](https://github.com/fsharp/fsharpbinding)
and running make in the vim directory - Vim 7.4+, make, python and a couple of
other vim plugins required.

After that, things can start getting pretty nice. For (my only public)
example,
[https://github.com/mavnn/Advent2014](https://github.com/mavnn/Advent2014)
shows how you can use fsx scripts and paket (a package manager compatible with
nuget.org and taking source dependencies from github) to create a nice little
project without needing to get into any of the Visual Studio project file
nastiness. Of course, if you need to work on an existing project, the Vim
bindings know about how to handle that too - but actually editing project
files is still a pain.

One word of caution: there's currently a bug in the packaging for rpm: I'd go
with Debian/Ubuntu packages at the moment. And as a final option, building
from source is slow but has become pretty reliable over the last year or so.

~~~
vosper
Thanks for that. Having got past the setup and configuration issues, have you
experienced any problems with the packages that are available? What's the
ecosystem look like for F# on linux?

~~~
mmavnn
Packages generally work fine, although if they rely on native binaries they
often require a bit of tweaking to point at the Linux .so rather than the
windows .dll. That's uncommon in the .net world though.

The ecosystem is huge; [http://nuget.org](http://nuget.org) hosts the main
.net package collection, and it fairly comprehension. Also, to be fair to MS
the standard library is pretty "batteries included"; it just doesn't always
have what I would consider the nicest APIs.

------
jarcane
Glad to hear they're doing well. I've been slowly tinkering with the
tryfsharp.org tutorials and I'm liking what I see. It might be the first MS
language I've actually liked since QBASIC.

~~~
lennel
I have been playing with F# a fair bit and I am totally in love with the
language. I wish it was a jvm language given that is what I ply my trade on
(and no scala is not as elegant imo)

~~~
edgyswingset
While it's not an ML-style language, I've found that I enjoy Clojure the most
when it comes to JVM alternatives. The lack of F#-style pattern matching makes
a few things feel less elegant, but the general structure of my code is
extremely similar.

~~~
jarcane
There is core.match[1], and between the restructuring bind, multimethods, and
the ability to create polymorphic functions like _hello_ in this example[2],
you can replicate a lot of common FP idioms reasonably well. It's not pretty,
but Clojure generally isn't.

[1]
[https://github.com/clojure/core.match](https://github.com/clojure/core.match)
[2] [https://github.com/lazerwalker/clojurescript-
koans/blob/mast...](https://github.com/lazerwalker/clojurescript-
koans/blob/master/src/koans/meditations/09_runtime_polymorphism.cljs)

------
inchforward
I recently tried to teach myself F#. Although the community is very small
compared to others, the folks I ran into were warm and enthusiastically
helpful.

Most of the intro texts I tried were not good. I found a fantastic one, but it
is an outdated, abandoned text that must be accessed through the Internet
Archive [1]. I tried to contact the authors to see if I could help updating
it, but received no response.

The language has a large surface area. It is not uncommon to think you have
learned a lot of F#, then read a blog post by someone full of F# code and
think "what the heck is that symbol?"

I agree with others that note the MS influence. Things are definitely getting
better, but you will have an easier time if you are in the MS ecosystem.

For what it's worth, I wrote a blog post [2] that might be helpful if you're
trying to get started.

[1]:
[http://web.archive.org/web/20110715231625/http://www.ctocorn...](http://web.archive.org/web/20110715231625/http://www.ctocorner.com/fsharp/book/default.aspx)
[2]: [http://inchingforward.blogspot.com/2014/11/recommended-f-
beg...](http://inchingforward.blogspot.com/2014/11/recommended-f-beginner-
resources.html)

~~~
jackfoxy
In my opinion the best way to learn F# is to work through the Wiki Books
tutorial,
[http://en.wikibooks.org/wiki/F_Sharp_Programming](http://en.wikibooks.org/wiki/F_Sharp_Programming),
and then work through Scott Wlaschin's series on _Thinking functionally_
[http://fsharpforfunandprofit.com/series/thinking-
functionall...](http://fsharpforfunandprofit.com/series/thinking-
functionally.html)

[http://fsharp.org](http://fsharp.org) and Scott's site are the go to sites
for all things F#. The Twitter hashtag #fsharp is sure to get you retweeted
and/or responded to, and finally any well-formulated question to stackoverflow
with an F# tag will get a speedy response.

