sp33der89

F#, I can target backend and frontend, using battle tested libraries. Static typing that gets out of my way and has very good domain modeling capabilities. Good enough tooling.

Scala as a close second!

MS management seems like a wild place to me, but I only have experience with the OSS side. Between X amount of GUI frameworks, adding every feature under the sun, OSS controversies, quite unpredictable at times...

I think the community plays a more important role in what they want for F#. First there was a focus for Fable and targeting frontend, and now you can target Python and potentially use F# there instead of Python.

But the community is interested in a lot of things, so F# doesn't have a real "singular" focus, like Go(backend systems/api's).

F#'s ties with Microsoft is a big productivity boon, but also seems to work against it sometimes...still the community really gets stuff done instead, because it's such a practical language!

This could be very cool combined with something like Pulumi!

> since then various factions that emerged have only come to hate each other more

There are (recent) threads out there on the interwebs were people suggest using Cats Effect or ZIO(or as a better Python) without it being hateful. And there are enough people not going at each other because of some effect library.

I am not saying everything is good, there is enough room for improvement, but I feel like you have an outdated view of the Scala ecosystem. For example "ecosystem firmly split between ZIO and Cats" doesn't ring true either, there are tools/libraries like, scala-cli and Mill or tapir coming out that offer a more pragmatic experience, without locking you down to the pure FP dogmatism.

> a prominent "middle ground" member of the community disappeared after accusations that he was a sexual abuser

Yes, this stirred up a lot of controversy and I found this indeed a failure of the Scala community, I don't think that means things haven't gotten better though.

That thread is 4 years old...I wouldn't say that's reflective of the current situation, nor do I find "probably won't get better" a great take, because the Scala OSS situation tries to not-repeat-mistakes.

Hell the worst thing the Scala Discord deals with it are spambots!

I think you can use `v` for that in Helix.

Helix(https://helix-editor.com/) and Kakoune(https://kakoune.org/) both have a keybindings that are discoverable through their UI. Helix has this small pop up that shows you the keys that you can chord and what command they perform. And kakoune has a Clippy like thing.

You could also use a thing like a neovim distribution that has which-key support.

SBT is a lot less scary these days IMHO.

Ah very true, I like types and all that jazz, I'm mostly looking for a nice developer experience and don't know that much about either platforms.

I personally like and use DaisyUI for such "components" type of things: https://daisyui.com/

Does its job, gets out of my and helpful docs as well.

Big fan of Helix and Kakoune-esque keybindings! I like that they have tree-sitter and LSP as first class citizens, both extremely nice.

I hope they figure out the plugin system, but honestly, if they'd just add something like Telescope(an absolutely amazing neovim plugin), I'd be more than happy enough.

As somebody who's in this exact same position(well not really corporate), I feel the same way about this guide.

Thanks so much the author!

Check out: https://laminar.dev/ or https://github.com/PurpleKingdomGames/tyrian Event ho it's a React wrapper it's still a really good one: https://github.com/japgolly/scalajs-react

The downside of this approach is the ecosystem isn't that big compared to JS.

Love the org support in LogSeq! Probably the deciding factor why I chose it over Dendron(which is great as well).

LogSeq also has experimental Android support: https://github.com/logseq/logseq/releases/tag/0.5.8

Last time I tried nimlsp was in June-ish, using neovim. It was an okay experience, but things broke down quickly when using macros and I got red squigglies everywhere because things rely on a certain setting. Compared to the VSCode experience, it's really lacking though.

It's certainly been getting better and the focus is also on tooling, so I'm hopeful!

For me it's the intersection of performance like Rust, the readability like Python, the ability to generate native executables without dependencies like Go and a very cool type system. All while delivering fast compile speeds!

The adoption isn't like Rust and Go, but Nim is growing: https://github.com/nim-lang/Nim/wiki/Organizations-using-Nim and the community is active across all socials.

Some downsides: not a big ecosystem(tho can piggyback off C libraries) and tooling isn't great.

Advent of Code would be a great way to dip your toes into a language you might not really care about!

With .NET and React in your toolbelt, you already got easy to deploy, powerful and job market. What else do you want? :P

Could always try out F# if you think the grass is greener out there.

You might like Scala 3 starting off quickly with: https://scala-cli.virtuslab.org/ too (maybe!).

That's some great info, thank you!

And how has your experience with dotnet been?

Yeah, I would love it if I could just write idiomatic code for the platform and it'd be just fast enough!

I've seen the posts about all the speedups each new version of .NET gets and I'm just wondering, was .NET just alright in performance before all this? Is that the reason they can get all these speedups? :P

I'd be interested in some JVM vs .NET 6 benchmarks too, which platform to chose when.

EDIT: I know about the benchmarks and I also feel like sometimes these benchmarks are really optimized in a non-idiomatic way. I would love to know how performance idiomatic Java/.NET code is and if one is to start a new project today why one would choose the JVM over .NET or when someone would chose .NET over JVM.

Oh, don't get me wrong, I definitely think dotnet is an advantage for F#, but when I learned F#, a lot of beginner resources didn't teach you how it dotnet works. I think it got easier from .NET Core 3 onwards tho.

F# is one of my favorite languages! I'd recommend to everybody to try to learn it.

But I kind of don't like the .NET ecosystem, it seems constantly changing but also at the same time incredibly stable? I can't really explain it well, but I hope F# learning resources not only focus on introducing FP concepts extremely well(which they really do!), but also learn how to deal with .NETisms.

Some things I didn't get and felt like I had to shift through C# tutorials/resources to understand:

- What exactly is a solution? Is a solution just a bunch of fsproj's en csproj's together? - What is an .NET Runtime assembly? - Do I use NuGet or Paket? Paket seems to be the most recommended, but apparently NuGet has caught up?

Now a lot of these questions are trivial, but I felt like that the docs teach you really well the simplicity, power and awesomeness of F#, but they don't really tell you how to deal with the beast that is .NET

There have been a lot of awesome resources that do teach you these things, and I'm looking forward to seeing more of it from the sweet F# community. F# 6 seems like another step in the right direction!

I've read that Clojure(Script) has a great REPL experience. Even when using VSCode, can one use the REPL easily?

So I'm not a fan of metaprogramming or heavy abuse of tricks for convenience either, and I do get and agree with your point!

But for some anecdotal nuance concerning the React example: > Take React for example. It's an abstraction, arguably a new "language", and requires ample documentation and usability concessions to be palatable. You could accomplish this with macros as well.

I feel like the standard before React was just every (web) framework inventing its own templating language, whereas I found React to be really easy to learn, because the way it abstracted things were straightforward and well explained. It's tooling however is one of the scariest things I've ever seen haha.

> Ultimately, they’re all cool, modern languages, so pick whatever fits your brain and helps you reach your objectives easier, while engaging in this social (or solitary) activity called programming.

Extremely, extremely true!

See my comment from the other reply on this question for potential solutions, but as an fyi for those curious, Nim does come with a VIM that comes in very handy for such purposes: https://nim-lang.org/docs/nims.html

My statement was mostly an exaggeration, than an absolute truth. REPLs are really nice, but it's story with Nim is less nice.

There is: https://github.com/inim-repl/INim and the builtin `nim secret`.

There is also a Jupyter kernel: https://github.com/stisa/jupyternim