This weekend Al and I went down to Eugene to see Ben and have a small getaway, with a trip to the movies, too. We saw Guardians of the Galaxy Vol. 3 and walked out of it feeling like we’d seen a good conclusion to the trilogy. I always appreciate a good trailer fakeout, and the one they did for this one was sort of a double head-fake, making you think you’d seen the high-stakes thing, then pulling that rug out from under in the first five minutes, then making the stakes high again.

It was a darker, more violent movie than the previous Guardians installments, maybe to raise the stakes high enough to make it all feel like a good sendoff. Parts of it are heart-rending. There’s a little Wizard of Oz stuff going on at the end I choose to give a pass, because James Gunn appears to be decamping from the MCU to go do DC stuff and I get the need to provide a little closure I’m not sure anyone was asking for.

I was a pretty big Howard the Duck fan as a grade schooler, so I’ve always appreciated the way Cosmic Marvel balances the, er, cosmic stakes with a little silliness. Guardians Vol. 3 keeps the silliness, pulls the stakes in a little, and manages more darkness than usual. It was an interesting balacing act that seemed to work.

We couldn’t go to a normal showing so we had to do a 3D show, and that didn’t do much for my opinion of 3D. Always seems like the screen is a little more dim and some detail is lost for not a ton of benefit. I’ll be happy to see it at home when it starts streaming.

Also, Portland movie-going audiences are, on balance, better than the Eugene one we dealt with. Lots more people in their phones, more chatter in the audience. The glare of the phones is worse than the chatter, which was at least sort of participatory and topical vs., like, random couple behind you is processing their relationship for 140 minutes (my Magnolia experience years ago). OTOH, it was Saturday night of the second week of the run. We tend to do the movies that matter to us at quiet matinees and don’t go to many weekend evening shows anymore, so maybe the crowds we’re used to are not going because it’s a social event.

Dug out my old org-mode config

Maybe seven or eight years ago I was working in a group that had an intense progeress reporting culture. I was entrenched in org-mode and had things set up such that I could make a status report out of my work.org file with a quick export. It was not a bad way to live: If I was just keeping track of the things my team was doing, my status report was pre-written on Friday morning.

I went digging around in the config I had set up from that period and it’s interesting how much weight I was putting on tags for my organization. I’ve got a ton of custom agenda views set up for people, teams, and contexts. Now that I look at it again, I guess I was still trying to do gtd in some form or another, because I can also see custom agenda views for NEXT items.

The emphasis on tags was also about the benefit of emergent organization. My custom agenda commands were really simple affairs, organized around a top-level “people, teams, contexts” scheme. So if I was walking into a 1:1 with, say, “Isaac,” I could invoke the agenda dispatcher and tap p i (“people” “isaac”) to get all our topics. In the context of my weekly status reports, which were director-level things, you could scan down all the work in flight in my group and see the people tags if you wanted to know who was on what.

Anyhow, by making simple configs, like this:

("g" .  "Groups")
  ("gd" "Docs" tags-todo "docs")
  ("gD" "DIO" tags-todo "DIO")
  ("gs" "Staff" tags-todo "staff")

… I could easily add new tags to the agenda dispatch as they came into prominence, or retire old ones.

This time around, I’ve got a lot more up-front organization. I guess I didn’t really know about categories back then, because I see no evidence I ever used them. Now, every file has a category, and most of the top-level headings in any of my files have a :CATEGORY: property. It makes the agenda view cleaner (category names, not file names) and it’s easy to quick-filter by category (tap s c to “filter on category at point”).

Part of what makes that work is also a growing hierarchy of org-capture templates. I was wondering why I didn’t do more with that back then until I found a bunch of config around org-remember. That was still the “get this thing out of your head” option when I first started using org-mode. I can see some generic org-capture stuff I pasted in, but it’s rudimentary and I am pretty sure I never really used it. Now, I have a variety of org-capture templates that target specific headings in my org-mode files. I tend to work in transient capture buffers, not within files.

With a more robust org-capture hierarchy, categorization of headings, more active use of the agenda, and increasing use of org-roam, I don’t spend much less time in my org-mode files this time around.

