
Erlang LS – The Erlang Language Server - lelf
https://erlang-ls.github.io/
======
frou_dh
I'm sure this one is good. But something I've noticed from trying Language
Servers for various languages is that a lot of them still need to get over the
hump to be an overall help rather than a hinderance. i.e. using a Language
Server that's flakey and fouls up often is more annoying than not having one
enabled at all.

~~~
the_duke
Yup. Writing a good language server is a big task.

It needs to do everything a compiler frontend does, and most languages don't
have compilers that are written with this use case in mind.

Even if parts of compilers can be used as a library, they are very rarely
written in a IDE compatible way, where you need fast, incremental and very
resilient parsing and type checking.

Typescript was written with IDEs in mind from the start, which is a big reason
it excels here. C# has a dedicated IDE toolchain called Roslyn.

And for dynamic languages the task is even more complicated, since you need to
implement type inference and static analysis.

~~~
dnautics
It's not erlang-ls, but having used elixir-ls is a pleasure (for the unaware,
elixir runs on the erlang vm). Pretty much everything just works as you would
expect, and it's a huge timesaver. Erlang and elixir have static typechecking,
which is a slow process from the command-line, but it's integrated and "just
works" with the ls, and rather refreshingly fast.

I even wrote a Zig package for elixir, which plugs into the elixir compiler,
and I found that the ls correctly highlights compile-time errors in my Zig
code embedded in the Elixir Code. About a month ago VSCode switched to auto-
code-loading (instead of hitting save) and now my Zig embedded in Elixir live-
highlights mistakes (with about a 500ms delay).

So if erlang-ls is about as good as Elixir-ls it'll be fantastic.

~~~
sitkack
Wait, please explain/expound on using Zig contained within Elixir?! Is this
running in or out of proc? What is your dev/edit cycle like?

I love Zig, but it doesn't have the security guarantees (yet) of Rust, so I
would recommend either running it out of proc or within an in-proc Wasm
environment, which actually has other interesting properties.

 __edit

[https://www.reddit.com/r/elixir/comments/e955jw/zigler_zig_n...](https://www.reddit.com/r/elixir/comments/e955jw/zigler_zig_nifs_in_elixir/)

[https://hexdocs.pm/zigler/Zigler.html](https://hexdocs.pm/zigler/Zigler.html)

So this is an Erlang Nif [3] which runs inside the VM, akin to JNI in Java.
This also means that errant code can bring down the entire VM.

Would you be open to a fork of Zigler that targeted a Wasm environment running
inside the Erlang env?

[3]
[http://erlang.org/doc/man/erl_nif.html](http://erlang.org/doc/man/erl_nif.html)

~~~
dnautics
You can do what you want :) in practice it's really hard to bring down the
erlang VM in zig. I'm also going to experiment with OTP managed OS threads,
which I think should allow you to safely run code that panics (but maybe not
segfaults), and will clean up the memory resources after you.

I think in general though you should be using zig not rust, because zig is
aggressively unopinionated about memory allocators, so when you allocate
memory in your code, you'll use the allocator that zigler provides, which
makes the BEAM alloc conformant to zig's allocator interface. This means your
code will be more performant, because there are fewer trips to the kernel on
allocate and destroy, and your code will respect the BEAM's memory
fragmentation, cache optimization, etc.

------
durandal1
Configuring Neovim for different languages used to be such a hassle, now with
CoC.nvim, all it takes is pointing to the LS, combined with the benefits of
having functionality standardized for all languages. I've used Erlang LS
briefly, and if nothing else, it's _way_ easier to set up.

------
giancarlostoro
Source here for those interested:

[https://github.com/erlang-ls/erlang_ls](https://github.com/erlang-
ls/erlang_ls)

Specifically here:

[https://github.com/erlang-
ls/erlang_ls/tree/master/src](https://github.com/erlang-
ls/erlang_ls/tree/master/src)

------
rapsey
Does it work better than:
[https://github.com/pgourlain/vscode_erlang](https://github.com/pgourlain/vscode_erlang)
?

~~~
robertoaloi
I would say the major difference is that "vscode_erlang" is tailored for VS
Code, while Erlang LS aims at be editor-agnostic (which is the main point of
implementing a Language Server). There are currently some differences in terms
of features, too. For example, VS Code has support for a debugger, which
Erlang LS does not have (yet). On the other hand, Erlang LS provides support
for Dialyzer or Elvis and I'm not sure if those are provided by VS Code
Erlang. You can compare the list of available features:

[https://github.com/pgourlain/vscode_erlang#erlang-for-
visual...](https://github.com/pgourlain/vscode_erlang#erlang-for-visual-
studio-code) [https://erlang-ls.github.io/features/](https://erlang-
ls.github.io/features/)

------
robertoaloi
If you would like to try it out, you can do it in the browser:

[https://gitpod.io/#https://github.com/erlang-
ls/erlang_ls](https://gitpod.io/#https://github.com/erlang-ls/erlang_ls)

Zero setup, just login via your GitHub account.

~~~
sigjuice
Is there a way to try it without logging in?

~~~
robertoaloi
I don't think so, unfortunately. Of course you can follow one the installation
instructions for one of the available editors. See the "editors" section on
the website. Instructions exist for Emacs, VSCode, Vim, etc.

------
fortran77
This is working nicely in MS VS Code! I program in Erlang every day, and
didn't know this was available.

------
RickJWagner
Awesome. Can't wait to see it in Eclipse Che.

------
marcrosoft
The more I learn about lisp the more I see its insights. The interpreter
itself is kind of like the language server.

~~~
uryga
couldn't this be said about any language with an interpreter? or do you have
some lisp-specific feature in mind?

