The ionide project is doing tremendous job of support on vscode.

It has improved compared to year, and definitely much better, in a month or two all the major IDEs including MonoDevelop will likely have .net core 2.0 support with F# baked in (speculation on my part).

Eta will never even approach Scala in terms of adoption, and I had only heard about Purescript a few weeks ago reading about Elm.

Typescript will dominate functional JS-world (already is, tbh) and Scala is still crushing function JVM-world, and if Dotty ever actually materializes, adoption will get even better. Additionally, Scala-Native and ScalaJS are making progress and could eventually be real players. Not likely to take food away from Haskell or Typescript, but they will certainly maintain larger usage than PS or Eta.

edit: I'll concede that Clojure matters a bit in JVM-world, but it's dying quickly.

So ScalaJS could be a "real player" but PureScript is barely able to exist? Forgive me if I don't just take your word for it.

I'm not making this shit up out of thin air, look at usage numbers.

Purescript is not going anywhere, most likely ever.

I know you aren't OP, but it doesn't sound like they have jack shit to back up their statements.

Is it? Do you have evidence of this?

I'm not defending how obnoxious it CAN be to write Scala, but say it's stagnant is just dishonest or misinformed. Or both.

Also SBT. Fuck sbt.

It's difficult to point to a more poorly managed language project than Scala. The net result is a mess with tons of gotchas, performance pitfalls, technical debt and a 3-way split tie in the community.

Scala has driven away a lot of brilliant people.

My dad has been writing COBOL for 30+ years, but I think we could both agree that it's a dead language in a certain sense.

My first language was Scheme. I wrote some stupid BATCH scripts at school and decided I wanted to learn to program. I worked my way through half of SICP, etc etc. I LOVE Lisps. I was rooting for Clojure a few years ago.

However, I think Clojure is embracing types too little too late. Large systems are hard to do in dynamic languages. There's no easy way around that. Sure, immutability helps, and having a strong style guide helps and having strong interactive programming helps, but it never goes away that it's harder to do when you can't reason about the structure of something without evaluating that thing.

That there are more Clojure jobs sprouting up as development is drying up screams disaster maintenance to me.

I'd love to be proven wrong. I would LOOOVE for Clojure 2.0 to fully embrace a strong type system and maybe some stricter semantics but it just isn't going to happen. Very few people are familiar with Clj internals, fewer people still are still working on it, and fewer people still plan on continuing that work for a long period of time.

Call me crazy, but I think there are two major threats to Clojure's current reign in the enterprise lispverse.

Racket's rewrite to Chez. That's big. That will mean big performance gains and I think could provide incentive for someone industrious to wrangle some of the crazier parts of racket into a coherent biz-ready language.

The other is Elixir. Now, I hate elixir but people seem to eat that kind of stuff up. They have a strong macro story, BEAM is very powerful in the right hands, and as time goes on it becomes more and more clear that it's easy to write high-concurrency, low-latency, SMP-enabled systems in Elixir.

Elixir doesn't have a type story (racket does, but it's kinda lame), but that never stopped Clojure up to this point.

Also, Clojerl (clj on erlang/otp) exists, which could strengthen the motivation for moving away from Clojure by making pure-clojure applications vulnerable to completely automated porting thus eliminating the need for clojure maintenance programmers.

That's my take on that whole situation.

[1] https://hexdocs.pm/elixir/typespecs.html