Once a week, given my current employment circumstances, I have to go through and read some log entries I capture. When I work on a daily post, I have a capture template to instantiate the entry, but I quickly move it to an indirect buffer. I’m writing this subheading in an indirect buffer that started from a “blog idea” capture template with an IDEA type, to make sure I can see all my blogging ideas in the agenda. When an idea doesn’t pan out to my liking but I invested time in it, I atomize it into org-roam with org-roam-extract-subtree and tag it. I need to rewrite some of my PRM functions to operate from the agenda, but I’d otherwise never actually touch my contacts.org file, either.

I guess what I’m getting at is that the trend feels more and more like atomization and abstraction toward the construction of a plaintext database, and less like “working on individual text files.”

Which I’m really happy about. You can do a ton to make org-mode files look nice and do some auto-formatting, but it’s easy to get hung up on everything lining up nicely instead of remembering it’s all just data that tends to be readable in its own context, even if it isn’t perfectly tidy in a wider context.

It’s the smarts I was talking about when I wrote about linking stuff in Things that org-mode running in Emacs gives you that doesn’t exist in the org syntax highlighters you get in other editors, and that apps like Ulysses get close to but can’t quite manage.

Fixing Doom’s busted leader key in mu4e

I am not using mu4e (much), and one of the reasons it was easy to set aside was some brokenness in the way its keybindings interact with Doom Emacs: The space key stopped being the normal Doom leader key and started being the scroll key. I tried to remap it using what I understood of Doom keymapping, but nothing doing. About three weeks ago I posted a question in the Doom Emacs subreddit and on the Doom Discourse, but the best I got was “yeah, upstream’s broken.”

Yesterday someone on the subreddit finally replied with a recipe:

(after! mu4e
  (evil-define-key* '(emacs) mu4e-main-mode-map (kbd "SPC") 'doom/leader)
  (evil-define-key* '(emacs) mu4e-headers-mode-map (kbd "SPC") 'doom/leader))

That syntax is … impossible … to me. But it works.

Picture taking. I’m not doing it much.

After months of constant photography, I just stopped taking pictures. I know my Fujifilm has a few dozen pictures sitting on the card, and I haven’t even taken pictures on the phone except to do things like grab a picture of a receipt or remember which floor of a parking garage I’m on.

I remember the morning Al and I were going to head out the door for a coffee walk and I grabbed the camera, then thought about the photos I hadn’t even processed still sitting on the card, and just put it down. I also remember taking it with me to Astoria and just not wanting to shoot anything: I left it in the hotel and maybe took a phone picture or two that I promptly forgot.

I go through periodic no-pictures phases. This one has lasted a while. Looking in Lightroom, this is the last picture I took that really mattered much to me, from February:

And in that picture is probably what passes for “the issue.” That was an interesting evening I was excited to get out into and shoot. The camera ended up being caked in snow and ice and it was a miserable experience to be out walking around in it.

Since then and up until the past week or so, it has mostly been “normal Portland late winter and early spring,” so, flat and kinda gray. We haven’t traveled at all.

But the other part of it is that I’ve been happy to let things be that way. The last time I went on a long hiatus from regular shooting I felt sort of weird and guilty about it. Like I was not being Mr. Picture Guy, and that meant something was wrong with me because I’m supposed to be Mr. Picture Guy.

This time around I thought about it after a few weeks of feeling weird about it and remembered something a writing professor once suggested to me about the times I wasn’t being Mr. Writing Guy, which is that it’s fine to go through periods where that sense of drive and need isn’t there, and that it’s even good to let a sense of pressure and drive build up a little before giving it voice.

This weekend I saw some things in Eugene that left me wishing I had a camera besides my phone handy. I paused and watched those scenes and thought about what I was missing … what I could be capturing … and felt a twinge of regret that I hadn’t grabbed a camera on the way out the door.

Nice to have that feeling.

I went into giving mu a shot giving myself a giant side-eye for doing anything that involved running some MDA on a laptop, which is the minimum to use something like mu.

The intensity of the irritation with myself just deepened when my first pick for delivery – offlineimap – didn’t pan out and I found myself configuring isync to see if that would do any better. But isync (dba mbsync) works pretty well. It was easy to configure, I figured out how to gpg-encrypt my credentials, and I got it all set up in mackup such that I only have to configure/reconfigure in one place.

Most of my aversion to fiddling around with mail comes down to the MDA part, either because of the fragility of the component itself, or the flakiness of running these things on a laptop and how they’ll cope with being daemonized in an environment that’s not awake all the time. isync itself seems fine after several days, and it seems to be okay running as a homebrew service (with one minor caveat).

