First impressions: Climbing mount Emacs

8min. . 🏷 Editors Emacs

I’ve been meaning to write this post for a while, where I just jot down some of my initial thoughts of the experience of learning Emacs. When newcomers find the time to write down some of their thoughts as they’re learning new technologies I find that quite valuable. So, here’s me doing the same for Emacs.

Let’s get into some of my impressions of learning Emacs so far.

Finding bedrock (emacs) #

I first tried learning Emacs from a vanilla setup, but that proved a little too barebones for me. I could extend the Emacs configuration, but I wasn’t sure on how to organize my configuration.

On my second attempt I went with Doom Emacs, which is Emacs pre-configured with a ton of smart packages and configurations. Doom Emacs honestly overwhelmed me with all its functionality, and it felt a bit bewildering trying to figure out how to wrangle all the existing config. I also got a bit puzzled juggling between evil-mode (Vim emulation) and the default emacs experience.

Finally, I found the Emacs Bedrock project which was a setup that didn’t overwhelm me. It wasn’t too much source code to read, which gave me the confidence to think that I’d be able to extend this configuration and really make it my own moving forward.

A mature shortkey system #

Welcome to chord-mania, I mean the shortcut-world of Emacs. As a newcomer I was quickly puzzled by symbols such as M-x and C-x, which are the key combinations Ctrl + x and Meta + x. And I was also puzzled when reading about the Meta key, which I’ve since learned means the alt key.

This is as natural as breathing air to a regular Emacs user, but for me it took a little work getting into this shortcut-lingo.

When you don’t know a given hotkey, you can call M-x which will prompt you to type a command you want to execute. Bedrock Emacs comes included with the Vertico package which enhances the UI that pops up when M-x is pressed, by also showing the key-combinations bound to the various commands. This is great for discoverability.

Documentation directory built-in #

Emacs has impressive documentation, and I mean not only the content but also how it’s organized and embedded into the Emacs distribution.

There’s the Emacs tutorial, accessible with C-h t.

There’s the Emacs manual, accessible with C-h r.

But what impressed me most is stumbling on the Info Directory which you can reach by calling M-x and typing Info-directory.

Emacs screenshot with long list of documentation links

Here’s a glimpse of what you see when you go to the top-level Info Directory. It’s a long list.

It’s interesting to see that the Emacs Manual is just one of many manuals housed in the Info Directory. I also noticed that when I installed new packages such as Slime, it also made its documentation visible in the Info Directory. Neat!

Emacs also comes bundled with many commands for working effectively with these manuals, and working with help system in general.

Vibrant community #

Community is important to me, and it’s inspiring to see how Emacs users share their knowledge.

Some examples:

This is by no means an exhaustive list, but it does hint at a thriving community.

Fun with Lisp #

These past years I’ve been curious about Lisp programming. I wanted to see what all the fuzz is about. Using Slime I can program Common Lisp. And off course I can program Emacs using Emacs Lisp.

I also started using paredit because again I wanted to know why some people like it so much for working with Lisp. I also tried parinfer briefly, but it didn’t chime with me and for now I prefer parinfer.

I haven’t built anything substantial in Lisp (yet). And although I find that I’m slow when programming lisp, I find it enjoyable. I guess I just need to accept being slow moving at first.

Suitable for typing Norwegian? #

As a Norwegian I have these lovely extra sounds in my alphabet æøå.

Interestingly this makes some of Emacs’s shortcuts harder to reach.

Consider these keyboards:

Here’s a keyboard featuring the US-ANSI layout. For the keyboard-curious it’s a Leopold FC660C.

And here’s a keyboard with Norwegian keys, laid out using the ISO layout.

I haven’t tried typing Norwegian within Emacs in earnest, but it’s going to be interesting due to Emac’s extensive use of shortcuts. Let’s consider the Emacs shortcuts for doing a simple undo:

  1. C-/
  2. C-x u
  3. C-_

To perform alt. 1) on my Norwegian keyboard I’d have to type ctrl + shift + 7, which is a convoluted maneuver stretching your fingers, and likely forcing you to look down on the keyboard to find the right numeral.

Alt. 2) is a two-part chord where you first type C-x followed by u, which can be a bit tricky when you want to do undo actions in rapid succession.

Alt. 3) seems like a hat-tip to people on the ISO-layout because the underscore key’s position on the Norwegian keyboard is the same as on the US-ANSI layout. My only gripe with this option is that the chord ctrl + shift + underscore, requires you to hold one extra function key.

Hmm. Maybe undo isn’t so hard to reach while on Norwegian ISO-layout. I only learnt about it when I was writing this blog post. The more you know.

Not using it for web development (yet) #

I still use VSCodium for most of my programming, especially web development. There’s certainly people out there who are able to do effective web development using Emacs (exhibit1, exhibit2). Maybe I’ll go down that path as well, but for now I’m quite content using Emacs for blogging and writing lisp code.

Bonus: Writing my first Emacs command #

I use Hugo for blogging, and it can be a little fiddly to insert images. So, I wrote a Emacs command that searches for files adjacent to the markdown file I’m writing, and let’s me pick the image I want to insert.


(defun get-pwd-path ()
  (cadr (split-string (pwd))))

(defun find-adjacent-files ()
  "Find files that are adjacent to the file being viewed"
  (directory-files (get-pwd-path)
		   nil
		   directory-files-no-dot-files-regexp))

(defun filter-images (files)
  "Filter list of filenames, and pick files that end with .png, .jpg and .svg"
  (let ((image-types '(".png" ".jpg" ".svg"))
	images)
    (dolist (file files images)
      (dolist (type image-types)
	(if (string-suffix-p type file)
	    (setq images (cons file images)))))))

(setq image-partial "{{< bundled-image name=\"%s\" alt=\"\" caption=\"\" >}}")

(defun hugo-insert-image ()
  "Pick an adjacent file, and insert a Hugo partial for displaying it."
  (interactive)
  (let ((images (filter-images (find-adjacent-files))))
    (if (equal 0 (length images))
	(message "Found no adjacent images to insert in folder: %s" (get-pwd-path))
      (let ((chosen-file (completing-read
			  "Hugo: What image do you want to insert? "
			  images)))
	(insert (format image-partial chosen-file))))))

Tip: If you’re a programmer and unfamiliar with Lisp I can recommend this link to get a brief overview.

I did like the workflow of rapidly evaluating code within Emacs and quickly seeing results. But it still took a bit of web searching to find right way to tackle my problem. I’m sure my speed will increase once I get more of the lisp syntax into my fingers, and also getting more comfortable with Emac’s built-in help system.

Moving forward #

I’ll keep tinkering with Emacs on my spare time. I’m looking forward to writing some more Lisp. And maybe I’ll start using Emac’s org-mode.