Kotlin-Lsp: Kotlin Language Server and Plugin for Visual Studio Code

Kotlin does not lock you in and has not locked you in to IntelliJ. About a year ago, I coded up a Kotlin service using VS Code. See https://glennengstrand.info/software/coding/csharp/kotlin for my description of that including how nice the developer experience was under VS Code. The plugin I used was https://github.com/mathiasfrohlich/vscode-kotlin which works like a charm.

What are the IntelliJ alternatives you prefer?

On a different perspective, I love that VS Code supports so many things. As full stack dev I have to work with Python/TypeScript/C# interchangeably, often in the same project. I can easily switch between projects with the same editor window, and I get to use the same keybinds.

I’m interested in hearing more about Nova for embedded C, what makes it more suitable? Looking for an excuse to try it.

I on the other hand rather go with use the best tool for the job, this applies to IDEs as well as programming languages.

The vertical integration from an Apple product tailored for a specific experience, versus the jigsaw from Linux desktop distributions.

I've pretty much replaced my Sublime Text usage with Zed as a general purpose editor, which handles any edits that last longer than i can be bothered to edit stuff in Vim. I've used Vi(m) for decades, and know my way around, and while it's a decent editor, it is NOT and IDE, and modern features feels like they're tacked on.

Aren't Zed and Nova and vim meant to be general-purpose editors too?

How is Zed for refactoring Elixir stuff? I use VS code for it but I find the options for even just renaming variables quite poor.

why zed for elixir/phoenix?

i thought the mainly maintained editor plugin was the one on vs code

i love emacs, but nowadays i would argue most languages are far better supported outside emacs, with few exception like lisps

so being strictly emacs, will really limit your choices, and honestly waste your time

Kotlin adoption has been stagnating recently (subjectively) and VSCode + forks have massive market share.

It was extremely shortsighted to think that a single language would sway people to IntelliJ instead of just limiting Kotlin’s growth.

One of the reasons might be that they realized that the absense of an official LSP for Kotlin will hinder its wide adoption by new developers who want to try Kotlin but don't want to move away from their favorite IDEs.

Most LLM based code-gen are VSCode forks. This reason would have certainly been on the list.

Supposedly Kotlin usage has gone down a little bit in the last TIOBE Index. So I think they are trying to get Kotlin usage up.

https://www.tiobe.com/tiobe-index/

I (and countless others I know) simply refuse to learn/use a language that locks you in an ecosystem. I haven’t taken Kotlin, C# or any of the Apple proprietary tech jobs and never will.

>I know it's a difficult spot because such effort will also indirectly compete with their main product which is an IDE, so I'm not very optimistic it'll last.

I would say this if this step was taking early while Kotlin is still a new language in the market, but I think their late decision to develop an official LSP for Kotlin is because of reasons you just mentioned, but maybe they changed their minds because they saw other benifits including a wide adoption of Kotlin.

Does Fleet not use LSP?

Based on the commit dates, it seems like their Eclipse plugin had at least four years of activity: https://github.com/Kotlin/kotlin-eclipse

I think the overlap between "people who use Eclipse" and "people interested in Kotlin" is pretty small, though. I've only seen Eclipse in use with companies and teams stuck working on legacy applications.

They even created Kotlin to help sell InteliJ licenses, cleary they are having an adoption problem outside Android.

"The next thing is also fairly straightforward: we expect Kotlin to drive the sales of IntelliJ IDEA. We’re working on a new language, but we do not plan to replace the entire ecosystem of libraries that have been built for the JVM. So you’re likely to keep using Spring and Hibernate, or other similar frameworks, in your projects built with Kotlin. And while the development tools for Kotlin itself are going to be free and open-source, the support for the enterprise development frameworks and tools will remain part of IntelliJ IDEA Ultimate, the commercial version of the IDE. And of course the framework support will be fully integrated with Kotlin."

-- https://blog.jetbrains.com/kotlin/2011/08/why-jetbrains-need...

In my case it is simple: I think IntelliJ is great but I much prefer VSCode and NetBeans.

Why? Two main reasons:

- On the projects I tend to work on, IntelliJ has a habit of breaking its internal configuration a few times a year—not just for me, but for my colleagues as well. When it does, it can take the better part of a day to sort out. Often I end up getting frustrated, deleting anything not under version control, reimporting the project, and end up having to reconfigure all the database connections and other bits manually.

- I also just prefer the more straightforward feel of NetBeans and VSCode. It’s a bit like my old car: less automation, fewer clever electronics. Sure, the new one is objectively better in many ways—but the old one was easier to get out of the snow, and it rarely surprised me.

It’s nice to have options. IntelliJ IDEs may be popular and well-regarded, but they’re not everybody’s cup of tea. As someone who’s spending a lot of time in Android Studio, it’s not unusual for me to become frustrated with it due to various behaviors and bits of UI design that can’t be changed, as well as fancy “smart” functionality that gets in the way almost as often as it helps.

I’m not terribly enthused with VS Code either but I’ll probably give this plugin a try, and since this has a standalone LSP it should be reasonable to write Kotlin plugins for other editors.

I use VS Code for everything BUT Kotlin.

I begrudgingly use IDEA because it was the only option if you wanted a decent IDE experience. The fwcd VS Code LSP for Kotlin that existed somewhat works, but it's very barebones and hasn't seen much development.

Before there was VS Code, I used Atom, so I've been on the VSC train for about as long as you can get.

It'd help with other editors as well. I'm vim user, for example, various "vim-modes" in other editors are unsatisfactory for me.

> especially that it's a proprietary language

In what sense is Kotlin a proprietary language? It's Apache 2.0 licensed AFAIK. And there are many projects that use Kotlin which are not legacy projects.

But to answer your question that is loaded to the brim with false assumptions/claims directly: https://kotlinlang.org/docs/comparison-to-java.html

- It has the best null handling mechanism

- Java handling of mutability of variables and collections

- Java is still more verbose and with less powerful utilities

- Much better for functional programming

-Some things were done right with all the learnt lessons. E.j. equals Vs ==

I respect preferring free languages. But I love Kotlin

I love java and kotlin. The gap has certainly swayed way more in Java's favor over the last 5 years, but there are still a ton of great features that kotlin does first and if that gives java a target to run toward in a lagging way more legacy compatible rock solid way, isn't this just a win for both camps? Just consider kotlin (JVM) to be java-beta with slightly different flourishes, and you wouldn't be too far from the truth. Kotlin is also very big in pushing their other initiatives that aren't entirely directed at JVM at least for now, like cross compilation native targets, compile time serialization primitives, totally structured concurrency, etc

Having to target Android, Google's .NET, mostly.

Aside from the often cited nullability issue, here is an (incomplete) list of important things that Kotlin still does better than Java:

- First class, fully functional closures. - Non-abstract classes and methods are final by default. - Named parameters. - Easy to write iterators via sequence { ... } - First class support for unsigned types.

Kotlin isn't just a jvm languague.

>after Java 21/23, what's the argument for using Kotlin

Having to use Java again when Kotlin exist

Honestly, lack of the ability to write free-floating functions in Java.

Recent Java features like records, pattern matching, sum types via sealed interfaces have certainly made it a much more ergonomic and modern language.

But having to wrap everything in "class" feels ludicrous to me.

The other ones are lack of explicit null types (meant to be addressed by JEP "Null-Restricted and Nullable Types") and inability to write anonymous types for functions.

For example, something like:

   fun withCallback(
      handler: (A, B, C) -> D
   )