So that’s getting mail down to the machine.

mu itself – the indexing/search service for the maildir that isync creates – is pretty good. I’ve got ~231,000 messages indexed in it, and it’s super fast. As I’ve been working on cleaning up my contacts list it’s been great for just mu find "someone" from the command line. In some ways it’s almost too helpful given the volume of messages, because you get stuff like multiple reply-to’s in headers from Google+ email notifications or whatever, so one name can return 20 or 30 results in an address search.

So that brings us to mu4e.

Most of my aversion to running anything to do with ’net activity on Emacs comes down to blocking the whole app on a slow operation. I used to use GNUS for both IMAP and Usenet, and remember sometimes just having to get up and walk away during a sync until something finally got around to downloading. It was no way to live and I swore off anything to do with mail on Emacs unless I was willing to do it with an MDA of some kind in place (with all the attendant reasons I did not want to do that applying).

mu4e doesn’t even really interact with whatever we could consider a “physical” mail message, though. I mean, yes … when you write a message with it, it is creating a tmp of something that is eventually handed off to an MTA, but for reading and processing it is not touching Maildir messages in the filesystem – it is instead interacting with the mu database as a set of queries. It’s super fast. Fast the way Spotlight can be in Apple Mail, or search can be in Gmail, but consistently so.

UI-wise, mu4e is initially puzzling.

It starts from a place of “every list of mail is just a database query, not a list of files in a Maildir directory.” That’s fine. Lots of things in computing exist as vectorized representations of an object in filesystem. The difference between mu4e and some of these other styles of digital information is that not a ton of work has been done to re-translate these vectorized abstractions back into their old metaphor. So the menus, etc. talk in terms of “lists of headers” and not “folders of messages.”

Broadly, you can tell mu4e started from mu – “let’s make a mail search engine” – and then found expression as an Emacs MUA. While other MUAs include the idea of marking and operating but tend to start from a place of direct operation on a message (mutt’s an exception), mu4e starts from the assumption you’re going to mark and operate. So you don’t “delete a message,” you mark it for deletion (or moving, or whatever) then either execute your marks with the x keystroke, or sign off on executing them when you leave a given header list (i.e. what everyone else calls a folder).

It’s … I hate to even make it sound like this is a thing. If you have room in your life for setting up an MDA, a search engine for mail, and an Emacs MUA, you have whatever it is one needs to interact with a thin layer of abstraction over that whole pile of other abstractions. In some ways, mu4e feels to me like what might have happened if we chucked every innovation in mail interfaces that occurred after mh and went straight to “nah, dawg, your mail is still there on disk, but it also lives in The Matrix.” There’s just a little ramp for your muscle memory, is all.

So, what do you get in exchange, I guess?

First, it overcomes the core objection to running an MUA on Emacs at all: Everything except composing a message is a database operation, so everything is pretty fast.

People report being slowed down when trying to send messages with large attachments, and the proposed workaround (an async method you can configure) reportedly flakes out now and then. A dedicated MUA like Apple Mail might just step over that by backgrounding the send operation and letting you go on your way. Some webmail apps will give you the AJAX-y spinner until they’re done receiving the attachment, but not otherwise lock you out of using your browser. Conceivably, a big attachment with mu4e will still cost you the use of your text editor for the duration of the attachment. People who refuse to use their text editors for things besides just editing text will find that unacceptable and weird, but also know it’s a problem they’ll never have. People who think it’s right and proper to use their text editors to catch up on Mastodon, read RSS, send mail, do their calendaring, track their todos, browse the web … aaaaaaand sometimes edit a text file may be more put off.

By default, at least in Doom, it also hooks its update function into firing off your MDA so it can make sure the database has the latest messages. So when you check your mail with it, it wants to kick off an mbsync run. That doesn’t block it. I think it’s possible to configure it to just prompt a reindexing of your Maildir instead of a whole MDA run. I need to do a little more in-depth investigation of how well isync is working for me because right now I think mu4e and the Homebrew daemonization fight with each other, but the net effect is that one process gets isync to download my mail instead of the other.

Otherwise it is very, very fast, and its keyboard-centric UI is built toward getting at stuff quickly with a bunch of terse keystrokes to navigate to bookmarked mailboxes and canned search queries. Once you get the hang of marking/operating on a list of headers (with equally efficient keystrokes you can also customize) it’s a mail processing machine.

