What is Reddit's opinion of Get Programming with F#: A guide for .NET developers?

From 3.5 billion Reddit comments

So here's my 2c FWIW.

TL;DR I strongly recommend trying F#, even though I'm still learning it. As I'm still learning it, take my opinion with a pinch of salt. For context, I'm a Ruby dev mostly with a fair bit of TS/JS, C# and some Go experience and I wanted to get into FP for similar reasons (typing, mutability issues, among others). So, I did the thing any rational lazy programmer would do and became an armchair expert in a few different languages (i.e. I watched YouTube and read blogs for a few weeks with a bit of tinkering on the side).

I passed on these languages:

• Elm - too purist. Elegant and safe, especially the MVU model but it feels very dogmatic. The language creator seems to hold a tight leash on the language and won't let anyone else contribute JS interop modules (AFAIR). Big drama if you Google enough. Frontend only too.
• ReScript/ReasonML/BuckleScript - OCaml for the frontend that self-destructed. Got really excited about this after Elm till I realised there was a political falling out that split the community (and repo) in two and left a flaming mess behind. There are actually videos and articles trying to explain what language is what and how it's not the other one. Not going near that till it sorts itself out.
• Elixir - not statically typed. As a Ruby dev Elixir seemed amazing. The Erlang VM also seemed nice and sparkly. People that work with it seemed to love it. But I just don't want to do dynamically typed code anymore. I don't want unit tests or error notifiers to tell me I made a type error. I want the compiler to do that. I want my IDE to quickly tell me the type of something without doing lookups or using fuzzy tooling (which Elixir kind of has I think).
• OCaml - shaky ecosystem, poor tooling and libraries. So OCaml I actually started learning because it just clicked in terms of FP + pragmatism. But the tooling is a bit of a patchwork, the libraries and docs are okish only and AFAIR it still has a global interpreter lock like Ruby, something I won't put up with again without an excellent reason. Like all the languages here, some people love it and have been very successful with it but I wanted something a bit more beginner friendly (i.e. solid) ecosystem wise.
• Haskell and Rust - the nunchucks of their respective areas, very powerful, very impressive, but learning's going to hurt. I looked at them, admired them and then moved on.

The reasons I passed on those languages are largely the reasons I chose F#:

F# is about getting things done and getting them done right with a functional-first but pragmatic approach. The themes of F# according to its creator are for it to be "succinct, robust, performant" which I think is true but being modest. It's what happens when a language is designed with a laser focus on pragmatism and even a disdain for anything that isn't useful or practical. I believe it will tick all your boxes.

More than that, you seems to get your cake and eat it too:

• You want Elm's beauty, MVU pattern and safety without tossing out the whole NPM ecosystem? Enter Elmish+ Fable- you write F# (full F# with almost all the .Net base classes) and its translated to JS. Write MVU frontends (like Elm) using React to render a VDom. Also use whatever other JS libraries you want in type-safe F#. Just beautiful. Plus, you can very easily share code between the backend and frontend. All your domain models, validations, service code for calling other APIs - no duplication, no synching up in two different languages. I could go on for ages, it's really impressive.
• You want OCaml's amazing type system with little to no annotations but full static typing? You got it. You don't get type classes because, well, pragmatism but you get a bunch of other cool stuff.
• You want a huge ecosystem of solid libraries and a solid runtime? .Net is very mature and battle tested. Most things accessible to C# are accessible to F# too and .Net Core has made it open source and cross-platform (I code on Linux with no issues). Seriously, I know there's still a Micro$oft stigma and in previous it was deserved but I don't think it is anymore. .Net Core is fantastic.
• You want Rust/Haskell's performance? Well, write Rust or Haskell. But F# on .Net is quite impressive performance wise and for a lot of scenarios close enough.
• The community is great and the documentation is quite good for an FP language. Learning resources are also very good.

As for not being multi-paradigm, F# is but I don't think that should be considered a drawback. If you go look at the language benchmarks game and look at the actual code samples you'll see that a lot of the fastest FP languages' code samples are written, well, not very functionally. There's mutation and loops and imperative stuff everywhere. Because imperative coding is generally still faster and more efficient than FP coding. I'd advise you to embrace functional coding as another tool, not a religion. Sometimes object-based code is appropriate and F# allows that, because F# is about getting things done, not breeding disciples of a purist pursuit. F# is multi-paradigm the same way JS/TS is functional. You can do it if you really want but you're going against the grain and it will guide you towards functional-first coding.

Here are the resources I recommend to get started:

• F# for fun and profit - a great website with a collection of things
• The author of that site wrote a book about DDD and F# combined which I found great as it gradually introduces F# syntax as well as its features in the context of a business application.
• The blogs at Compositional IT, an F# agency
• The found of Compositional IT also wrote a book that Don Syme, the creator of F#, has recommended in multiple talks.
• The Elmish book is a great tutorial on Elmish in F# that walks you through building Elm-like apps in F# for the frontend.
• The SAFE dojo is a tutorial repo for getting started with fullstack F# apps using the F# "framework" (although it's more of an unopinionated template/collection of libraries for writing fullstack apps). I'd suggest starting with Fable/Elmish before diving into a full SAFE stack app though.

P.S. Ruby is as functional as JS. Probably less so in fact. It's also smothered by the behemoth that Rails became - it's hard to find good Ruby code because most of it is Rails code or Rails-compatible code and if you're interested in FP you won't like it. It will always have a special place in my heart because of what it enabled me to do but I wouldn't recommend it in your case.

I used Get Programming with F# and Domain Modeling Made Functional to learn F#. It worked out great.