Buying into the Emacs Platform (2018)

---- TLDR ----

I completely agree with the others who say:

  - learn elisp instead of learning "emacs"
  - if you want to memorize something, just learn the name of the command: if you use it very often then learn/define a keybinding for it

---- part 1: I'm happy I've learned elisp in the last year

People complain about memorizing emacs keybindings, but most of the time I just call the command name with M-x command-name. Only if I find myself using it often I bother memorizing or setting a keybinding for it.

As for why I use emacs, I started using it for org-mode, which I considered it's only killer feature at the time. Since 1 year ago I started learning elisp and I think only now I can see what's the whole point of emacs.

In just 1 year of (beginner-level) elisp I wrote 75 files containing elisp functions to help myself with dozens of tasks that comprise:

  - move/mirror parts of ascii diagrams
  - automate some tasks just clicking on custom org-mode links
  - wrap ammonite-term-repl to get Ammonite completion for scala scripts [1] [2]
  - add rudimentary support for kawa scheme to geiser (my first pull request ever (still waiting for response))
  - control video player from within emacs while I'm writing subtitles

---- part 2: you can have different emacs configurations

Another common complain is that emacs tends to become slower as you add more and more packages. As a spacemacs user, I noticed that too. For this reason when I don't need spacemacs goodies I use multiple, different emacs configurations (with evil-mode though).

This is how I do it:

1 - Make a new ".emacs.d" user directory somewhere

2 - Make a new "init.el" user file inside it

3 - Add to the beginning of init.el :

    (setq user-init-file (or load-file-name "path-to-init.el"))
    (setq user-emacs-directory (file-name-directory user-init-file))

4 - Call emacs with:

    emacs -Q --load "path-to-init.el"

That's it.

You could achieve the same result using cask, which would be more elegant imo, but takes a couple of seconds more to start.

---- part 3: use elisp to call other languages

As for elisp, once you have learned enough of it (not much), if you are determined not to use it, there are different ways to call other languages from it:

  - clojure through cider plus clomacs
  - common lisp through slime
  - shen through shen-elisp [3]
  - different compiled languages through dynamic modules:
    - C  (example at [4])
    - go (example at [5])
  - ... many others I haven't investigated...

Just out of curiosity, I explored the shen-elisp path. I tried a whole week to see if I could replace it with shen-elisp. At the end of the week I learnt how to call elisp from shen-elisp and shen-elisp from elisp... and the fact that every time you restart shen-elisp you have to re-declare types. However I abandoned the idea for 2 reasons:

  - Plain elisp is faster: I don't know the implications
  - I wanted to focus on elisp so I can contribute better to other elisp projects

---- references

  [1] https://github.com/zwild/ammonite-term-repl
  [2] https://github.com/spellcard199/ammonite-term-repl-completion
  [3] https://github.com/deech/shen-elisp
  [4] http://kitchingroup.cheme.cmu.edu/blog/2017/07/08/Adding-numerical-methods-to-emacs-with-dynamic-modules/
  [5] https://mrosset.github.io/emacs-module/

Abo-abo's Emacs packages are truly fantastic. One that I personally love is Ivy-mode (with Counsel and Swiper): https://github.com/abo-abo/swiper

It only took me like a week to get used to vim. I obviously still don't use it to its full capabilities but i can use it like a normal text editor now.

Emacs by comparison makes no sense to me.

> Here's the obstacle: Motor skills. It just takes way to long to first memorize reams of commands and then to train your fingers to issue those commands effortlessly.

Do you know VI? You can use viper-mode and use it as VI. And it's not a handful of keystrokes as the likes of Eclipse implement, it's a full blown VI mode.

Your comment about "apropos" tells me you have never ever tried Emacs help system. There is a nifty tutorial, you can search for commands, functions, what have you. Need to know what happens when you type a keystroke, even down to the source code if you want? describe-key. Need to know anything about your enabled modes? describe-mode. And so on. There are more describe commands, but I never had to memorize them due to completion.

The only times I feel like using something like VSCode are:

– Learning a new and popular language: as of late, you can find nice extensions which sometimes even integrate installation of external commands, so you have a working system out of the box. Since I'm learning, I don't yet know what I need. This use-case is diminishing as of late due to Spacemacs.

– When I feel the need to have something "fancier" in terms of UI widgets. For instance, the popup golang help that VSCode provides is less disruptive than having a pop-up buffer. This is just a case of being attracted to eye-candy, which the exclusively text-based does not provide by design (although it can display graphics to some extent).

That's it. I always end up going back to Emacs as it provides so much more. And specially when interacting with Git, Magit is wonderful and far better than any applications I have seen - including the command line. Org-mode is always at my fingertips.

One thing though. If you are unwilling to learn Emacs because you are happy with your environment and you have other priorities, that's perfectly fine. If you are unwilling to learn Emacs _even though you feel that there are benefits_, then that's not a good sign. We need to learn new things all the time to stay relevant and productive. If there is a new tool, language or process that will improve your professional life, you are doing a disservice to yourself by refusing to learn.

Mashing ESC also works.

ESC ESC ESC (translated from ) runs the command keyboard-escape-quit (found in global-map), which is an interactive compiled Lisp function in ‘simple.el’.