No, sorry, excuse me – it is a mail database processing machine.

I’ve previously named a few of these, but besides speed and efficiency, it offers a few other benefits:

First, I love composing mail in org mode markup. I sent myself a few test mails and loved, for instance, that an org mode src block was correctly colorized. org markup is a little more verbose than Markdown in some places. For instance, a blockquote isn’t done with a leading > but with a +begin_quote and +end_quote block.

Second, it’s easily hooked into org-capture. Here’s a capture template for putting a message in your inbox, marked for action within two days:

'("M" "process-soon" entry (file+headline "inbox.org" "Messages")
        "* TODO %:fromname: %a %?\nDEADLINE: %(org-insert-time-stamp (org-read-date nil t \"+2d\"))")

In Doom Emacs, you get at that with SPC X M. When it’s time to deal with the message, just tap enter on the heading and mu4e opens the message. Excuse me, no, it retrieves the header from the database.

In terms of drawbacks, setup time and learning curve aside, it has a few downsides:

At least one keymapping doesn’t play well with Doom Emacs. In mu4e, the SPC key is mapped to scroll-up-command to serve as a pager, whereas that’s the leader key for Doom everywhere else. The workaround is to use OPT SPC to get to Doom’s menu, but I’m still baking that into my muscle memory.

While orgmail-mode is cool and all, it interacts weirdly with the rest of the package sometimes, and I wish I could toggle its HTML mail features on and off now and then.

Its HTML mail presentation is as woeful as any mail client that starts from plaintext land, and the remedy is the same as it is in mutt: Learn the shortcut for opening HTML mail of any complexity straight into your browser.

Finally, it doesn’t interact as well with winner mode as I’d like, leaving frames in a weird state after some operations. I did convince ChatGPT to write a hook for me to get mail composer frames to close instead of leaving the view split:

