While mostly true, use of Kotlin has been rather nice with IntelliJ. Standard library is very small and out-of-the-box IDE support with Gradle plugin helps alot.
Kotlin is really a fantastic language even without IntelliJ but with IntelliJ it makes these older languages feel archaic. Once you've had this level of explicit typing & null checking, code navigation, and refactoring that really works its very hard to go back.
Kotlin also feels like a pretty safe bet since both Google & Jetbrains are backing it.
Agreed. Kotlin is already fairly niche of a language with most people using it already using a jetbrains product (like Android Studios).
I've tinkered with the idea of using an LSP for development, but when it comes down to it Intellij is just too nice and works perfectly (most of the time).
The thought of writing Java without IntelliJ makes me want to quick programming. Ironically, Kotlin might be great in a text editor despite being made by Jetbrains.
I'm a bit mystified why OP didn't include Kotlin on their list. It's very accessible for Java devs, works brilliantly with tools they are probably used to (IntelliJ, Gradle etc) and compiles natively to JVM and JS (and Native these days, if you care about that). It seems like the ideal candidate.
Though I prefer Scala the language, Kotlin is really nice and has pretty straightforward tooling (seriously why is sbt what I'm stuck with), as well as really awesome (unsurprisingly) Intellij support.
And the GC and the minimal stdlib and other things. If you are targeting multiplatform, Kotlin may be a reasonable choice so long as you don't need anything advanced the JRE provides (or are willing to abstract it and have a native equiv also). Otherwise, there are too many native options these days to use Kotlin solely for that purpose IMO.
Kotlin. It has has great tooling with IntelliJ, loads of libraries in the JVM ecosystem, and Native/JS build targets are in the works. It's also far less verbose than Java.
We're using Kotlin in our backend and pretty happy about it. It has support for co-routines and great syntax, it's lightweight compared to Scala and IntelliJ plays great with Kotlin (no surprise as both of them are from JetBrains).
I won't even mention the learning curve, we started learning Kotlin using IntelliJ's support for converting Java files to Kotlin initially and then it took only one week to learn about the details thanks to its documentation.
From what I have seen, I'd probably pick Kotlin if I had to be on the JVM. Seems to strike a nice balance between sanding off the rough edges of Java syntax, and still being conventional and blub enough that it won't put people off.
Tooling is quite good with IntelliJ and Gradle, Kotlin is neat. It's pretty fast, allows for high level'ish programming and is verrrry widely used (many like to claim this helps for finding devs, seen by many others as the super scarcest thing producing software, but i beg to differ).
If you know Java, it takes a week or so before you're comfortable, and after that it's magical. All of the boilerplate, all of the tiny little frustrations and bad ergonomics, are just gone.
IntelliJ is a fantastic IDE, too, and I didn't bother picking it up until I started playing with Kotlin.
Kotlin compiles to JVM bytecode, and it runs everywhere I'm currently deploying applications. It can be mixed in with existing Java baselines, and interoperability is almost perfect.
Kotlin also cross-compiles to Javascript, and there's a new Native target, which I haven't played around with yet, but seems like a decent answer to Go's statically compiled, platform native, single binary output.
Lastly, there's an experimental feature that allows you to write one source base and target native, the JVM, and browsers. That finally gives me a single language that I can run anywhere that isn't Javascript.
reply