pekko VS Metals

Pekko is open source, has the same API. So there's no problem there.

Understandable considering the size of Pekko and how much time is passed, I would recommend asking any questions/concerns on either the Pekko mailing list https://lists.apache.org/[email protected] or on Github discussions https://github.com/apache/incubator-pekko/discussions.

Another big reason behind the "struggle" is we have done further improvements. For example the first release of Pekko will support all Scala versions from 2.12 up to 3.3.0 LTS (which was just released a couple of days ago). This also includes Pekko's modules which means we had to either add back in Scala 2.12 support or Scala 3 support. Yet another example would be https://github.com/apache/incubator-pekko/pull/281 which allowed us to drop scala-java8-compat dependency for Scala 2.13 or higher. So while these improvements aren't technically necessary, they have a large impact on Pekko going forward, i.e. the scala-java8-compat change means that we can drop Scala 2.12 at any point in time without breaking users.

Apache Pekko is the open source fork of Akka. I know they can use more hands right now - https://github.com/apache/incubator-pekko/issues

There is an option missing: Considering switching to pekko when it's ready: https://github.com/apache/incubator-pekko

- In 2022, Lightbend changed the Akka licence, made it proprietary and very expensive at large scale

Software that starts out as more "pure", non-corporate open-source can still turn the tables on you and charge large licensing fees later. But at least if it's open source from the start, it can be forked, e.g. for Akka, there's this Apache fork that was started after Akka changed its licence: https://github.com/apache/incubator-pekko . This is the key open source protection, and it's true for both corporate and non-corporate projects.

Links: - https://dotty.epfl.ch/ - https://scala-native.org/en/stable/ - https://www.scala-js.org/ - https://typelevel.org/ - https://zio.dev/ - https://github.com/scala-native/scala-native/pull/3120 - https://github.com/lampepfl/dotty/pull/16517 - https://dotty.epfl.ch/docs/reference/experimental/index.html - https://scala-cli.virtuslab.org/ - https://scalameta.org/metals/ - https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html - https://www.scala-lang.org/blog/2023/04/18/faster-scalajs-development-with-frontend-tooling.html - https://www.scala-lang.org/blog/2022/08/17/long-term-compatibility-plans.html

You might want to look at Scala, they have proper LSP support with metals which means you can write your code in vscode, neovim, emacs, or even fleet (the new jetbrains text editor).

Please write in the comments if you know of any language servers I should test it with. Currently I tested only metals and rust-analyzer.

If you are using nvim-lspconfig you can pass the settings as a Lua table to the setup function. For example, here are may metals settings:

Bazel support in Metals. I didn't spend all that time figuring out and adjusting Emacs/Spacemacs and making my workflow (almost) mouse-free just to scrap my config and switch to IDEA's rodent infested ways.

There is one small issue involving code completion returning inappropriate completions in some cases; https://github.com/scalameta/metals/pull/4414 will fix it, once it's included in a release. Perhaps that's the PR you saw?

It is, by quite a bit.

While the "Scala IDE" project is dead for all practical purposes, IntelliJ IDEA's Scala plugin is actually pretty amazing. There's also a VisualStudio plugin that does pretty much the same and is advancing by leaps and bounds. There are also interconnecting projects that provide i.e. language server or build server that are reused by other projects. It's pretty modular. Metals (https://scalameta.org/metals/) is amazing.

In general the language has become a wee bit faster to build, there was good progress with build times during the 2.12/2.13 cycles.

With Scala3 the language got a bit simpler; concepts that were implemented explicitly using (hehe) implicits got their own keywords and a lot of the opinionated boilercode that cause a lot of debates is now generated during complication and hidden. A lot of "standardization" has occurred.

IntelliJ has its own BSP. The other one is Metals. You can use it with many IDEs (vim, emacs, vscode, atom,...). Use it with emacs if you're comfortable with it.