2011 In Retrospect: A Year of Writing F# Professionally

For the past year I’ve been working almost entirely in F# and have found the experience to be everything I hoped it to be and better. In just six months I was able to bring a research project to fruition which has since made our company millions of dollars. F#’s terseness made algorithms a joy to implement while F#’s type system made changes easy and regression errors non-existent. In fact, the few bugs we have had were either due to unexpected behavior in the GUI API, or in external C# libraries. Never before have I been so happy with the programming language I use on a daily basis. Never before have I felt so confident that when I make a change new bugs won’t be introduced. And no, we’re not using strict TDD, or any other strict development methodology. Simply leveraging the type system well in addition to algorithmic testing has proven to be extremely robust within F#.

It’s also been a great year for making new friends and meeting interesting people. The NYC F# community is thriving with an average of about fifty people attending any given NYC F# User Group meeting, many of them using F# at work for at least some subset of their projects. I hear the same experiences from many: Yes, learning F# isn’t simple, but the benefits in speed of implementation, LoC reduction, and correctness are huge. The excitement over type providers is also palpable. Finally, we’ll be able to extend our types out into data sources and eliminate new classes of error which currently occur at the border between our data and our applications. If you’re interested in following what we’ve been up to at the NYC F# User Group, check out our Vimeo stream.

I’ve also had the pleasure of speaking at a quite a few interesting events this year. One I haven’t yet written about is Monospace 2011.

Monospace, First Slide

Click For Video

In retrospect, it shouldn’t have been surprising that many in the Mono community hadn’t seen much F#.  They tend to go to different conferences and events than your standard .NET user and so hadn’t yet heard much about its benefits.  I will say though that it was a very bright group and I think many who speak on F# would find them  just as receptive as I have.  I do hope to see (and participate in) more outreach into the Mono world as I think we will find that there’s quite a few folks who would be happy to embrace a better way to program, if only they were shown the way.

Enjoy this post? Continue the conversation with me on twitter.

Tags: , ,

7 comments

  1. I’m also enjoying the unique features of F#, and the neat way it guides one from the imperative to the functional world. However, I’ve found F# fairly easy to learn. The only thing that I bump my head against from time to time, is the way it handles types & does type inference.

    I must also complain about how difficult it is to integrate with the DLR. From what I’ve learned at this stage, this is no easy task.

    Campfire Mono (in Cape Town, http://www.linkedin.com/groups?gid=3705428&trk=hb_side_g) will have its 1st F# evening, on the 25th of Jan 2012. I’m looking forward learning more about the language there.

    • Well, as F# is a CLR language just like C# and so the interop story is similar. You can’t have it both ways with dynamic and type safety, you need to pick :).

      Glad to hear about the event in Cape Town. I’d be interested in hearing about people’s experiences with F# there for sure.

  2. I am just about to embark on the journey of learning F#. I am learning mostly due to curiosity and also because I’ve heard so many good things about it. I am excited to learn it and you’ve definitely made a strong case for its use in a professional environment.

  3. Well said Rick!

    Bugs hate F# – the type system is like a death ray to them and expression oriented programming with immutable data leaves them fewer places to hide.

  4. […] 2011 In Retrospect: A Year of Writing F# Professionally (Rick Minerich) […]

  5. […] 2011 In Retrospect: A Year of Writing F# Professionally. F#’s terseness made algorithms a joy to implement while F#’s type system made changes easy and regression errors non-existent. In fact, the few bugs we have had were either due to unexpected behavior in the GUI API, or in external C# libraries. […]

Leave a comment