Irreal

It is often, but not always, nice to have a running count of the words in a buffer. Most usually, this is convenient for writers or students who need to keep track of word count in a paper or book. One way of doing that is the excellent wc-mode that I wrote about previously.

I like to keep a running count when I’m writing a blog post but almost never otherwise. I have a key sequence to turn it on and off so it’s easy to enable it for the buffers that I need it in. Still, it got to be a pain to turn it on every time I wrote a post so I added a bit of Elisp to enable it when I open a file in /Users/jcs/org/blog, which is where my blog posts live.

Here’s the code, which as you can see, is merely part of the use-package call.

(use-package wc-mode
  :ensure t
  :init
  (add-hook 'org-mode-hook
            (lambda () (when (and (buffer-file-name)
                                  (string= (file-name-directory (buffer-file-name))
                                           "/Users/jcs/org/blog/"))
                         (wc-mode 1))))
  :bind ("H-=" . wc-mode)
  :config
  (wc-mode nil))

It’s important to add the hook in the :init section, otherwise it won’t work until wc-mode is enabled manually at least once.

This is pretty trivial and I wasn’t going to write about it but I saw a question on reddit asking how to do something similar so I thought my solution might be useful to someone else.

Gergely Risko has an interesting GitHub repository that explores ways of making your Emacs load time as small as possible. Unless I’m hacking on my configuration, I rarely start Emacs except at boot time so the two or three seconds of startup time doesn’t bother me much. But if you simply must get your startup time to an absolute minimum, take a look at Risko’s strategy.

The TL;DR is that he avoids package-initialize and uses use-package in its place. The real problem with that solution is getting the load paths for the packages. In the video on use-package, John Wiegley and Sacha Chua discuss that problem. Wiegley avoids it by not using the package system. Most of use would rather not take that option and Risko has a method of loading the paths that runs when init.el isn’t compiled and adds them to the init.elc image so that the overhead is mostly avoided.

Most of us, I’m sure, don’t load Emacs very much. We either have a long running instance or start the server and use emacsclient so unless you have a use case like Wiegley’s that requires frequent restarts of Emacs, you may not want to bother with Risko’s solution. If minimizing your Emacs load time is another video game for you, take a look at the repository to see if his ideas might help.

As most of you are doubtless sick of hearing by now, I’ve settled very happily on mu/mu4e to handle my email from within Emacs. It’s not the only possibility, of course, and many other Emacers prefer using notmuch, which is similar to mu but with a robust tagging system.

For those of you in the notmuch camp, KKatsuyuki has an excellent post on how to configure notmuch and offlineimap for use with Emacs. He’s got a complete recipe so you should be able to pretty much paste his configuration into your init.el making only the obvious changes to things like paths and email account info. KKatsuyuki’s configuration is for Gmail, so you may have to do a bit of research on offlineimap if you’re using something else.

KKatsuyuki’s post is an excellent go-by for anyone wanting to bring email into Emacs using notmuch.

Since Emacs 25.1, Artur Malabarba’s excellent let-alist macro has been a built-in feature of Emacs. As the name suggests, it’s a way of dealing with alists. The idea is that instead of writing a series of assq and cdr statements, you just write .tag where tag is the car of an alist element. Malabarba’s post gives an example of its use.

There’s a nice example of its use by T. V. Raman in a post about parsing the result of a json-read. Most of the examples I’ve seen use json-read to produce the alist, but the macro can, of course, be used with any alist. It can even handle nested alists as both Malabarba’s and Raman’s examples make clear.

Mike Zamansky has another video up. This time, it’s about swapping buffers but keeping focus in the original window. The video is interesting because it shows the process Zamansky went through to solve a problem he was having.

The problem was that he had a window configuration with one large buffer and two smaller ones. He wanted to swap the buffer in one of the smaller windows with the one in large window. If you have ace-window installed, it’s easy to swap two windows. I have the proper call in a hydra and use it reasonably often.

The problem with that for Zamansky is that he’s trying to move another buffer into the large window so he can work on it but ace-window keeps the focus with the original buffer so it’s in the wrong window. What he needed was to swap the buffers but keep the focus in the original window.

Most of the video is how he solved this problem with a bit of Elisp and how he felt his way to the solution by using the Emacs help system and by looking at the ace-window code. It’s an instructive video especially if you have only minimal Elisp skills. Zamansky shows that you don’t need to be an expert to solve real problems.

Even if you already use ace-window, the video may teach you something you didn’t know. It did me. It turns out that after calling ace-window to change to a new window, you can give it a subcommand instead of a window number. That makes it easy to swap windows and do certain other actions. See the video for the details.

The video is a little over 12 and a half minutes so it should be easy to find time for it. As with all of Zamansky’s videos, it’s well worth your time.