What always prevented me to actually switch to Emacs was how it's so huge it seems impossible to get an overview of how to do what. Every programming language-specific mode comes with its own unique features that surprise me when I just want to write code, meanwhile just entering a single tab without it getting deleted again is an odysee of reading documentation. At the same time it's slow and despite it having the best Vim emulation it cannot hide that Emacs just doesn't work like that. As soon as you leave the file's buffer you discover how Evil mode's illusion falls apart on all sides and you always land in situations where you have to use a mix of Vim and Emacs keybindings.

I love the concept behind Emacs, I just think at least 80% of its code should actually be in plugins, and the program itself and a lot of large expansions are really bogged down by the sheer size and lack of simplicity.

Oh, and Emacs-Lisp...it's much better than Vimscript, but it's a disappointment nonetheless. Loops instead of recursion in Lisp, really? And last time I tried it the parser could not handle unmatched brackets in comments.

> Loops instead of recursion in Lisp, really?

That's pretty common in common lisp as well. Specifically do loops (and lest we not forget the loop macro).

I think you might be thinking of the scheme branch of lisps, but not all of them work that way.

I tried using it but got stuck on having to learn Lisp to understand my config file.

I'm not sure what's difficult about

    (map! :n "ff" #'save-buffer)          ; Save
    (map! :n "fq" #'kill-current-buffer)  ; Quit a buffer

or

    (defun my/org-buffer-check ()
      "Check that we are in org-directory, and the buffer name is in that directory"
      (and (string= org-directory default-directory)
           (seq-contains (directory-files org-directory nil)
                                (buffer-name)
                                'string=)))

the latter being easily represented as:

    function my/org-buffer-check()
        return string=(org-directory, default-directory)
           and seq-contains(directory-files(org-directory, nil),
                            buffer-name(),
                            &string=)
    end

(seq-contains looks through the sequence returned by directory-files, for the result of buffer-name(), and compares them using the string equality function)

Sorry but that is not clear or obvious at all to me.

I understand the "!", I use it when it fails the first time and I'm trying to hint that I really really want it to work.

Apparently all the cool kids are using neovim + Lua these days. Lisp turned me off of emacs years ago as well. Recently I started digging into Neovim and have found Lua much easier to parse/internalize than Lisp, and kind of a joy to work with.

Great, I am at least halfway on the right track since I am using neovim. I know Lua a bit, I actually didn’t realize it was integrated.