emacs VS LunarVim

The ugly: Handling JSONRPC synchronously. Now that eldoc is in core emacs, LSP is officially supported by core emacs but from this branch https://github.com/emacs-lsp/emacs/tree/json-rpc-29 it looks like core emacs still handles JSONRPC synchronously and blocking.

Without perf profile, it is hard to say. For starters, you may remove lsp-ui. After this: https://emacs-lsp.github.io/lsp-mode/page/performance/ it should be good enough for most use usecases. If you want blazingly fast lsp-mode, you need the LSP Emacs fork https://github.com/emacs-lsp/emacs which is another beast(see https://www.reddit.com/r/emacs/comments/ymrkyn/async_nonblocking_jsonrpc_or_lsp_performance/ as well).

https://emacs-lsp.github.io/lsp-mode/page/performance/ . If this doesn't do, then https://github.com/emacs-lsp/emacs

The other major performance boost is if you're using lsp-mode and this fork. And an lsp-server that sends waaay too much info, I guess.

lsp-mode is async, but sending the messages. If the server is busy and not reading the input messages then lsp-mode will block. The only way ATM to avoid the issue is to use https://github.com/emacs-lsp/emacs .

I disagree. When I am running a compilation (with output being dumped into a visible buffer) + query magit for large commit. Over tramp. Things noticeably freeze. Technically it all is async. Practically, it is implemented as polling things on main thread with some witing happening in non-async fashion.

> For example, querying your compiler for a list of methods that apply to the current object, or a list of functions that start with “Foo” are mostly moving to external processes using LSP as the communication protocol.

That's why we have lsp-bridge and lsp-mode emacs fork :) Both of which build some infrastructure to avoid doing communication work with lsp-mode work in main emacs thread. So, heavy emacs users are building some async machinery which wraps another already async and relatively lightweight protocol, because core emacs facilities can't keep up with it. Architecturally it is kind of insane.

I think, lsp-mode fork is doing the right thing (from practical POV; it goes against "emacs is just an elisp interpreter" ideology though) and hope it gets into core at some point. A better solution would have being having first class async and background threads support at the elisp level. Which would never happen due to elisp messiness.

https://github.com/emacs-lsp/emacs

Locks: https://www.gnu.org/software/emacs/manual/html_node/elisp/Mu...

Semaphores are not there, my mistake; I was thinking about: https://www.gnu.org/software/emacs/manual/html_node/elisp/Co...

That's basically what every other threading library provides in most languages... and it's also what was shown time and again to be very hard to work with directly. Higher-order abstractions are necessary to make parallelism safe and concurrency convenient.

> and atomicity is guaranteed apart from when you use these calls. So you'd never be in a problem state of `setq` failing halfway, for example.

That's true - it looks like Emacs uses a global lock to ensure the atomicity, similarly to what Python does. Also like in Python, you can release that lock from native code (module or core). You cannot touch any interpreter state from other threads, so you need a bit of plumbing to get the results back, but it's possible. I found this: https://github.com/emacs-lsp/emacs/blob/json-rpc/src/json.c very interesting: it's a fork that moves JSONRPC from Lisp to C and out of the main thread. See for example line 1109 and related.

> but threads are pretty useful already if hard to code with.

That's the point: the capabilities are there (mostly), but abstractions are not. Coding with threads, even in the presence of the global lock, is hard, and ensuring correctness is nontrivial. At the very least we should get channels for communication (share by communicating, don't communicate by sharing) between threads and thread pools for executing tasks (like futures in Java or Python, or Task in Elixir). Threads and locks are way too low-level for normal coding. I suspect that's the reason why they're not used more widely, even though they're there for the third(?) release now.

Aside: Racket is actually a nice example of concurrency and parallelism being treated as completely separate concerns. IIRC threads in Racket are call/cc-based green threads, while places are separate instances of the VM that execute in OS-level thread or separate process. Threads provide concurrency and places provide parallelism. It's actually a good thing, I think. Mixing the two is often a major source of errors. Racket also has futures, which are parallel-if-possible primitives that can benefit from parallelism if they don't touch external state - a sort of a middle ground.

In any case: yes, Elisp threads are a good addition to the language, but they alone are not enough to bring concurrency to the masses, so to speak. As a concurrency primitives, and compared to callbacks, they have few advantages and some serious downsides. Emacs still needs a lot of work on the concurrency front. And don't even mention parallelism, that's another can of worms that we don't really need to open :)

In order for that to work, you have to use the json-rpc branch from here: https://github.com/emacs-lsp/emacs .

LunarVim

I would suggest to start getting into vim by first trying out popular vim keybinding plugins available on your favorite code editor and get used to those first. Then, if you want to dive deeper into the power of Neovim, try out popular configs like LazyVim, LunarVim, NvChad... Taking Neovim from a mere text editor to a full-featured IDE with features like intellisense, debugging, testing, etc... on your own takes quite a lot of work and configuration.

I used Helix for a while due to its support for LSP out-of-the-box, which my Vim config at the time couldn't live up to. I switched back to NeoVim after finding LunarVim[1] which had everything I was trying to get setup in my own config.

[1] https://www.lunarvim.org/

I'll admit I didn't look into it, but Helix sounds like something like LunarVim (https://www.lunarvim.org/)

Personally I much prefer that the editor NOT ship with something like that by default, especially when it's so easy to set up. I have several different vim config I use, including a pretty bare-bones one for headless systems, and I much prefer the ability to customize something very specifically.

Build tools that can compose together, rather than a single do-it-all tool. That is the power of the low level editors vs IDE's.

I can't comment on any implementation details, but at least with LunarVim (which I use for daily coding), a slowdown when interacting with LSP is very noticeable. Some others have attested to this on a GitHub issue.

I'm not doubting your experiences with the lack of a slowdown, but there is truth that others do experience it. That might be more of a problem with LunarVim itself rather than Vim, but how likely am I (as someone who would like to avoid what he calls "config hell") or other newcomers to avoid whatever pitfalls there are, if a distribution designed for ease of use by people who know better fall into them?

https://github.com/LunarVim/LunarVim/discussions/3359

Anyways, although i have not used them, LazyVim and LunarVim comes highly recommended. You can try these and see what suits you .