Ammonite-Ops VS Metals

That's funny, because this is what I really like about Scala; how quick and easy it is to get a project started.

> sbt new scala/scala3.g8

will just create an empty project. If you don't even want to bother with a project, use use scala-cli or ammonite (http://ammonite.io/) to just start banging out code.

Even the upgrading of a project from Scala2 to Scala3 is a breeze, thanks to very good backwards compatibility of new library releases.

Scripting API is quite limited, so the third option. - reuse the ammonite scripts https://github.com/com-lihaoyi/Ammonite or look how this is implemented (using internal compiler API),

Here's an example of a smaller project that added telemetry without suffering a fork:

https://github.com/com-lihaoyi/Ammonite/issues/607

Or ammonite - I've ran Gatling performance test from a simple script based on this gist it fetches all the dependencies, compiles and runs the test, producing nice html report..

Scala with the Typelevel ecosystem. Stay on the jVM, but have a much more pleasant and robust experience, including a great REPL.

If you are installing, and you are learning, I would also recommend ammonite as an easier REPL.

I've been using amm on and off https://ammonite.io/#Ammonite-Shell

pretty nice if you know scala, still have to use regular shell(s) so I do not forget them

I've never tested Ammonite, only read the https://ammonite.io/#Ammonite-Shell, so I'm only guessing here.

From what I understand, Ammonite was designed as a "readline shell" as I wrote in the article. It perpetuates this approach that everything is a command.

The thesis of my article suggests we do the opposite: I'm suggesting to rethink shells by starting from the interface (here the SLY REPL) and then implement the shell features.

In particular, it seems that Ammonite does not support back-references and I'm not sure it has an interactive inspector.

While Ammonite seems to be a definite improvement over the _syntax_ of Bash, etc., I'm not sure it brings much novelty in terms of user interface. But again, I know very little about it so I may have missed some features :)

I wonder what people think about Ammonite (https://ammonite.io/)?

It's not Lisp but Scala so may not be the authors language of choice however it can be used as a Shell: https://ammonite.io/#Ammonite-Shell

I am personally using it and compared to a classical shell like Bash it's really nice for more structured data related tasks (exploring some API, checking some data, creating a bunch of PRs at once, ...).

It also makes use of Scala's adjustable syntax and functional concepts so you basically get shell piping but in a strongly typed fashion (e.g.

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.

Have a look at https://scalameta.org/metals/