(after! mu4e
(defun my-mu4e-close-frame-after-send ()
  "Close the frame after sending a message in mu4e."
  (when (and (eq major-mode 'mu4e-compose-mode)
             (not (mu4e~message-autopgp-p)))
    (delete-frame)))

(add-hook 'message-sent-hook #'my-mu4e-close-frame-after-send))

org-mail also seems to leave behind spare buffers it uses to put together the plaintext part of its multipart messages.

Net, though, it’s so fast and efficient that I can see past most of that. I’m sort of curious about connecting mutt to notmuch to see how that works, mostly because I know mutt very, very well and feel a little more fluent when it comes to customizing it. Some of the stuff I’ve got set up in mu4e could be done with a little utility scripting in mutt.

(map! :mode org
      :leader
     (:prefix-map ("C" . "CRM")
        :desc "Schedule Contact" "s" #'org-schedule-heading
        :desc "Clear TODO states" "z" #'my/org-remove-todo
        :desc "Update CONTACTED to today" "t" #'org-set-contacted-today
        :desc "Update CONTACTED to ..." "d" #'org-set-contacted-date
        :desc "SCHEDULE a date" "S" #'(lambda () (interactive) (my/org-set-heading-state-and-time "" 30 's))
        :desc "Mail this contact" "m" #'my-org-contacts-email)
     (:prefix-map ("C r". "Remember to ...")
       :desc "... write within 7 days" "w" #'(lambda () (interactive) (my/org-set-heading-state-and-time "WRITE" 7 'd))
       :desc "... followup in 3 days" "f" #'(lambda () (interactive) (my/org-set-heading-state-and-time "FOLLOWUP" 3 's))
       :desc "... ping within 7 days" "p" #'(lambda () (interactive) (my/org-set-heading-state-and-time "PING" 3 'd))
       :desc "... invite within 3 days" "i" #'(lambda () (interactive) (my/org-set-heading-state-and-time "INVITE" 3 'd)))
)

It’s a bunch of “tap the leader key, tap “C” for “CRM,” then do some common stuff,” like setting deadlines to write someone, or update the :CONTACTED: property, or just set the SCHEDULED: date on a record. This is the my/org-set-heading-state-and-time function:

(defun my/org-set-heading-state-and-time (state days &optional time-type)
  "Sets the TODO state and deadline or scheduled date of the current heading.
   STATE is the new TODO state to set, and DAYS is the number
   of days from the current date to set the new time. If TIME-TYPE
   is 'd', sets a deadline; if 's', sets a scheduled date; otherwise,
   prompts the user for the time type. Removes any existing schedules
   or deadlines before setting the new time."
  (interactive (list "WRITE" 7 nil))
  (org-entry-put nil "TODO" state)
  (when (org-entry-get nil "DEADLINE")
    (org-entry-delete nil "DEADLINE"))
  (when (org-entry-get nil "SCHEDULED")
    (org-entry-delete nil "SCHEDULED"))
  (let ((new-time (format-time-string "<%Y-%m-%d %a>"
                                      (time-add (current-time) (days-to-time days)))))
    (cond ((equal time-type 'd)
           (org-deadline nil new-time))
          ((equal time-type 's)
           (org-schedule nil new-time))
          (t
           (setq time-type (completing-read "Set time type (d/s): "))
           (my/org-set-heading-state-and-time state days (if (string= time-type "d") 'd 's))))))

It’s written with the menu system in mind. It’d be too clunky to use interactively – too many possible states to remember, etc. but as part of a bunch of canned menu options you can get to with one or two taps it saves a bunch of typing and cursor motion for common operations.

Then I thought, “it’d be handy to just visit a record and have an option to compose a mail,” so my-org-contacts-email was born:

(defun my-org-contacts-email ()
  "Open am email message to the email address in the EMAIL property of the current org-contacts heading."
  (interactive)
  (when (eq major-mode 'org-mode)
    (let ((email (org-entry-get (point) "EMAIL")))
      (if email
          (progn
            (unless (featurep 'mu4e)
              (mu4e))
            (mu4e-compose-new)
            (message-goto-to)
            (insert email)
            (message-goto-body)
            (insert "\n\n"))
        (message "No email address found.")))))

It has some behavioral issues I need to straighten out, but if mu4e is running and I tap SPC C m while positioned over a contact, it opens and pre-addresses a new message in mu4e.

I think it’s beyond the ken of org-caldav, but I suppose a call out to AppleScript could create similar functionality for scheduling things with a contact.

I really like the Doom menu system (and I suppose I’d like Spacemacs’ as well). The last time I was all-in on org mode I had so much trouble with all the Emacs chords that I ended up setting up org-drill to periodically train. With Doom’s menus, there are decent mnemonics up front, then visual reminders along the way. It still takes time to learn everything, but you get reminders and you can stop to study the menu if you forget. I don’t know how many times I have mashed CTRL g when I lost track of my fingers during a complex vanilla Emacs sequence.

I have a little self-control, so I made myself wait until I had mutt working before trying out mu4e.

And at that point, there was a yak capering about in my living room, and it had to be shaved:

• mu
• msmtp
• mu4e
• … and isync

isync because I found a bug in OfflineIMAP, which was inevitable given the 20-year-old email corpus I’ve been lugging around between mail servers. It was killing Homebrew’s ability to run offlineimap daemonized, so down that rabbit hole I went to satisfy myself the problem was widespread enough that it was worth considering alternatives, and isync has some good press.

Initial impressions:

• mu is pretty cool on its own. Very curious to play with my 20 years of email with it.
• I haven’t really tested mu’s performance under mutt with search. But it is nice having very fast address lookup.
• msmtp is … fine? I was using built-in SMTP for mutt, msmtp is there for mu4e’s benefit so I just use it for both clients now.
• isync seems fast enough and works well once the initial mail store is read into maildir.

Tomorrow I’ll move the data and databases over to my desktop

Oh … mu4e.

It is weird, but it’s my kind of weird. Very high concept. Super fast. The “squee” factor is being able to compose mail in org-mode markup, which it turns into multipart mail. If you read the HTML version of your mail, mu4e messages look like rich text. If you read the plaintext version, it applies some plaintext styling:

Heading
═══════

*Bold* and /italics/ and [a link].


[a link] <https://mike.puddingtime.org>

Subheading
──────────

Search is superfast, navigating between folders is keyboard-centric, and because the mail retrieval stuff is happening outside of an Emacs thread, it doesn’t block. I think you can set it up to run isync async inside Emacs, but I just noticed someone’s config a few minutes ago and it’s bedtime.

I am not sure what its future will be. I really like my mutt setup. I wonder if there’s a way to get the org-mode mail composition using Emacs as my mutt mail editor. Science needs to be done.