I used to have a bunch of conditional logic in config.org to manage all this, but it was sort of a pain to pick through when adding a machine, so I wanted to isolate the individual machine configurations a little. I’m guessing it could be useful for other stuff in the future, but for now it handles some appearance stuff.

For by-host configs, I added this to my config.org:

(let ((hostname (system-name)))
  (let ((hostname-file (expand-file-name (concat hostname ".el") doom-private-dir)))
    (when (file-exists-p hostname-file)
      (load-file hostname-file))))

That just looks for a file in my Doom directory with the hostname.el naming convention.

A sample hostname.el file looks like this:

(setq doom-font (font-spec :family "Fira Code" :size 14.0 :weight 'medium))
(setq mixed-pitch-set-height 15)
(set-face-attribute 'default nil :family "Fira Code" :height 140)
(set-face-attribute 'fixed-pitch nil :family "Fira Code")
(set-face-attribute 'variable-pitch nil :family "Helvetica Neue")

(setq initial-frame-alist
      '((width . 171)
        (height . 66)
        (left . 728)
        (top . 166)))

(setq default-frame-alist
      '((width . 171)
        (height . 66)
        (left . 728)
        (top . 166)))

The initial-frame-alist and default-frame-alist dimensions came from this function:

(defun my/print-frame-setup-snippet ()
  "Print a config snippet for setting the current frame size and position."
  (interactive)
  (let* ((w (frame-width))
         (h (frame-height))
         (pos (frame-position))
         (l (car pos))
         (top-pos (cdr pos)))
    (with-temp-buffer
      (insert (format "(setq initial-frame-alist\n      '((width . %d)\n        (height . %d)\n        (left . %d)\n        (top . %d)))\n\n"
                      w h l top-pos))
      (insert (format "(setq default-frame-alist\n      '((width . %d)\n        (height . %d)\n        (left . %d)\n        (top . %d)))"
                      w h l top-pos))
      (kill-new (buffer-string))
      (message "!!! Frame setup snippet copied to clipboard! Paste it into your config.el."))))

So, set the Emacs frame up the way you want, then run that function, and paste it into hostname.el.

ox-hugo lets you keep a monolithic org file where each post is an org heading:

** SyncTrain for Syncthing on iOS :syncthing:ios:iphone:
:PROPERTIES:
:EXPORT_FILE_NAME: 2025-04-20-synctrain-for-syncthing-on-ios
:EXPORT_HUGO_DATE: <2025-04-20>
:EXPORT_DATE: 2025-04-20
:EXPORT_HUGO_SECTION: blog
:EXPORT_HUGO_CUSTOM_FRONT_MATTER+: :cover '((image ."" ) (caption . "" ))
:EXPORT_HUGO_CUSTOM_FRONT_MATTER+: :images '(/mph-logo.png)
:EXPORT_DESCRIPTION:
:END:

A few years ago I gave Mobius Sync a try as a Syncthing client on my iPhone and iPad. That went about as well as you'd expect for an iOS adaptation of something that wants to be an always-on filesystem-watching daemon. It wasn't really worth the stress of wondering what quantum state of sync everything is in, and I hated having to explicitly open it up to nudge it to sync.

If a heading is marked as TODO, that translates to “draft” for Hugo. If you use org tags in the heading :tag1:tag2: those become post tags.

If you set up org-capture and a few hooks correctly, it takes a lot of friction away by exporting the Markdown files when you save the file.

Something has changed since I was last using it regularly, and some bugs crept into my setup. I was willing to live with a few of them, but last night I came across some goofy thing where Hugo’s Markdown renderer (goldmark) and ox-hugo were interacting strangely, and the org-to-markdown conversion was indenting unordered lists enough that goldmark picked them up as indented code blocks. I did some poking around and saw that a lot of people have been vexed by that: goldmark uses the CommonMark specification, which includes indented code blocks, and goldmark offers no toggle for it as a workaround.

How many seconds do we have of this precious life?

I do like working out of Emacs and not switching around to do stuff, so I found an old Ruby script I wrote to make generating a Hugo post with all the stuff particular to my setup and worked with a co-pilot to convert it to a lisp package.

When you invoke hpost-new it prompts for whether to follow the “daily” or regular post style, then asks for title, tags, and description, then plops the new file into the right place and opens it for editing.

This goes in ~/.config/doom/lisp:

;;; hpost.el --- Create new Hugo posts from Emacs  -*- lexical-binding: t; -*-

;; Adjust this to point at your Hugo or ox‑hugo content directory.
(defcustom hpost-posts-dir "~/blog/content/posts/"
  "Directory where new Hugo posts are written."
  :type 'directory :group 'hpost)

(defun hpost--slugify (title)
  "Convert TITLE to a URL‑friendly slug."
  (let* ((s (downcase title))
         (s (replace-regexp-in-string "[^a-z0-9]+" "-" s))
         (s (replace-regexp-in-string "^-\|-$" "" s)))
    (truncate-string-to-width s 60 nil nil ""))) ; hard cap at 60 chars

(defun hpost--today () (format-time-string "%Y-%m-%d"))
(defun hpost--now   () (format-time-string "%Y-%m-%dT%H:%M:%S%z"))

;;;###autoload
(defun hpost-new (title tags summary &optional daily)
  "Create a new Hugo post.

Interactively prompts for TITLE, TAGS (comma‑delimited), and SUMMARY.
With prefix arg, treat it as a daily note (pre‑sets title and tags)."
  (interactive
   (let* ((daily (y-or-n-p "Daily note? "))
          (title (if daily
                     (format "Daily notes for %s" (hpost--today))
                   (read-string "Title: ")))
          (tags  (if daily "journal"
                   (read-string "Tags (comma): ")))
          (summary (read-string "Summary: ")))
     (list title tags summary daily)))
  (let* ((slug    (if daily "daily-notes" (hpost--slugify title)))
         (fname   (concat (hpost--today) "-" slug ".md"))
         (path    (expand-file-name fname hpost-posts-dir)))
    (when (file-exists-p path)
      (user-error "File %s already exists" fname))
    (with-temp-buffer
      (insert (format
"---
title: \"%s\"
date: %s
draft: true
tags:%s
summary: \"%s\"
---

" title (hpost--now)
        (mapconcat (lambda (t) (format "\n- %s" (string-trim t)))
                   (split-string tags ",") "")
        summary))
      (write-region (point-min) (point-max) path))
    (find-file path)
    (message "New post created: %s" path)))

(provide 'hpost)
;;; hpost.el ends here

… and the config:

;; --- Hugo post helper ---------------------------------------
(use-package! hpost
  :load-path "lisp/"
  :defer t
  :custom
  (hpost-posts-dir "~/blog/content/posts/")
  :config
  ;; Optional keybinding:  <leader> n h
  (map! :leader
        (:prefix ("n" . "notes")
         :desc "New Hugo post" "h" #'hpost-new)))

It goes well with a few helpers I made to fire up or shut down the Hugo preview server within Emacs:

(defun my-start-hugo-server ()
  "Run Hugo server with live reloading."
  (interactive)
  (let* ((root (projectile-project-root))
         (default-directory root))
    (compile "hugo server -D --navigateToChanged" t)))

(defun my-stop-hugo-server ()
  "Stop Hugo server."
  (interactive)
    (kill-compilation))

(map! :leader
      (:prefix ("H" . "Hugo")
       :desc "Start Hugo Server" "S" #'my-start-hugo-server
       :desc "Stop Hugo Server" "s" #'my-stop-hugo-server))

So, SPC H S to start the test server, and SPC n h to start a new post. When I save the buffer, the preview server jumps to the newly written page in the browser.

So I had this very cool thing going on with Gollum running on my Synology. Gollum is mostly the same engine GitHub uses for its own wikis, and it can understand a variety of plaintext formats (including Markdown and org). With Gollum you’ve got a web front-end with search, version control, and inline editing if you’re away from an Emacs-capable machine or just want to look a note up on a phone.

And Denote has its very cool org-mode dblocks: You can use a regexp to pull files matching a certain pattern into a dynamically updating block to create things the Zettelkasten folks might call a MOC, Prot refers to as “metanotes,” etc. I have made a set of index files on high-level areas I tagged with “topic,” so a Denote dblock with this syntax:

#+BEGIN: denote-links :regexp "_topic" :not-regexp nil :excluded-dirs-regexp nil :sort-by-component nil :reverse-sort nil :id-only nil :include-date nil

… will dynamically create an index of links to all my “topic” notes, and within each of them I can make Denote dblocks that pull in notes with their tag.

In the context of Gollum, or even just an entry point into my notes collection, that means my Home page can provide a dynamic index of topic notes as I create them. Except, of course, the whole problem that a Denote dblock uses its custom denote: link scheme, and Gollum can’t understand that.

You can manually use Denote’s denote-org-convert-links-to-file-type command to convert those links to standard file: links, but I’m forgetful and hate the thought of having to remember to do it. So I fixed it with a .dir-locals.el file that does it for me with a pre-save hook:

((org-mode . ((eval . (add-hook 'before-save-hook
                                #'denote-org-convert-links-to-file-type
                                nil t)))))

So I can update my topic pages, save them, the hook runs for me, and I can push into the Gollum repo. I get to keep all of Denote’s convenience features around link-making, backlink lists, etc, and Gollum knows what to do with it all.

I know that is easier said than done.

“Bits of our identities” are conversation starters, signifiers, hints, badges, clues to deeper things about us, personal reminders, and anchors.

“Anchors.”

“That was a very anchoring conversation.”

“This is a real anchor around my neck.”

Which is a weird way to start a post about note-taking apps, but here we are.

Like, Emacs is part of my “Unix person” origin story. I can’t name another software tool I’ve used as consistently for 33 years. I suppose the Unix paradigm itself edges Emacs out for personal longevity, but not by much. And when I think about everything I was doing with that first Ultrix account in 1991, “running Emacs” is the only thing that remains from the list. No more Netrek, I don’t use USENET in a way that would be recognizable to Past Me, and if the work I did on the Landsraad assembly hall for the DUNE MUD remains – getting cones of silence to work felt like a real triumph – I haven’t been around to visit it for a few decades.

It is a bit of an anchor in the putatively good sense of the word “anchor.” Technological comfort food. One of the first things that goes on any new machine, and one of the first server-side things I test when I’m trying out a new remote access tool. But also a bit of an anchor in the not-great sense of the word, in that I will pay the “figure out how to express this in elisp” tax for hours, well beyond practicality or reason.

Most recently, I was ignoring some excellent advice from Prot regarding people who want to use his excellent Denote for task tracking:

“If you want my opinion though, be more forceful with the separation of concerns. Decouple your knowledge base from your ephemeral to-do list: Denote (and others) can be used for the former, while you let standard Org work splendidly for the latter—that is what I do, anyway. … “Do not mix your knowledge base with your to-do items.”

… and the complexity was piling up and up, the tradeoffs were getting worse, and there was simply no joy in the experience because I had gotten myself into that bitter “make this problem yield” mindset that eventually leads to less understanding and more hacked-up, suboptimal stuff.

I just don’t have time for it right now.

So it makes sense that my fallback position was “maybe Logseq would be fine,” because it’s got the whole “supports org-mode syntax” thing going on – leave the door open for a return to Emacsland once I have more time – and perhaps because it is just odd enough to tickle another bit of my self-image. Mercifully, the second I tried to solve a problem of moderate complexity I realized how much time I’d have to invest to do anything besides pick code samples up off the sidewalk and pop them in my mouth. So I backed away slowly.

And after that it makes sense that Tiddlywiki got a look because it has been around forever and there is a sort of cheerfully prosaic attitude among its users. But the plugins started creeping in and I was trying to get it to do stuff it doesn’t really want to do without a lot of third party assistance, so the whole “it’s very simple” thing was not allowed to find much expression.

So there I was, and I’m sort of glad that I chased my tail over the past few weeks because it tired me out a little, but left me with an idea of what I wanted to do: Take notes in a connected manner, blend a little of PARA with space for a slipbox approach, and have inline todos, and I wanted it to sync across a few devices.

Obsidian does all that very well. There is always the risk of plugin creep, but in past Obsidian experiments that has been less about extending the core feature set and more about removing repetitive work. The simple mission of “write notes, link between them, keep track of tasks” doesn’t take much, with mobile and sync managed competently. It runs on every platform I’d care to run it on.

It’s a little dull. But after a few days of “just using it” and adding little affordances here and there from past vaults as I’ve remembered them, it has the benefit of just working in a non-dramatic, non-head-desking, simple way. I haven’t had to really think about it much. I haven’t inadvertently broken it or misconfigured it in such a way that I’m scrambling around a minute before a meeting trying to get back into my own notes. It’s of sufficient maturity that you can look up the answers to things and they are often in written form, which minimizes the whole “if I see one more YouTube poster frame of a slack-jawed influencer taking 30 minutes to explain something I could have copied and pasted in ten seconds I’m going to do a murder” thing.

I was inclined to say “and it says nothing about me, at all.”

But it does say a few things: “Doesn’t want to think about this problem he created for himself in any more detail,” “will settle on Markdown even though it is inferior to org,” “can stand being associated with people who think a graph of their notes is interesting and useful if it means not having to think about this any longer,” “will pay for sync,” “considers seven plugins normal and reasonable, would not admit to nine,” and – most likely and eventually – “always seems to creep back to Emacs even though it seemed like he knew better last time he did this.”

I like the ideas I get from taking a tour of a tool like Logseq, even if I don’t think the whole thing is going to work for me. It’s a chance to fold ideas into what is practically my forever tool, which is org-mode/Emacs, or at least rethink things I thought were more bothersome to fix than they sometimes end up being.

The last few weeks I’ve been intrigued by PARA as a simple organizing principle, I’ve wanted to continue to mesh prose and tasks in the way org-mode excels, and I’ve wanted to de-gunk my Denote setup.

I gave Logseq a try, looked at Workflowy again, and briefly dusted off my last Obsidian setup. Logseq and Obsidian are pretty good at surfacing tasks from all over your notes collection. org-mode can manage that but it is very oriented around the org agenda as a way to see your tasks, and the agenda doesn’t scale well with large collections of notes.

There are a few ways of coming at that problem, ranging from “just be selective about which files go into the agenda” to functions that pre-scan your corpus cheaply then assemble a list of agenda files only from things with active todos.

I am still a long way away from having a notes collection large enough to slow the agenda down, but it’s growing.

So, in the midst of poking around and trying to decide whether or not to add one of several possible lumps of lisp to my config, I came across Jack Baty’s post on his own solution, which is limiting your agenda files to just project files, based on Denote’s naming convention.

My own Denote hierarchy has a bunch of little atomic notes, then a collection of project files, area files, and people files. It also has a home file that indexes the project and area files, and an inbox file. I’ve been experimenting with a foundations type that I use to define core concepts. For instance, my team’s work a specific tool migration might be a project file; while portfolio management generally is an area file. Defining what even is the portfolio, what it means for someone on the team to own a piece of the portfolio, and what expectations are for portfolio owners is a piece of foundation thinking.

I can see putting tasks in those special-purpose files, and will tend to avoid putting them in tinier atomic or fragmentary notes files. Feels like a reasonable compromise that discourages littering my notes with tasks, keeps org’s agenda efficient, and provides a little bit of structure that I feel can go missing in a strictly anti-hierarchical note setup.

The code Jack shared defines denote-to-agenda-regexp to make a decision on whether or not some supporting functions should include a file in the agenda. He limits his to files with _project in the name (derived from having project somewhere in the filetags). I wanted to include area and people, too, so I expanded the regexp (inelegantly):

(defvar my-denote-to-agenda-regexp "_project\\|_area\\|_people\\|_inbox"
      "Denote file names that are added to the agenda.
    See `my-add-denote-to-agenda'.")

I’ve also added the project/area/person name as the #+category: property in my agenda-ready files, since that cleans up the far-left column on the agenda, which is the (very long in Denote) filename by default.

Forsaking mobile

I guess the other development of all the cleanup and fussing was choosing to not care about the mobile use case for this stuff at all.

I think I have shared elsewhere that one of my formative work experiences included being handed the keys to a portfolio of websites with zero supporting staff and being expected to keep comment moderation going seven days a week. I developed a small fixation around mobile work that predated useful technology for mobile work by a good number of years. It made sense because it allowed me to be out and about and doing little moderation micro-tasks whenever.

Since then, I’ve had this scar or kink or crease in my brain about making sure the mobile bases are covered, but the more I think about it the more I think it’s a bad idea. It’s bad enough that I let Slack or Gmail on my phone, let alone wanting all my work notes and tasks available wherever I am. I suppose in a truly, truly dire situation I could use Blink to sign in to the desktop machine and run an agenda or look up a note, but that’s a ridiculous scenario and the better answer is probably “yeah, sorry, away from my computer rn.”

I felt a little nostalgic for my old ox-hugo setup today. What was so great about it?

• One big org file.
• Your stuff ends up in a regular Markdown file for portability.
• Pretty nicely wired up in Doom’s menu structure: SPC X b d and a daily post is underway.

I took a look in config.org and it looked like all the config was still there, so I started a daily post. type type type type type … saaaaave? What was supposed to happen next? Whatever it was, it didn’t happen. I tried the whole “close your eyes and start typing” thing to see if muscle memory would take over, but no … I hadn’t used this setup since last June and it was gone from my fingers.

More fiddling and fussing – it turned out there was no muscle memory to forget because I’d had it set up to autopublish on save. One of the cool things about ox-hugo is that if you leave a post heading in TODO state, it’s a draft, so saving and auto-publishing is safe, even if you forget and wander off and push another commit somewhere.

But saving availed me nothing … huh … more poking.

Oh, right … I took ox-hugo out of my packages.el when I stopped using it to keep things light.

Now it’s working again.

And wow did I just elide a ton of stuff I had so step back through to get it to where it “just worked” again. My config.org was full of helpful notes like:

Of particular interest: org-hugo-auto-set-lastmod, which is set 't in a lot of examples. This one is pesky because when set 't it will bump the date on posts that don’t have a date: property set (in favor of org-hugos EXPORT_HUGO_DATE). You don’t get bit until you have org-hugo-auto-export-on-save set, at which point fat-fingering a save in the wrong post will change its mod date and hence its published date, teleporting it into the future.

… but the whole setup was still littered with stuff I couldn’t understand. Like …

 COMMENT Local Variables :ARCHIVE:
# Local Variables:
# eval: (org-hugo-auto-export-mode t)
# End:

Why the COMMENT thing? Why the ARCHIVE thing? Why “End:” I don’t remember how I learned that stuff or why it is what it is. I am pretty sure there were 10th century Saxon peasants who understood more about how ancient Roman highways were engineered than I was able to understand about my own setup.

I don’t think, the day before I was let go from, er, “Puppet by Perforce” that I imagined I’d spend as much time as I did doinking around with org-mode blogging, but wow did I. It was fun. I can tell it was fun because I was leaving myself paragraph-long notes on minor configuration issues.

I used to play this tower defense game on the Mac called Hordes of Orcs. Orcs would enter a maze, you’d build towers of all kinds to murder them. After playing for a while, I came to pick out a certain aural signature. As you built more and more elaborate orc-murdering capabilities, you could begin to hear a rhythm emerge – the sound of a tower spraying hot death, the sounds the orcs made. It was not a rhythm game, but it invoked a similar feeling. I came to think of a session of HoO as “firing up the murder factory.”

Well, Vampire Survivors sort of does that, too. I didn’t really notice until I turned the music off, but as a level progresses and gets more intense and your character is surrounded by a number of orbiting weapons (boomerang axes, a lethal garlic aura, puddles of holy water dropping from the sky, two orbiting birds that rain death, etc.) you can hear the rhythm of all those things interacting.

It also occurred to me that Vampire Survivors reminds me a lot of Robotron: 2084.

Anyhow, it’s an awful lot of fun for such a simple game.

kitty and denote

Okay.

1. Emacs as a systemd service? Check.
2. Launching useful stuff in kitty? Check.
3. Making a quick Denote note in kitty … ?

Sure.

Make an org capture template like this:

(with-eval-after-load 'org-capture
  (add-to-list 'org-capture-templates
               '("n" "New note (with Denote)" plain
                 (file denote-last-path)
                 #'denote-org-capture
                 :no-save t
                 :immediate-finish nil
                 :kill-buffer t
                 :jump-to-captured t)))

… then add this to kitty.conf:

map kitty_mod+d launch emacsclient -t "org-protocol:///capture?template=n"

That launches an emacsclient instance in a new kitty window teed up to enter the title and tags for a denote note.

There’s another way to do this, using kitty’s startup sessions capabilities.

You can make a session file with something like this in your config directory:

launch emacsclient -t "org-protocol:///capture?template=n"
focus_os_window`

… name it something like denote.conf

… and launch it with kitty --session denote.conf.

Which isn’t really what you want to do. You really want to use that for a custom keybinding out in your window manager.

terminal maximalism?

Seeing my agenda for the day in a terminal … getting my upcoming todos in a terminal … denote notes in a terminal …

Is this all some sort of terminal maximalism thing?

Maybe, I guess?

I don’t know about the rest of the world, but I go through moods with this stuff. Some days I feel supremely unfussed about the assorted UIs imposed on us by web app designers. Some days I feel very resistant to messing around with a browser or mouse. It’s nice to sit down to a text editor in a terminal, start writing, and be able to quickly orient on where I’m at in the day with a glance at my agenda or the day’s todos. There are some days I don’t feel put upon doing that in a browser window.

Looking at nb is what got me thinking about doing more in a text shell, but I couldn’t figure out a good way to solve for the mobile use case and I didn’t want to live in it as my task manager. Sometimes it is handy to be able to manage or just review todos with a GUI. Its notes tool is fine, but I spent a lot of time setting up Denote and really appreciate it, plus I have a way to review my Denote notes via the web and create them on the go with Drafts.

And when I think about my little 11" MacBook Air, that’s a machine that would benefit from not having a lot of GUI clutter and not having a lot of open apps. It’s a great candidate for spending more time in a terminal.

So … less terminal maximalism and more terminal optionality. For days when pointy-clicky feels really burdensome.

Anyhow, I did find a few good collections of CLI app links:

• awesome-cli-apps
• awesome-shell

I think my favorite discovery from both of them at this point is probably autojump, which watches where you visit and lets you go there from anywhere else, rather than having to descend and ascend a directory hierarchy. If you want to give it a try, the documentation is missing one key thing, at least if you pull it down from Fedora: You need to source a file it sticks in /usr/share/autojump in your shell’s .rc file. The core package in Fedora supplies that file for bash, and you have to install the autojump-zsh package to get it for zsh.

the working world

Today I feel very annoyed with what I have come to think of as “Businessing,” which is to say “all the things people do in the course of working in a business, but especially the ones that involve things nobody will say and rules nobody will articulate.”

I don’t think I have much more to say about it than that, so consider this me quietly whispering discontent into a hole in the side of a stump in the middle of an empty field under a new moon at midnight.

Okay. I have a little more to say.

Years and years ago I read Paul Fussel’s Class. I was at something of a personal low point: Recently out of the army, a very different person on the other side of the experience, and feeling exiled in a small southern university town. Class gave me a lens for observing other people that my feelings of unbelonging and insecurity hadn’t ever allowed through. It’s a light, biting book that would pair nicely with Barbara Ehreneich’s Fear of Falling.

Once I saw the thing Class calls out when it’s at its most empathetic – the constant and pervasive atmosphere of insecurity middle class people occupy and perpetuate – it made some things about work a little easier. But just a little.

I set up a Linux PC over the weekend, and I’m going to give Pop!_OS a try on it. I want to be able to use this machine for work sometimes, and there are a few desktop-y things that work better under Pop! than they do Fedora, maybe owing to Pop! remaining on xorg. Screen sharing in Zoom, for instance, works like you’d expect on xorg and does not under Wayland. Apps with taskbar icons also work without the need for an extension.

You can tell Pop! is a little behind Fedora 39, but I’m not sure it’s that big a deal. I found a PPA for Emacs 29.1, but don’t worry about much else: The stuff that moves with any speed is coming from a Flatpak. My ~/bin, ~/.fonts, and ~/.config/doom are all handled via SyncThing.

What else?

• I noticed that my Elgato CamLink 4k + FujiFilm X-T2 work with a little less lag. I think there still is some, but it’s pretty smooth.
• shairplay-sync has some permissions issues as a service, but works fine when I start it in daemon mode, so I’ve moved my bookshelf speakers over to this machine: It acts like an AirPlay 2 endpoint for all my other stuff, and I can use Cider to get at my Apple Music stuff when I’m working on this machine.
• There’s less font weirdness than under Fedora, meaning most apps show most fonts at a normal size out of the box and don’t require passing environmental variables along or messing with config files.
• My Jabra Engage 75 works fine with this thing, so no more messing around with AirPods: I just plugged it into an open port and I’m back to reliable audio.
• The rbenv and ruby-build that ship with Jammy don’t have any of Ruby 3.x available. I just installed that on my own and added ruby-build as a plugin. Problem solved.

Otherwise … I got through a day with it and it worked great: No weird glitches, crashes, or whatever. Multiple Zoom calls. Oh, and I’m down to my last possum sticker, but the wireless scanning stuff works great, too: I managed to get a hi-res scan of my last sticker so I can make more.

Bad company

I like company-mode in Emacs when I’m coding, I hate it when I’m writing prose. It slows everything down to suggest words I do not need suggested. This incantation fixed it:

(setq company-global-modes '(not text-mode markdown-mode org-mode))

Don’t spin me

I enjoyed the most recent episode of Bad Faith, “Vibecession?”, partly for the analysis and partly because one of the guests got to the thing that has been bothering me the most about the discourse around the economy:

“… as to why people are so heated in the first place I think you have a few things going on. One you do have people who are just kind of concerned about Biden’s electoral prospects they’re worried about Trump and they’re worried about […] a negative narrative.

“You’ve always got people out there who although they […] appear to be kind of making objective arguments about this or that topic they’re really mostly worried about trying to kind of steer the discourse in one way or another to to be more favorable to Democrats or less favorable to Democrats or whatever so there’s that aspect […] of the election worrying …”

I posted about it a few days ago:

… and then:

… and then I favorably boosted this:

… because if there’s one word I have worn some grooves into over the past four years, it is “precarity.”

I don’t know. We can either speak truthfully or we cannot, and I am not responding well to progressives or leftists or whatever who do not want to speak truthfully because they believe that are actually unpaid press secretaries for the Biden administration.

I’m not telling anyone what to do with their spare time, I’m just saying that if you’re talking to me, leave me out of the four-dimensional chess game. I show up every election and vote exactly as you’d expect. It is okay if, in December of the year before an election, I say “I wish we had a better alternative than Biden.” And it is super okay if I say, “you know what, I wish we had a better alternative than this entire way of being we’ve landed on.”

A Disturbance in The Force

A Disturbance in the Force is a documentary about the 1978 Star Wars Holiday Special.

Al and I went to see it at the Hollywood Theater several years ago. I managed to win a cool Boba Fett poster (the cartoon version, from the special). It truly is wretched, but the documentary does a nice job of explaining that actually everything in 1978 was at least a little wretched, including the entire variety show genre.

And it does a nice job of explaining why the silly thing even mattered to anyone.

I had just turned nine when Star Wars came out. My family went to the theater to see a 6 p.m. showing on opening weekend in 1977, and ended up waiting around for a special 10 p.m. showing the theater added. It stayed in that theater for the better part of a year, and it became a way to just get me out of the house: Mom would give me ticket money, I’d walk across the field and hop a ditch to get into the loading dock area of the mall, then walk around to the theater. When we visited relatives that year, “what would Mike like to do” was always “go see Star Wars.”

I was completely saturated in anything Star Wars I could get my hands on. Magazines, copies of People featuring any of the cast, the novelization, the comic books, aaaaanything. So the Holiday Special was a huge deal because it was gonna be more actual Star Wars and not just stuff about Star Wars.

And, as someone points out in the documentary, Star Wars was a very wild property at that point. Like, there were hints of deep lore and all, but the only “canon” you had to work with was the movie itself and wild theorizing. Some heretics thought Darth Vader was actually a robot. There were rumors that there would be a whole movie about Wookies. It was just this crazy thing that had landed in our pop culture lives and nothing was ever going to be the same again. So we were ripe for whatever George Lucas wanted to churn off the assembly line, including, apparently, a superannuated Wookie grandfather perving out to VR porn with Dianne Carroll.

Anyhow, the documentary is a fun 90-minute diversion. Not super heavy, but cool to hear from people who actually worked on it, and fun to see a lot of period clips, like the bonkers Donnie and Marie episode with Kris Kristofferson Han Solo and Paul Lynde Imperial officer.

Hugo Previews in Emacs

I made this function to spin up the Hugo preview server while still working in Emacs:

(defun my-start-hugo-server ()
  "Run Hugo server with live reloading."
  (interactive)
  (let* ((root (projectile-project-root))
         (default-directory root))
    (compile "hugo server -D --navigateToChanged" t)))

(defun my-stop-hugo-server ()
  "Stop Hugo server."
  (interactive)
    (kill-compilation))

(map! :leader
      (:prefix ("H" . "Hugo")
       :desc "Start Hugo Server" "S" #'my-start-hugo-server
       :desc "Stop Hugo Server" "s" #'my-stop-hugo-server))

Reader, I lol’d.

magit-wip-mode

magit WIP modes:

“Git keeps committed changes around long enough for users to recover changes they have accidentally deleted. It does so by not garbage collecting any committed but no longer referenced objects for a certain period of time, by default 30 days.

“But Git does not keep track of uncommitted changes in the working tree and not even the index (the staging area). Because Magit makes it so convenient to modify uncommitted changes, it also makes it easy to shoot yourself in the foot in the process.

“For that reason Magit provides a global mode that saves tracked files to work-in-progress references after or before certain actions. (At present untracked files are never saved and for technical reasons nothing is saved before the first commit has been created).”

I wander back and forth machines a lot and this seems like useful insurance, so I turned it on.

accurate but not good

Luke prompted a half-response this morning:

I replied in a spirit appropriate to me, which is to say “disappointed idealist who should learn to either quit being disappointed, or give up on being an idealist, or get a new sense of humor.”

Because that article feels like a bookending, illustrative underscore of this column, which I went into sort of nodding along in a “checks out” sort of way, then sitting up straight when it got to:

“Expect more antiracist action plans, more vaporous decolonization, more mandated training, more huckster consultants, more vacuous reports, more administrators whose jobs no one can explain, more sleazy land acknowledgments (“Sorry I stole your house!”), more performative white self-flagellation, more tokenization of minority faculty members.

“And amid this great tornado of race chatter, if you take a moment to plug your ears and look around, you will probably begin to notice fewer and fewer brown and Black kids reading on the quad and, down the line, fewer and fewer brown and Black doctors in the maternity wards. It will turn out that all those initiatives will have next to nothing to do with actually combating structural racism. We may well find ourselves teaching Toni Morrison to rooms that get whiter and richer by the year.”

The biggest change I noticed at my job from 2019 to 2022 was that HR managed to edge everyone out of anti-racist work, and suddenly anything that seemed like it could be meaningful and engage senior managers was ruled “performative.” Mentorship programs? Performative. Sponsorship programs? Performative. I came to realize that “we don’t want to be performative” was just a thought-terminating cliché meant to shut down the conversation.

What were you supposed to do? Basically, fill low-stakes associate positions, maaaaaybe send a manager out to specific recruiting events, but otherwise just hand the entire hiring process over to recruitment and forget about it. If you looked at any demographic information that suggested perhaps the lenses you were supposed to use — ratios that ignored role or level — were problematic, you were asked how you got the information you were using because they thought they’d locked it all up. And I watched a good leader driven out by someone who weaponized the whole topic.

When I helped interview HR business partners, it suggested to me that what I was seeing wasn’t just local. One of them got uncomfortable when I asked about their experience with ERGs, and preferred to discuss how happy people were with a local soccer team ERG they’d sponsored. I honestly didn’t know what to do with that, but just marked “strong no,” explained why, and was relieved the hiring team went another direction. For all I know they thought that — as an older, white, male interviewer — I wanted to hear about a soccer ERG instead of an identity-based one, but I didn’t feel like playing eight-dimension chess. Including soccer fans seemed like an odd DEI triumph.

So if I’m coming off a little mordant about an NYT piece that manages to both report and perform a certain weird forgetfulness in the summer of 2023, it’s because I’m struggling to understand what we got besides a new consultant class, a new slice of territory for HR departments, and vague commitments to “work on ourselves.” I can’t get mad about the reporting itself, because it seems accurate. It’s where we all are. What do we want to do about that?

New loom on the Himalayan

I stuck the new loom on the RE Himalayan today. It was a 20-minute process, from taking off the side plate to figuring out where everything was, to disconnecting and reconnecting all the connectors.

The net effect is that it puts the gear detector behind the ignition instead of straight to the battery, which I hope will stop the parasitic drain I’ve been dealing with. It’s a weird thing to have to do, but I read a few rumors online that some dealers have been putting them on at sale. It’s just a bad design decision with a $25 fix.

Al and I took a ride for groceries this evening. When we got home I took a reading off the battery then set a reminder to myself to check back in 24 hours to see whether the drain seems reasonable. Since I put an Antigravity battery in there the stakes are a little lower if it drains too much while I observe.

Not related to the loom, the bike is running really well now. It sounds good, feels smooth, and I’ve appreciated how manageable it is. I had it out twice today and just enjoyed driving it through a few curvy parts of southeast Portland in the sun. We’re thinking about taking a camping trip down in Clackamas County and going out separately so we can bring the Himalayan along and enjoy some forest service roads and rides along the river.

Still considering trading it in or selling it, but it’s growing on me again. I just wish RE was just better at QA overall. I’ve got $125 worth of dongles hanging off the thing to get it to just do what it should have done out of the factory, I’ve spent four hours sitting around the dealership while the mechanics grudgingly fixed stuff like pinched vacuum hoses and weirdly tuned electrics, and I spent a bunch of my own time hand-tightening connections and digging overpacked grease out of connectors.

With all that time and effort invested, it’s behaving. I don’t know if I’d recommend these bikes to a newbie. I have some patience and don’t mind having to do a little work — it’s sort of educational and interesting. Someone new to the hobby shouldn’t have to think about that stuff when they’re trying to just learn the basics and wondering if stalls or glitches are their fault.

Al and I went to our first Portland Thorns match last night. I think this is maybe the third soccer match I’ve ever been to. The two previous were Timbers games for company parties and one of them got rained on pretty hard.

Since this was my first “go sit in the regular seating, pay attention for 90 minutes” match I wasn’t sure what to expect. It was pretty fun. Our hosts are on their first season passes and newly energized about the sport, so their enthusiasm rubbed off. I think the other thing I kept coming back to was that watching requires patience similar to watching high-level jiu jitsu grapplers, but the other fans do a lot to contribute to your sense of the ebb, flow, rising and falling tension.

More Lemmy

I have three accounts on assorted Lemmy instances, with a fourth pending. I learned about wefwef yesterday, which is a PWA that provides a nice client you can save to your phone homescreen same as Elk for Mastodon. I also have the beta of memmy on my phone.

There’s not a ton of interaction on many of the communities I’ve subscribed to so far. There’s a portland one where people are swearing to be nicer, less hostile, and less censorious than /r/portland, which is a super low bar; and also less reactionary and goonish than /r/PortlandOR, which — again — low bar.

You can subscribe to communities in Mastodon by adding their address sans the ! lemmy convention. I added a few but there’s the usual “now your instance needs to start pulling their stuff in” lag.

Secret Invasion

I’m two episodes into the Skrull/Nick Fury espionage series Secret Invasion. Not sure. It feels like in terms of size, scale, and texture it’s maybe a step down from The Falcon and The Winter Soldier, which felt pretty slick; and maybe a step up from She-Hulk Attorney at Law, which felt like it was made on a shoestring budget. None of those three have the charm of Hawkeye.

The dialog’s sort of flat, there are “big scenes” that feel small. Samuel L. Jackson is doing something different and I’m not sure it always works. There’s a reason to not involve the Avengers that … it’s going to always be a problem when there are any issues going on of a sub-Thanos scale where you’re not just sending a group of second-string probationary Avengers to fix it.

But, you know, let’s see where it goes.

Emacs function for tagging posts in Hugo

I seem to be sticking to just blogging in Markdown, using the Ruby script I wrote. I didn’t realize how much I missed reference links, or Markdown link notation in general. Tags are a little different story. I like the way ox-hugo uses org-mode’s heading tags (:foo:bar:baz:) instead of Markdown/YAML’s key tags (tags: ["foo","bar","baz"]).

So I made mph/replace-tags-in-frontmatter and stuck it in my growing Hugo submenu. You just invoke it and enter a comma-delimited set of tags and it replaces that frontmatter key. My script asks for tags up front, which is fine for single-topic posts where I know the tags up front. Doesn’t work as well for daily posts, where it takes a day to know what’s going in.

(defun mph/replace-tags-in-frontmatter ()
  "Replace the 'tags' line in YAML frontmatter with user input."
  (interactive)
  (let* ((frontmatter-start-regexp "^---\n")
         (frontmatter-end-regexp "\n---\n")
         (tags-regexp "^\\s-*tags:\\s-*\\[.*\\]")
         (input (read-string "Enter new tags (comma-separated): "))
         (new-tags (mapcar (lambda (tag) (format "\"%s\"" (string-trim tag)))
                           (split-string input ","))))
    (save-excursion
      (goto-char (point-min))
      (re-search-forward frontmatter-end-regexp)
      (backward-char 1)
      (re-search-backward frontmatter-start-regexp)
      (forward-char 1)
      (re-search-forward tags-regexp)
      (replace-match (format "tags: [%s]" (mapconcat #'identity new-tags ","))))
    (message "Tags replaced successfully.")))

(map! :leader
      (:prefix ("H" . "Hugo")
       :desc "Set tags for Hugo post" "t" #'mph/replace-tags-in-frontmatter))

Ben in France

Ben watched the Apple store in Strasbourg get smashed and looted, avoided a tear-gassing, and was briefly separated from his bike. He finally made it to the train after missing the first one out of town. Now he’s on to the Netherlands.

When I was almost his exact age I went to Europe and then the then-Soviet Union as part of a student group. Our professor gave us a lot of advice on how to avoid local trouble, and since it was winter things were pretty much on rails anyhow: Cologne was mild, Copenhagen was wintry but okay, Stockholm was extremely cold, then Leningrad and Moscow were where I learned that -40 is the same on both the Fahrenheit and Celsius scales. Hungary: Cold and snowbound. Zurich: Not so bad but we were staying near a park known for aggressive cop sweeps. So there were opportunities for a little bit of mischief, but the overall vibe was “travel in groups, don’t go off alone.” So we mostly didn’t except for one guy who made himself sort of the group pariah.

When I think about my year in Korea, I’m surprised nothing happened. I was there during a summer with some violent anti-US protests thanks to high-profile brawls between soldiers and Korean civilians. We were locked down on post for several weekends straight because the risk of violent altercation was high. I was a little bit of a loner over there, so it wasn’t unusual for me to be out in the ville on my own, and a few times when I had to drive command staff up to Seoul for overnighters I just wandered around on my own after they cut me loose for the day. My KATUSA friend said my lonerish-ness made him nervous. I was in a weird frame of mind at that point — fresh out of jump school and hence invulnerable, more physically capable than I’d ever been — but he had a list of places I wasn’t supposed to ever go and said the stakes would be higher than a beating or a black eye, so I didn’t go to those places. I got followed a few times other places, did the whole “demonstrate situational awareness” thing, and nothing ever happened.

Ben’s over there with two other kids just roaming around, with the itinerary seeming to change as whims take them. It continues to make me incredibly happy for him. It took me a while to gain the confidence he has, his street savvy is a lot higher than mine was at his age, and his confidence comes from knowing how to get away from whatever it is, not steer into it.

typography

I saw a blog go by with a really nice serifed body type. I spent 30 minutes messing around with Google Fonts trying to dial in something similar and ended up not liking anything I saw, so I picked something completely different to freshen up headings and nav but otherwise left everything alone. I’m not sure how much of not liking things was not liking them and how much was not being sure of my own typographical taste. Part of me thought “oh! well! Go learn!” and the rest of me outvoted that part.

Anyhow, day two of a four-day weekend. Nothing on the agenda for the next two days besides visiting a friend for a walk through Oaks Bottom tomorrow, and having some friends over for dinner for the Fourth. The park across the street is going to go completely bananas with the usual impromptu fireworks show, and there’s a better-than-even chance of the show more or less ending with a drunken brawl, so we tend to stick close to the house every year to make sure nothing catches on fire. This will be the 14th year we’ve enjoyed this particular experience. This year I’m anticipating it with less dread than normal, and maybe even a little amusement.

Somehow our little park became the place a lot of people go to set off their illegal fireworks. People start showing up in the early afternoon to set up chairs and blankets at the edge of the treeline. Within an hour of sundown everything is parked in and there are two rows of picnic chairs around the perimeter of the park, which is a block square minus maybe 50 or 75 yards of treeline on our end of it.

On the one hand, wow it can be annoying, especially when people block your driveway, set fireworks off next to your car, or set things on fire. And nobody packs out their trash, so the park is strewn with trash and expended fireworks the next morning. But it’s also just … this thing that happens. People get a lot of joy from it. It’s not official or sanctioned. It’s seems to be a spontaneous thing and it happens every year. When we had a rescue dog who was terrorized by the whole thing it was the absolute worst. Now that we don’t, I feel bad for all the other dogs and people in the neighborhood who are suffering, but it doesn’t feel personal, and the cops and fire department have zero interest in doing anything to curtail something they come around and watch every year. So there’s not much to do but watch it unfold and people watch.

I mentioned a few weeks ago that I was trying out Golden Ratio, an Emacs package that dynamically resizes windows inside the frame as you switch between them. I saw a few warnings here and there that it had a few bugs, but for the past few weeks it seemed fine. I finally came across one a few days ago that I couldn’t quite isolate — it broke the way org-insert-structure-template worked — and finally took the time to narrow it down this morning.

Golden Ratio isn’t being maintained anymore, so I decided “not enough time in the day,” marked that part of my config :tangle no and installed Zoom,, which does much the same thing.

Minimum config:

(custom-set-variables
 '(zoom-mode t)
 '(zoom-size '(0.618 . 0.618)))

Post-reddit

Golden Ratio made me think about reddit for a bit. I learned about that package from one of the Emacs subreddits. I don’t recall a ton of discussion about it, so it must have been one of the quiet link aggregator subs, like /r/planetemacs. That was the other half of my reddit experience: Grazing steady feeds of interesting stuff. I’ve learned a lot about assorted interests — motorcycling, longboarding, Emacs, ruby — from watching a subreddit scroll by and just grabbing links.

That part of my experience is largely unaffected by the third-party app shutdown. I don’t follow or participate in discussions much, so I can do that from a browser or reddit’s own, terrible app.

But while I’m not, like, boycotting mad, I’m irritated. I don’t know how spez managed to press so many buttons at once with me — ordinarily tech dude stuff rolls off my back, and C-level tech dude stuff barely registers as language or thought, but the combination of smarm, Ralph-Wiggum-esqe “I’m a business man <eats paste>” posturing, deceit, and bizarre turn into trying to make the whole thing some sort of identity politics issue just … wow.

Like, look: Even at my most business-like — my most “jacked director” — I’m pretty much just one of those vintage-looking prints you see at mall restaurants of little kids dressed in adult clothing sitting at a desk on an old-timey phone or whatever. If I have a philosophy of business communication or governing principle for “how I show up,” it is probably “best to keep your mouth shut and be thought a fool …” etc.

But when I read the clown-like attempts at businessing going on over the Apollo debacle — the appalling, weak blithered promises that everyone was gonna be cool here — I was sort of appalled and a little embarrassed for them. It was like when you ask one of your managers “so did you give them that feedback about promotion?” and they swear to God they laid down the law but their report took it like a champ, then you actually read the check-in and it’s, like, “Joe Grudd was stellar this year. Recommending for immediate promotion. Top notch ace contributor. Indispensable.”

And then, after dithering around and failing to just sit up straight and deliver the damn message, they let themselves get clowned. Nobody covered themselves in glory in whatever negotiations were going on, but table stakes for people who’re busy ruining the customer experience on a beloved website because They Are Serious Business People Who Get How This Works is pretty much “don’t look worse than the one-man cottage industrialists who’re hoping you’ll get them to go peacefully if you just buy them out ha ha only serious.”

But somehow they couldn’t even do that.

Anyhow.

It just sort of shades the whole experience now. Perfectly nice, sometimes emotionally violent shitposters just getting on with their days, the occasional incel breaking cover and going down in a hail of gunfire under the helicopter spotlights of the moderation team, no longer ad free, forcing you to remember that when someone says “have some gold, kind stranger” that gold was sold to them by the Ed Rooney of web publishing. There’s just this lingering fart smell wafting through it all. Where do you go from here?

Lemmy

Well, I decided to look around at Lemmy.

I get it, more or less, and am assuming that all the weirdness I’m seeing is down to the same thing that happened with Mastodon last fall: Lots of little instances struggling to keep up with the newbies, plus different configurations, plus the codebase itself. Most of the instances I skipped through were either slow or glitchy. The most solid Lemmy instance I’ve seen — sometimes slow but usable — is the unfederated hexbear.net, and I don’t think it counts.

So I signed up for a couple of more normal ones and will revisit as things calm down.

Himalayan Day

Today is “work on the Himalayan day.” My new Antigravity self-jumping battery is here, the mounting base and passenger back pad for our Givi topcase are here (which will make it easier for Al to ride pillion), and I did some reading about how to test for that parasitic drain. So I’m going to give it all a few hours out in the driveway with a wrench and a multimeter. It’s sunny and beautiful, so I’m looking forward to the ride after I’m done.

I’m kind of wondering if this small round of “get ready for sale, but also make it a little nicer” investment will change my mind about selling it.

My strong impression of Himalayans in general is that the user base is split between people who just drive them off the lot and love them, never really having much trouble that doesn’t get addressed during early service; and people like me, who get a badly QA’d one and more than their share of glitchy components.

I like riding the thing. It’s a manageable size for city riding, and it does really well anywhere you’d want to go in the Portland metro area. Holds its own on 205/84, fine for runs up to St. Johns or Sauvie Island, great down to Estacada. With the panniers and topcase it’s fine for groceries. There’s just enough power to two-up in town on date nights. I don’t think I’d ever take for a run down I5, but I could see running downstate on the back highways.

I’ve done so much to it at this point that there’s some sweat equity I don’t want to part with. If I could nail down the parasitic drain I’d have a bike that I feel more than a little attached to, because I’ve put a lot of time into getting it dialed in. Knowing there’s a dealership up in St. Johns that spends most of its time selling RE’s, vs. the sort of crappy “RE’s are a weird loss-leader for broke Harley wannabes” dealership out on the west side I had to get early service from, makes me a little more hopeful, too. It was frustrating having to go do my own research about assorted RE glitches then convince the service team to try fixes. I get the impression the St. Johns people are a little more into REs and would be a little more proactive.

We’ll see. If I get it into a place where it just feels good and I don’t have that “poorly shimmed table leg” feeling every time I turn the key, maybe we continue another season.

Anyhow, that’s the plan for today, so I’m gonna save and ship this.

Thorns game

Oh … going to a Thorns game tonight. Our first. Kathleen and Amy had extra tickets, so off we go.

It shows up as a thing in the latest release notes and it seemed to be true when I looked for it this morning: Sync on the reMarkable between desktop app and device is a lot faster. Not sure it’s “instantaneous,” but it’s in the range of “wrote a note on the device downstairs, it was on my desktop by the time I got upstairs,” which is a vast improvement. No idea if it will be consistent.

I sort of wonder about reMarkable, generally:

They just dropped 25 percent off the cost of their expensive keyboard accessory, and they’re trying to herd users into annual plans. There are a lot of similar devices on the market, including stuff from Amazon and Kobo that combine note-taking with ebook reading. If I’m doing the tradeoffs, the things that might count as “nice” on a reMarkable have to compete against the combined utility of a device that lets me read all my stuff from their respective stores, and take notes.

Personally, if I could make the thing go away and pocket $200 for it without dealing with assorted Craigslist randos who’d try to trade me for a kayak with a hole in it and a moldy bag of weed I’d take that deal. It has never really found a place in my workflow that has lasted. I won’t say I regret it, but it just doesn’t work for me.

Obsidian, again

I knew that once I had a new job things would begin to change for me. Stuff I previously felt like messing around with would seem less fun to mess around with, and my assessment of a given tool would take a harder edge.

This week was my first week at work where I was in “full engagement” mode for the balance of the week: Back-to-back days, ad hoc meetings, just needing to get stuff done quickly. I wanted to do stuff like “take this free 15 minutes to go downstairs, drink a glass of water, and look at the four todos I just added to my list before starting the next call.”

It was all very clarifying. For instance, these general things about writing notes all occurred to me:

• Mobile matters, both for writing and reading.
• If I have a spare few minutes to hack in a feature, I’d rather do it in JavaScript than elisp.
• I prefer sync infrastructure be somebody else’s problem.
• It turns out that if life were a Richard Scarry book, for eight hours of the day I would be, like, a bear with spectacles and a neck tie who does business stuff. Markdown is sufficient for “businessman notes.”
• Future-proofing matters to me.

These things about Emacs occurred to me:

• I like sitting down and writing longer-form stuff with it.
• I am grateful for it as my daily driver text editor for programming.
• Given Doom and very modest customizations, Emacs “just works” for me.
• I am better off as a “slow Emacs” person, not a “fast Emacs” person.

On that last, it means that I do better with Emacs when I am doing things that I tend to configure once and never mess with again. Like, it’s enough to have Rubocop and LSP working for my Ruby coding. Done. It’s enough to know how to preview a Markdown file, and I don’t care about any other stuff I could do with Markdown mode. Done. Electric modes for the things where I care? Great. Done and done. That’s all “slow Emacs.” Figure it out once, take your time doing so, then never think about it again.

Fast Emacs stuff tends to be whole workflows, and I am constantly tweaking those. I can’t stop. I hate wasted motion, I hate having to remember three words separated by hyphens when I can remember two letters led by a spacebar. If I can turn on a preview server and open a tab to it in Safari in a single command, I’ll figure out how to make that work. If I get an idea in my head about how to optimize something, or come to believe that something is taking more time than it absolutely should, I can’t quit worrying at it. Fast Emacs. Constant, rapid iteration on little things meant to shave seconds or keystrokes or conserve brain storage.

When I am using Slow Emacs stuff, I am in a very focused, calm place. Emacs feels steady underfoot, stuff “just works,” I quit noticing the tool.

When I am using Fast Emacs stuff, it doesn’t feel as steady. More stuff goes wrong. I end up dropping a paren and blowing everything up when I restart. Weird little things go wrong because I missed an edge case. It’s over-automation, and I know something about that because I did two IT tours and one engineering services tour dealing with over-automated teams. I’m not, like, Rock-Ribbed Business Guy on the job, but the waste of constantly getting bit in the ass by things someone made to make work easier and more efficient that become sources of mysterious failures and lost days of refactoring and debugging sort of grinds me. When I’m doing Fast Emacs stuff, I’m doing that to myself.

So that’s Emacs. These things about Obsidian occurred to me:

• When I took away some things I liked about Denote and implemented them in Obsidian, it took very little time and four community plugins (one of which is just there to provide an API for another one).
• Setting up capture templates for my common use cases involved 30 minutes of reading and poking and then maybe five minutes per use case.
• When your plugin loadout is light, Obsidian feels very sturdy. With a decent theme, it feels pleasant.
• Trying to do Fast Obsidian — heavily automated workflows — feels so self-evidently wrong that I don’t even bother. I see people doing it, it seems janky.
• Slow Obsidian – simple little keyboard shortcuts, macros, etc. is dead simple to do quickly. Those kinds of quality of life plugins are usually pretty good.
• I cannot imagine writing long-form stuff in Obsidian. I’m glad you wrote your book in it, but there is something about it — probably the busyness of the UI — that prevents me from considering it.

And these things about my free time occurred to me:

• Tool-specific subreddits are Satanic. Obsidian and Emacs both invite an endless wander among the plugins and packages interspersed by the occasional dipshit trying to pick a fight by complaining about their inability to learn something new, triggering both the hardened Tool Warriors and the soft-hearted, enabling evangelists. You’d think by now I’d be resigned to the whole “baby newbie with a broken wing” cycle, but any kind of brand or consumer identification is grotesquely fascinating to me, and the ability of someone wandering in off the street crying about how hard elisp is to suck all the air out of the room never ceases to amaze.
• I like my new job, but I knew going in that parts of it were going to be a challenge, and that’s proving out. So during the day I want to do the easiest possible thing to do things that are helpful but are not the core value I provide (like taking notes, storing information for later, and connecting this thing over here to that task over there). I don’t want to mess with those things. They need to just work. And at the end of the day, I want to be done with things that would remind me of work, which I am enjoying but want to keep in its place so I can keep enjoying it.

So after a week of living the Obsidian-but-configured-to-make-files-like-Denote life, I got into my config.org file, disabled large swaths of the configuration that have to do with Fast Emacs, and reconfigured Denote to produce markdown-yaml files in my Obsidian vault, so if Obsidian ends up bothering me, my fallback position is already in place.

• Plain text
• A little more future-proofed than Obsidian’s loose default behavior thanks to Denote conventions
• Solid mobile experience with reliable sync
• Markdown’s spare markup
• Fewer moving pieces

As long as a certain software company from Minneapolis doesn’t come and buy this place, too, I’ll reclaim my free time to screw around with something else.

This morning over tea I applied myself to learning how Templater works. It’s an Obsidian plugin that lets you run JavaScript on notes, with access to stuff like the data in the YAML frontmatter and the ability to build your own functions and make them globally reusable. With Templater, you can do the automation needed to produce Denote-style filenames with a very Denote-style “name the directory, name the file, name the tags, start editing” workflow. It sounds sort of Rube-Goldbergy, but if JavaScript is to Obsidian as elisp is to Emacs, it’s just “extensible tools require code.”

So this is a Templater template to make a new note with YAML frontmatter and user-input tags. You can see that it’s just template + a few strftime variations + a prompt:

---
title: <% tp.file.title %> // title comes from user input using the QuickAdd plugin
date: <% tp.file.creation_date("YYYY-MM-DDTHH:mm:ssZ") %>
tags: <%* let tags = await tp.system.prompt("Enter tags, space delimited", "")%><% tags %>
identifier: "<% tp.file.creation_date("YYYYMMDDTHHmmss") %>"
---

(There’s a small bootstrapping problem of how a new note can have a title to drop into the frontmatter — that’s solved with a plugin that prompts for the title before creating the note.)

So … invoke that template and you get a note that has the characteristics of a Denote note with markdown-yaml content. Its actual filename, however, will be following Obsidian conventions: Whatever the name is.md on the filesystem.

That’s not okay, because Denote’s also a file-naming convention, and one I prefer because it includes tags in the filename along with date and title. If you just keep your filenames proper, most of what you care about for long-term portability is just sitting right there in the filename, easily extractable for export/migration/etc.

Templater is able to run scripts that suck in the data in the frontmatter, and it’s able to manipulate filenames and locations. So, this is a user function that takes title, ident, and tags params and spits out a Denote-compatible filename:

function slugify(title,ident,tags) {
  title = title.replace(/^\s+|\s+$/g, ''); // trim leading/trailing white space
  title = title.toLowerCase(); // convert string to lowercase
  title = title.replace(/[^a-z0-9 -]/g, '') // remove any non-alphanumeric characters
           .replace(/\s+/g, '-') // replace spaces with hyphens
           .replace(/-+/g, '-'); // remove consecutive hyphens
  tags = tags.replace(/ /g,"_");

  return ident + "--" + title + "__" + tags;
}
module.exports = slugify

Once you know what the filename should be, you have to actually change it on the filesystem. This is a second Templater “template” of JavaScript you can run on a note once it has been created:

<%*
	identifier =  tp.frontmatter["identifier"];
	title = tp.frontmatter["title"];
	tags = tp.frontmatter["tags"];
	slugged =  tp.user.slugify(title, identifier, tags);
	tp.file.rename(slugged); -%>

(Looking at the slugify function and that Templater code, I think you can just pass the tp object into the function to move some busy-ness into the function and away from your file template. I dunno. I’m just trying to get ping right now.)

So at that point, you have a Markdown note sitting in your Obsidian vault with a filename that conforms to Denote’s naming convention. If you visit your vault directory in Emacs using dired, the files are all fontified for Denote-browsing goodness.

And that’s where I ran out of tea and needed to go do some paying work.

I don’t yet know how to get that last function to run at the point of note creation. There’s surely some way to get Templater code to hold off on firing the next step in a script until you can get all the data in place, but I don’t know what it is. So I have the renaming template bound to a hotkey and just tap Ctrl-Cmd-r to trigger the rename once the note is ready. It’s good to have it exposed as its own command, because part of the Denote workflow involves keeping good file naming hygiene when you change note metadata, I’d just like to automate that part at time of creation, too.

The last ingredient I’m using for all this is the Obsidian front-matter title plugin. It just consults the YAML frontmatter for the title: property and uses that to display note names instead of the filesystem name. That makes directories of files a little more legible, makes tab names less noisy, etc. It does for you in Obsidian some of what Denote Menu and similar do in Emacs, pulling Denote’s useful but visually cluttered naming convention more firmly in the “human-readable” direction. It’s optional to this exercise, but preferred, especially when on mobile, where there’s less real estate to burn on long filenames.

If you visit the file in Denote, you can mess with the frontmatter and use Denote’s denote-rename-file-using-front-matter command to update the file name. If you mess around with it in Obsidian, you can run that Templater template to do the same.

If you run obsidian.el on top of all of this, it becomes possible to navigate your notes in Emacs, insert links from Emacs, etc. etc. You can’t just tap a link from the keyboard — you have to use obsidian.el’s navigation commands — but that’s not terrible.

So to solve the mobile thing, you’ve got this approach — customizing Obsidian with a few plugins and some light code to make your vault look like a Denote corpus — and you’ve got the thing I did to provide a searchable web interface.

The Obsidian route gives you a more complete mobile experience. You can make notes on the go, you have more flexibility for searching your notes, etc.

The web approach is more compact: Do some Emacs configuration, use some commodity infra with Tailscale and a Synology, then just use Denote in its native form, which is org- and desktop-centric.

Given my usage patterns, either seems fine?

Switching to Markdown for Denote satisfies a part of my brain that doesn’t like trying to script org-mode migrations and that also understands “org-mode vs. Markdown” is another one of those “Beta vs. VHS” situations I need to just accept. Commensurately, it irritates the part of my brain that completely got it when my tech writing team told me they wanted to migrate from Markdown to DITA, maybe a little before we were really there on the maturity curve.

Anyhow, it’s a hobby.

espanso

I don’t know what on Earth happened to TextExpander but wow it isn’t good.

Looking around for a text expansion tool of some kind I came across espanso. It’s a snippet tool. It behaves about like yasnippet or TextMate snippets: Start typing a trigger phrase and it expands it for you.

Most of these things are wrapped in a GUI. espanso is configurable with a YAML file. It also has some cool stuff for handling regexps that allow you to use variables to your snippets. For instance:

- regex: ":tml\\((?P<tag>.*)\\)"
  replace: "[Items tagged `{{tag}}` in Things](things:///search?query=%23{{tag}})"

If you type :tml(foo) it’ll expand to a Markdown link using foo.

[Items tagged `foo` in Things](things:///search?query=%23foo)

(I’m not sure, btw, how to do that in yasnippet and need to figure that out.)

This is kind of cool. The golden-ratio package dynamically resizes Emacs windows within frames as they become the active window. It works okay on a desktop machine, and I really like it on my laptop. Opening up a window for LSP output, for instance, kept the code buffer at a better size while still being able to track the LSP to the side.

It doesn’t work out of the box with Doom Emacs — it needs an incantation:

(use-package! golden-ratio
  :after-call pre-command-hook
  :config
  (golden-ratio-mode +1)
  ;; Using this hook for resizing windows is less precise than
  ;; `doom-switch-window-hook'.
  (remove-hook 'window-configuration-change-hook #'golden-ratio)
  (add-hook 'doom-switch-window-hook #'golden-ratio))

Demo/tutorial video:

I understand that Golden Ratio is no longer maintained. Some people say Zoom is as good, so maybe I’ll try it if I hit any of those bugs people talk about.

“When you feel the heat coming around the corner …”

I think I lost an hour to figuring out how to take a batch of existing Denote notes in org format and move them into Markdown, so I got very, very patient with ChatGPT and together we came up with this:

import os
import re
import argparse
from datetime import datetime
import pypandoc
import shutil

org_dir = '/Users/mph/org/notes'  # Replace with your directory path
md_dir = '/Users/mph/org/notes-md'  # Replace with the desired directory path for markdown files

def convert_org_to_md(org_file, org_path, md_dir, with_hashtags):
    # Recreate the directory structure in the markdown directory
    org_relative_path = os.path.relpath(org_path, org_dir)
    md_relative_dir = os.path.dirname(org_relative_path)
    md_output_dir = os.path.join(md_dir, md_relative_dir)
    os.makedirs(md_output_dir, exist_ok=True)

    md_file = os.path.splitext(org_file)[0] + '.md'
    md_path = os.path.join(md_output_dir, md_file)

    # Copy org file to markdown directory
    shutil.copy2(org_path, md_path)

    with open(md_path, 'r') as file:
        org_content = file.read()

    # Extract frontmatter variables from org file
    title_match = re.search(r'#\+title:\s+(.+)', org_content)
    identifier_match = re.search(r'#\+identifier:\s+(.+)', org_content)
    tags_match = re.search(r'#\+filetags:\s+(.+)', org_content)

    frontmatter = {}
    if title_match:
        frontmatter['title'] = title_match.group(1)
    if identifier_match:
        frontmatter['identifier'] = identifier_match.group(1)
    if tags_match:
        tags_string = tags_match.group(1)
        tags_list = [tag.strip(':') for tag in tags_string.split(':') if tag.strip()]
        frontmatter['tags'] = ' '.join(tags_list)

    # Update date stamp format
    org_content = re.sub(r'\[(\d{4}-\d{2}-\d{2}) (\w{3} \d{2}:\d{2})\]', r'\1T\2:00-07:00', org_content)

    # Convert org to markdown using Pandoc
    md_content = pypandoc.convert_text(org_content, 'gfm', format='org')

    # Generate new frontmatter content
    updated_frontmatter = {
        'title': frontmatter.get('title', ''),
        'date': datetime.now().strftime('%Y-%m-%dT%H:%M:%S-07:00'),
        'identifier': frontmatter.get('identifier', ''),
        'tags': frontmatter.get('tags', ''),
    }

    # Generate the new frontmatter string
    frontmatter_string = '---\n'
    for key, value in updated_frontmatter.items():
        frontmatter_string += f'{key}: {value}\n'
    frontmatter_string += '---\n'

    # Add updated frontmatter to the markdown content
    md_content = frontmatter_string + md_content

    # Insert tags as hashtags on the last line if enabled
    if with_hashtags:
        tags_line = ' '.join([f'#{tag}' for tag in frontmatter.get('tags', '').split()])
        md_content += '\n' + tags_line

    # Save the markdown file
    with open(md_path, 'w') as file:
        file.write(md_content)

def convert_directory(org_dir, md_dir, with_hashtags):
    org_files = []
    for root, _, files in os.walk(org_dir):
        for file in files:
            if file.endswith('.org'):
                org_files.append(os.path.join(root, file))

    for org_path in org_files:
        org_file = os.path.basename(org_path)
        convert_org_to_md(org_file, org_path, md_dir, with_hashtags)

# Parse command-line arguments
parser = argparse.ArgumentParser(description='Convert org files to markdown.')
parser.add_argument('--with-hashtags', action='store_true', help='Insert tags as hashtags on the last line')
args = parser.parse_args()

# Convert org files to markdown
convert_directory(org_dir, md_dir, args.with_hashtags)

I thiiiink that’s according to the Denote spec for Markdown, and I think that makes it good enough for Hugo, too, excepting links in the [[denote:12345678]] format.

So, what is it good for? Mostly just getting from an org-mode-based Denote corpus to a Markdown-based one. At least, it seems to “just work” to do that.

If you’re not heavily cross-linked and don’t mind cleaning up denote:-style links I suppose you could drop the whole thing into Obsidian. In fact, I did. Works well minus, again, denote: links. I was also personally curious about whether the whole mess would work well with Marksman — an LSP server for Markdown that has some interesting “make a wiki out of simple Markdown” features — but I’m missing something about Marksman. It doesn’t work well with the stock LSP under Doom, and while it doesn’t crash using Eglot, I’m still not sure of its utility.

I also tossed in a command line switch that adds the tags as hashtags at the bottom of the file, which is where I tend to put them, and also what I thought I needed to do until I realized that Obsidian actually understands the tags: ["foo","bar","baz"] notation in YAML frontmatter if you do a tag:#foo search in its search tool. So — if you’re a frontmatter person, just run it plain. If you’re not then --with-hashtags is your friend.

Obsidian.el

Another option, I guess, is obsidian.el, which is meant to provide a way to get around an Obsidian vault within Emacs. You point it at your vault directory, designate an inbox folder, and it provides ways to search by tag, etc.

I dunno. At this point it’s all just messing around and seeing how all this stuff hangs together (or doesn’t.) Fun.

I’m back and forth on whether to stick to org-gtd or to start using Things again. I wanted to re-tag some actions on the fly this morning and it took some extra typing I didn’t want to do. So far, my org-gtd and Denote usage haven’t intersected, and there is no way I can think of that any of the existing mobile tools could do anything for me at all if they did. So as I think about my Emacs/Denote/org estate, and how to decompose it and remix different pieces, there’s a pretty clean perforated line between written notes and tasks, provided I can find a way to bridge the two.

One thing I used to do when I was a regular Bear user was create a Things project for all the people I had regular 1:1s with. I set up section headings for each person in the project under which I dropped actions I owed or had delegated. At the top of that project, I had a list of links to my 1:1 notes with each person to make it easier to get to past notes during a meeting without looking them up in Bear – just save the URL to their 1:1 file, click the link, Bear opens to where I need it. This felt like a clean way to let two tools do what they’re best at: Things does have some basic Markdown editing, but I don’t generally want to embed writing/thinking in actions.

Unlike Bear, Emacs has the disadvantage of not being everywhere I would use Things, but since I’m exporting my Denote stuff to the web, my notes do have a permanent URL, and it’s derived from the filename of a given note, so it’s easy to convert the file path to the URL.

This function copies that URL to the clipboard when I’m in a note. No error- or sanity-checking: The results will be nonsense if I invoke it outside my Denote hierarchy, but I bound it to my Denote menu in Doom Emacs so it’ll only come up when it’s contextually appropriate:

(defun mph/convert-to-skyhook-url ()
  "Converts the current buffer's path to a URL for the Skyhook notes."
  (interactive)
  (let* ((buffer-path (buffer-file-name))
         (notes-directory "/Users/mph/org/notes/")
         (relative-path (file-relative-name buffer-path notes-directory))
         (html-path (concat (file-name-sans-extension relative-path) ".html"))
         (url-prefix "http://skyhook:8888/")
         (url (concat url-prefix html-path)))
    (kill-new url)
    (message "Skyhook URL: %s" url)))

Then it’s just dropping it into a Things project page and wrapping it in Markdown link markup.

There’s a converse linking relationship between todos and notes, and I made something to address that, too:

;; updated to de-hard-code the # symbol -- any symbol is sanitized for use in a URL now
(after! org
  (org-link-set-parameters "things"
    :follow (lambda (label) (browse-url (concat "things:///search?query=" (url-hexify-string label))))
    :export (lambda (path desc backend)
              (cond
               ((eq 'html backend)
                (format "<a href=\"things:///search?query=%s\">Things: %s</a>"
                        (url-hexify-string path)
                        (org-html-encode-plain-text path)))))))

It’s a custom org external link for Things. Enter a link of this format:

[[things:#foo]]

… and it will link to a Things search for #foo.

The :export section insures that when I publish the site, the things:// URL scheme survives. When org-mode comes across protocols it doesn’t recognize it mangles them. This ensures that things: URLs show up in the rendered HTML.

So if I’m sitting down to a 1:1 with “Joe Grudd,” I’ve got a link to the web version of his metanote from Things on a computer or phone. If I’m looking at Joe Grudd’s metanote in Emacs or on the web, I’ve got a link that shows a search for anything tagged #joeg in Things.

Automating dblock-driven metanote updates

I have metanotes set up in my Denote hierarchy for frequent people and topic tags. The metanotes are semi-automated at this point using Denote’s dynamic blocks.

#+BEGIN: denote-links :regexp "_rfc"
#+END:

Just C-c C-c in that block and it expands to something like:

#+BEGIN: denote-links :regexp "_rfc"
- [[denote:20230613T083549][RFC - Crosstraining]]
- [[denote:20230613T083700][RFC - IT Portfolio]]
- [[denote:20230613T083726][RFC - Status and progress]]
#+END:

All those Denote links are translated by org-publish during conversion to HTML, so a link to a metanote on the web server gets me to the HTML version of all the linked notes.

If I’m on a laptop, getting to the metanotes is pretty easy: They’re all in a metanote at the top of my Denote hierarchy, so that’s easy enough to get to in “full computer” contexts.

The biggest hole in this workflow is that that dynamic blocks have to be updated. I semi-automated it yesterday with a save hook in my Denote directory that updates any dblocks in a file before it saves, but you have to be in a metanote for that to happen.

Not sure if there’s a more efficient way to do it, but this automates the update process:

(defun mph/update-meta-dblocks (directory)
  "Update dynamic blocks, save, and publish HTML for files with '_meta' in the name in the given DIRECTORY."
  (interactive "DSelect directory: ")
  (let ((files (directory-files directory nil "\\.org$")))
    (dolist (file files)
      (when (string-match-p "_meta" file)
        (let ((org-file (concat directory "/" file)))
          (with-current-buffer (find-file-noselect org-file)
            ;; Suspend hooks temporarily
            (run-hooks 'no-hooks)
            (org-update-all-dblocks)
            (save-buffer)
            ))))))

(The run-hooks 'no-hooks business is there to keep my post-save publishing hooks from running with each touch, which I think will make this safe to use as a pre-processing hook.) I think I’m going to just use it as I remember it for a few days until I can see how much time it chews up. Maybe it’s better run as a scheduled batch thing now and then.

Cleaning up org publishing exports

I also took the time to clean up HTML publishing last night. Emacs documentation ftw: I used the publishing options page to run down settings/variables and what they do. In particular:

org-html-divs

I use SimpleCSS to save a few steps. org-html-divs lets you set the preamble, content, and postamble element types and id’s, so:

(setq org-html-divs
    '((preamble "header" "preamble") ;; set the preamble div to a <header> element with an id of "preamble"
      (content "main" "content") ;; etc.
      (postamble "footer" "postamble")))
(setq org-export-with-author nil)

I kept the id’s so I could have a reference for debugging and keep sight of org’s nomenclature.

org-html-preamble

To get a SimpleCSS nav into place, markup has to go into the export’s preamble:

(setq org-html-preamble "<nav><ul>
                           <li><a href=\"/\" class=\"home\">Home</a>
                           <li><a href=\"/sitemap.html\">All Notes</a>
                           </ul>
                         </nav>
                         ")

org-html-head

To pull in SimpleCSS, FuseJS, and a local style sheet:

(setq
      org-html-head "<link rel=\"stylesheet\" href=\"https://cdn.simplecss.org/simple.min.css\" />
                     <link rel=\"stylesheet\" href=\"/local.css\" />
                     <script src=\"https://cdn.jsdelivr.net/npm/fuse.js@6.6.2\"></script>")

espanso

I don’t know what on Earth happened to TextExpander but wow it isn’t good.

Looking around for a text expansion tool of some kind I came across espanso. It’s a snippet tool. It behaves about like yasnippet or TextMate snippets: Start typing a trigger phrase and it expands it for you.

Most of these things are wrapped in a GUI. espanso is configurable with a YAML file. It also has some cool stuff for handling regexps that allow you to use variables to your snippets. For instance:

- regex: ":tml\\((?P<tag>.*)\\)"
  replace: "[Items tagged `{{tag}}` in Things](things:///search?query=%23{{tag}})"

If you type :tml(foo) it’ll expand to a Markdown link using foo.

[Items tagged `foo` in Things](things:///search?query=%23foo)

(I’m not sure, btw, how to do that in yasnippet and need to figure that out.)

The other half of the “get more mobile with Denote and Emacs” conundrum — outside the stuff where you can read notes — is the capture part: Being able to get things into the system when you’re out and about and maybe don’t have a laptop along.

The glue for everything I’m doing to address the mobile stuff is Syncthing, with all the nodes connected via TailScale. On my iOS devices, I use Mobius Sync as my Syncthing client. Since I’ve got Syncthing running on a Synology, that provides me with a central node to compensate for mobile or seldom-used desktop devices coming in and out on the TailScale network as they sleep and wake up.

To make my Denote setup more mobile, I’ve got SyncThing updating my published notes folder more frequently than the default, and I’ve got a save hook for my Denote directory that both publishes my Denote notes as HTML and runs the note indexer script that FusionJS depends on to make search fast. Since org publishing is incremental, there’s not a big hit when I save a Denote file: It recreates the notes index and runs the Python script, which takes about a twentieth of a second to complete at this point because all it cares about is the filename and the tags (which are built into the filename.)

Over time, as my notes scale, that script might take longer, and that’s fine: It is also running on the Synology where performance isn’t as big of a deal. Running the indexer on the client nodes just means when SyncThing kicks in it is shipping an updated index along with the new files to the Synology.

Anyhow, that’s the background infra stuff.

To handle the other part, capture, I turned to Drafts. It needed a little bit of Javascript to create a few variables for the output template, and it can write out to on-device storage, so it was trivial to create a Drafts action that takes this:

Some note about agriculture
fruits vegetables
I am going to write today about fruits and vegetables and how important they are to our way of life.

… and turns it into a file called 20230612T121326--some-note-about-agriculture__fruits_vegetables.org with the content

#+title:      Some note about agriculture
#+date:       [2023-06-12 Mon 12:13]
#+filetags:   :fruits:vegetables:
#+identifier: 20230612T121326

I am going to write today about fruits and vegetables and how important they are to our way of life.

… and then deposits it into the on-device storage path for Mobius Sync and ingestion into the Syncthing network.

The use case for something like this is pretty small: I’d like to be able to make Denote notes on a phone or iPad when I’m not near a laptop or desktop machine, and it was easier to automate that up front even if Denote’s naming and formatting convention is pretty simple. Following the “convention over configuration” mindset of Denote, the top level of my notes hierarchy is empty, so it becomes the de facto inbox for when I’m back in front of a “real computer” for triaging incoming notes captured while mobile – moving them into the right folders, updating metadata, etc.

The action writes to a Drafts “bookmark,” so you can use whatever storage back end you like: If you keep your Denote notes in Dropbox, Box, Google Drive or whatever, the action will prompt you the first time you use it (on Mac or iOS/iPadOS) and you can choose the right thing for you. I suppose for Git people something like Working Copy will probably also work.

Anyhow, seems to be a fine v1.

And I guess, going wide for a few seconds, another comment on what I like about Denote generally: It’s a good convention! As I was working on the search stuff over lunch, I realized that the Python script that creates the index.json file that Fuse.js has to consume was using file creation times to record the date of a given note in the index. That’d be fine if those notes were never regenerated, but they are. But whatever! The Denote naming convention embeds the date in the filename. So I just parse that to create the date entry for each file in the index.

If all my plaintext notes were saved with that naming convention for all eternity, it wouldn’t be the worst thing. If the space goat comes and eats Emacs, the convention-over-configuration approach means that if you understand regular expressions and any commodity scripting language, you can pipe your stuff through pandoc and be on your way in a new tool. It’s not much more complex a lift than, say, switching from Jekyll to Hugo. If you’re willing to use a tool you have to use lisp to configure, this isn’t a big thing.

The one “looking over my shoulder” question I have is around markup and future-proofing. There’s a case to be made for using Denote with its Markdown-and-YAML format and not its org-mode format. That would provide close to perfect portability into something like Obsidian without needing to run anything through pandoc first. There’s an argument to be made that parsing that format is easier, too, because YAML is a thing and “org mode file variables” are kind of not.

Eh. Whatevs.

I might need to write a script. Please don’t throw me in the briar patch.

A bit more on the Leica Q3 and the Fujifilm roadmap

I loaned my Leica Q2 out, which prompted some comments from the lendee, which made me think about the Q3 in clearer terms. It sounds like actual general availability will be quite delayed, and I’m in no hurry to buy new gear anyhow, but I think I’m more curious about what’s next for Fujifilm’s X100 lineup and the eventual X100 – VI? 6? Whatever it is.

I’d love to see IBIS and I’d love for it to have the X-T5’s sensor. It feels like a faster lens is probably too much to hope for: The size difference between Fujifilm’s two faster 23mm lenses — the original XF23/1.4 and the WR remake — and the lenses you find in the X100 series and the XF23/2 WR is pretty drastic. I think an f1.8 or 1.4 would bulk the X100 up considerably.

I’m also curious about whether there’s any life left in the X-Pro series. I thought the “no chimping” design of the X-Pro 3 was a gimmick, and I am not sure what the real audience even is for an optical viewfinder. I read someone recently who put the X-Pro OVF in the context of early mirrorless technology, pointing out that it helped people get around the performance problems with early EVFs. Personally, I feel an aesthetic connection with it but prefer to just shoot with the EVF. The one exception to that is when I’m out with my little Funleader fixed-focus pancake: I use the EVF now and then to spot-check exposure, but it’s fun shooting super lo-fi with a toy lens and an OVF.

It feels to me like the X100 line could be coming close to rounding out a phase: Get IBIS squeezed in there, break the f2 barrier on the lens, and what else do you do besides iterate on the sensor as it makes sense to do so, selling it as a travel/street compact all-rounder? They added WR last go-round. There’s not much left to do if it is to stay a fixed-lens kinda-rangefinder. If they killed the OVF to make room for IBIS, and bulked it up a little for a faster lense, I think I’d take that deal. It’d just be an APS-C Leica Q-series at that point.

Fright Night (2011)

We watched the 2011 Fright Night remake last night after a weekend conversation about vampire movies. I wouldn’t call it a paragon of the form, but by the time we were able to settle down for a movie it was a little late and we wanted something fizzy. I … didn’t remember Colin Farrell having so much fun the first time I saw it, which must have been in the theater or not long after its run. But he does have fun. And it left us wanting to go back to the ‘85 original, because the remake raised a few questions we couldn’t answer. It was nice of them to let Chris Sarandon turn up long enough to get eaten.

That conversation also has me wanting to do a few more pairs/trios. Like, Murnau’s Nosferatu along with Shadow of the Vampire, but also Cabinet of Dr. Caligari to get a good dose of German Expressionism.

Old man coos at cloud

Possibly lost in the Denote shuffle because I’m using them and they seem to just work:

Syncthing, NextDNS, and TailScale are really doing it for me.

There’s the occasional glitch with Syncthing, but nothing too bad and probably because I have some things writing to the sync folders a little too often. But it works really well for how I’m using it:

• Syncing org files
• Syncing the HTML output of org publishing to the Synology
• Syncing back end for Mackup (configuration syncing)
• Syncing back end for my Doom Emacs configuration
• Syncing ~/bin

I haven’t been using it quite long enough to rule on whether it’s as good as Dropbox, but it’s not nearly as needy as Dropbox, and it works great over …

TailScale. I came this close to setting up a VPN on my Synology when I remembered that I meant to look into TailScale. I went in expecting I’d bounce off something about it, and didn’t expect to be able to connect iOS/iPadOS devices to it, but it’s almost magical in its just-works-ness. I’ve got a few things on Heroku I could probably pull back to the Synology at this point.

Another bonus is that I can use my NextDNS account with it, which spares me conflicting profiles on my Apple devices and hence removes the need to keep separate ad blockers going on anything: I’m subscribed to a few filters on NextDNS and it is more than adequate.

I need to take one last pass at making sure I don’t have something syncing its config on Dropbox, and get all my Dropbox stuff out, but I think that’s one more account I can kill thanks to Syncthing and TailScale.

I’m remembering back to when my world was NFS mounts and DynDNS, and this is all so much better.

Well, after a lot of hinting and oblique mentions, it’s okay to finally say I started a new job this week, as director of IT at Iterable, thus ending about seven months of rest and a relatively easy job search.

Here’s the LinkedIn version:

I remember being 1200 feet over a Ft. Benning drop zone: My parachute risers had twisted up, my helmet had fallen off, and I was airsick. I thought to myself, “well, you brought this on yourself.”

Years and years later, I read Pema Chödrön, who said, “to be fully alive, fully human, and completely awake is to be continually thrown out of the nest.”

I finished my first day at Iterable today. I’m very happy to be starting this new role with a warm, welcoming team that includes a few familiar faces.

Reflecting on my time off after Puppet:

It is easier said than done to go still, rest, and find some quiet. I think I lost two months to assorted writing and photography projects and other busy-making stuff until someone close to me finally said, “I thought you were supposed to be resting. This doesn’t seem like resting.”

I did finally manage to go still and rest. When I decided to start looking for work again, I knew I had to sift through 10 amazing years at Puppet and figure out when I was happiest and helping the most people. Having the time to discern meant I was able to set a few things aside I would have sworn I most wanted to do as I realized I was probably just trying to replace something I’d lost. I felt more focused with each recruiter screen or interview, and my list of job alerts got shorter as I shifted from “what can I do” to “what do I want to do.”

It’s easy to euphemize: During my time out I got a lot of really unfortunate advice about covering up gaps, and trying to talk around things, so I’ll just say that yes, it sucked to get laid off — to get thrown out of the nest.

It wasn’t a world-ending shock, I was treated with respect and generosity, and it was a genuine gift to know that I could spend a few months helping my team transition once I knew I wasn’t going to continue. But it was still tough. So I’m also grateful to friends I got to spend time with over the past several months. There were a few times I felt at sea and unsure of myself, and all the coffees, lunches, and texts helped so much. I had a lot more friends on this jump than I did over that drop zone, and I’m very grateful for all of them.

There is a ton more to say about the past seven months, and it feels like the right thing to do is to think more deeply about big themes. But there are some little things to say:

First, I caught a lot of great breaks going into my time off, and saw my layoff coming far enough out that I could prepare. I spent a lot of my early career under the shadow of layoffs, with a completely different mindset. I think the person who smiled and told his layer-offer that he hoped they had an okay time with all their other layoffs last August would be completely alien to the person who wouldn’t take a weekend off for nine straight months in 2001.

There are lots of ways you can “figure out what’s next” that don’t have to involve getting laid off or quitting your job, but “figuring out what’s next” takes work. It’s probably easiest if you know and start acting on it while you have a job, but if you’re in a place where you have a ton of things to sort out and you’re just enervated from keeping the lights on wherever you are, it’s still kind of hard. I’m glad I had the resources, and hence the time, to take a break and be methodical. There was risk and some anxiety, but it got the best result.

Second, depending on how you want to manage the reckoning, this is my first new job in almost 11 years. I did so much growing during that time. There are some moments I wish I could go back to and get a do-over on, but that’s part of the whole “growth” thing … not getting things quite right the first time you encounter them.

Third, I’m glad I structured the job search the way I did. During the intense “cold call” period of February through April I had a loose routine of taking three days a week to just go through job listings and two days a week of applying for the listings I had saved the other three days of the week. Breaking it up like that gave me space to think about each listing.

I learned a practice years ago of pausing and asking if an opportunity or request elicits a “whole body yes,” — positive reactions from head, heart, and gut. I found that spending some time looking through job posts and quickly capturing the ones where my first response was “sure, I could do that,” then coming back to them a few days later to look a second time elicited a slightly different response. Sometimes it was “wow, why am I delaying the application here?” and other times it was “I don’t know why I thought that was a good idea.” The third test was the actual application — filling out whatever forms and writing a cover letter, and that was when I could tell whether my heart was really in it. If I couldn’t write a compelling cover letter — didn’t feel sincere or engaged — it was a signal from head and heart.

I started out looking at several kinds of jobs — IT, engineering, operations — and then a few categories within each. I had some good early signal from the operational roles (chief of staff and similar), extremely positive signal on IT, and really uneven signal on engineering. I was also looking at organizational size/maturity. Part of me went in thinking “man, I wish I could do a ‘Puppet in 2012, but everything I know now.’”

Going in my enthusiasm and interest was highest around chief of staff roles. Over my time at Puppet I’d been in and out of “operational leader” roles, and had to very disappointing experiences in that area. I wanted another bite at the apple. I got several interviews for that sort of thing, made it pretty far into a few processes, and came away with a few observations:

• The places where I would do the most good, that seemed the most exciting, and that were the most greenfield, were the worst conversations, and they happened early enough that my energy and patience for yet another baby CTO with a reflexive hatred for process were too low to even attempt to make a sale. Or they didn’t actually want a chief of staff — they wanted an EA/office manager.
• The places where I could be helpful and effective — the medium maturity organizations with enough introspection to know they needed help — were harder to find, and the few conversations I had there always left me uneasy. Like I was swapping the process resistance and insecurity of baby C-levels for the conditioned wariness of leadership teams that understand a chief of staff is a potential threat to the balance of power and their individual access and influence.
• There was a third tier – medium or high maturity orgs who wanted someone very senior with much more hard-core business operations experience. Just isn’t me, and I didn’t bother.

But I also had to come to grips with why I was looking at those roles to begin with, and it began to dawn on me that the things that made me a likely candidate to do that kind of thing at Puppet over the years involved a different mix of factors from what these places needed. I kept imagining doing these roles from the perspective of the person who’d been at Puppet for ten years, had a solid network, had a basis for trust with people throughout the business, and an inventory of patterns we could pick up and dust off that had the ring of familiarity for the old-timers, but could be pivoted or spruced up a little for the skeptical newcomers.

I kept saving those roles when I got job alerts for them, though, kept applying, and kept tracking why I dropped out or decided not to finish the cover letters for everything, and finally formed a thought over my morning tea and listing review one morning:

“You loved that place, loved being there, and loved even the people who drove you a little crazy. You wanted to make it better and knew how to get things unstuck. You understood what it needed on some emotional level. It’s gone.”

I quietly re-branded my LinkedIn page, turned off those job alerts, and narrowed my list to IT and engineering.

Engineering things weren’t sparking much joy at any point in the process. One opportunity came along that seemed interesting, but in a very “you’ve got a very painful-sounding definition ‘interesting’” sort of way. When you send your wife this gif to explain why you think you’d be a good fit for a job:

… you should ask a second time if that’s how you want to spend your days.

It kept coming back to which zone I’m in when I’m leading in engineering, and I never really felt like I was in my “Zone of Genius.” I’ve been around those people and know enough to understand the difference between us.

Ultimately the things that kept feeling the most right to me were the IT roles. I had a few processes go pretty far, so I had the chance to do a lot of personal writing and preparation, and I realized that the challenge I was having was less about thinking up a response, but organizing all the thoughts I had on any given part of the conversation. Over the course 30+ years in professional workplaces I held a lot of jobs in a lot of different kinds of businesses. I was never quite sure what skills would transfer in each role I held, but I knew that during my time in IT it felt I could tap the most of my experiences, and that my particular temperament worked the best.

By the time the Iterable opportunity presented itself, I felt primed and very clear.

I guess the last thing I want to say right now is that it was a pretty great couple of weeks of interviewing. I had no problem writing the customary followup note. The opportunity is at that intersection of “oh, there’s a lot to do” and “I know what I need to do.” I want to be there.

Our world of note-taking compromises

So part of Week One was having my new boss up from California for a kickoff and planning. We got a WeWork space. I didn’t do anything to get a toolchain onto my new work laptop so I didn’t have Emacs or any of my personal config stuff on it. It was a good opportunity to think about the compromises that have loomed the largest when it comes to living in the Emacs ecosystem but having the occasional mobile use case:

• Decent clients to read org-mode files.
• Reliable sync.
• Capture on the go.

After a few days in a WeWork, seeing what would have been useful and how I was working by just putting stuff in native tools then moving them over, I realized I’d be happiest working with these assumptions:

• Stick with Emacs/org-mode/Denote. They feel the best for just doing work on a laptop or desktop, and that’s where I do most of my work.
• Give up on any of the mobile options for managing org-mode. They’re dancing bears. It’s great that they can dance, and it feels uncharitable to complain that they don’t dance well, but they’re hindered by a lack of native sync. The best they can do is capture simple things and relate simple things. Put more weight on them and they’ll frustrate me.
• Make static notes available in a way that’s easily readable by native tools and put extra effort into making sure that when the static notes are pushed out, they’re truly pushed out.

On that last point, the biggest pain point I’ve come across using Denote/Emacs has been getting at stuff for reference when I’m not near a real computer. One way tools like Obsidian and Things run rings around Emacs is in their native, bespoke, purpose-built sync capabilities. Capture is no big deal.

Yesterday I spent some time sussing out how org-publish works and:

• Got my notes set up to publish using SimpleCSS.
• Connected the output directory to my Synology via SyncThing.
• Set up the Synology’s web server (it’s just nginx).
• I can connect to the saved notes via Tailscale, which is running on all my devices (and using NextDNS, which is sweet, since I was able to take out a whole layer of browser-based ad-blockers).
• Set up an after-save-hook to kick off a publish whenever I save a file in the notes directory.
• Set up a pre-save hook to update any Denote org-babel d-blocks, because I make meta note pages with those.

I put SyncThing on an aggressive update schedule to make sure the HTML versions of notes will get pushed out after saves.

Today I started figuring out how to add search to my exported notes. FuseJs seems to be working fine for that. I made a script that can walk the exported HTML notes and get them into a JSON index, and I added some HTML/JS to an index.org file in my notes directory. Here’s a quick demo of a few searches on mobile:

For now the notes indexing script is just running from the Synology’s Task Scheduler.

So, net:

• When I write or edit a note in Denote, save-hooks publish all my notes as HTML.
• SyncThing makes sure the HTML is pushed over to my Synology.
• The Synology periodically indexes the HTML for search.
• nginx running on the Synology serves the notes.
• Everything is happening over Tailscale.

There’s a very fair question, which is “why on Earth do all this when Obsidian, Logseq, or a few other mobile-capable PKMs are sitting right there?”

I guess the answer is, “I don’t like them as much.”

I mean, they’re fine and all — I would use Obsidian if there were no Emacs — but if I line up what they excel at with what Emacs/org-mode/Denote excel at, and ask myself “how do I most often use these tools,” the mobile access use case is relatively rare and mainly amounts to a question of access and very simple capture. I just want to know that if I save a piece of information on a laptop or desktop, it’ll be there for review on a tablet or phone not long after.

For a few hours of work configuring some off-the-shelf tools and a little bit of fine-tuning of the underlying sync engine, all my notes are securely available to me with super-fast search, and I can author them in a decent environment to begin with, not some Electron-based Markdown editor

I’m happy to share what I came up with but avoided my customary “here’s a few snippets.” The stuff I have going right now feels alpha. It’s working, but it’s in that realm of “I just got ping.” The HTML output needs some polishing, I’m not sure the search stuff is configured as well as it could, and it remains to be seen how it all works as I just get on with my day. I did as much as I could over a few sessions on the weekend so I could just get back to work tomorrow without any lingering “just one more thing” desire to fiddle.

I want to have access to my Denote notes via SyncThing on a machine I don’t completely control (but is not, to be clear, operating in a hostile environment) and I want them to be encrypted, same as my org-journal files. I should probably just ask Prot, but as near as I can tell the clean way to encrypt notes in Denote is to add an “org.gpg” type to denote-file-types, like this:

(add-to-list 'denote-file-types
             '(org-gpg
               :extension ".org.gpg"
               :date-function denote-date-org-timestamp
               :front-matter denote-org-front-matter
               :title-key-regexp "^#\\+title\\s-*:"
               :title-value-function identity
               :title-value-reverse-function denote-trim-whitespace
               :keywords-key-regexp "^#\\+filetags\\s-*:"
               :keywords-value-function denote-format-keywords-for-org-front-matter
               :keywords-value-reverse-function denote-extract-keywords-from-front-matter
               :link denote-org-link-format
               :link-in-context-regexp denote-org-link-in-context-regexp))

It looks like a lot to do a little, but it’s just a clone of the org type that’s already in that list, with the extension changed. I suppose one could just alter the org type, but then you don’t have an unencrypted type if you want it.

With that in place, you can do:

(setq denote-file-type 'org-gpg)

… and anything you create with the denote command uses that type, with the correct extension. Given the right general config:

(require 'epa-file)
(epa-file-enable)
(setq org-crypt-key "foo@bar.baz")

… it all “just works,” with decryption handled transparently provided the gpg agent is set up correctly, and I preserve the option to have unencrypted notes for whatever reason I might want them at some point.

To get my existing notes into an encrypted state, I used this script:

#!/bin/zsh

encrypt_file() {
  local file_path="$1"
  local recipient="$2"
  local encrypted_file_path="${file_path}.gpg"

  gpg --encrypt --recipient "$recipient" --output "$encrypted_file_path" "$file_path"

  echo "File encrypted: $encrypted_file_path"
}

encrypt_files_in_directory() {
  local directory="$1"
  local recipient="$2"

  for file_path in "$directory"/*.org; do
    encrypt_file "$file_path" "$recipient"
  done
}

# Usage: ./encrypt_files.sh directory recipient_email
directory="$1"
recipient_email="$2"

if [[ -n "$directory" && -n "$recipient_email" ]]; then
  encrypt_files_in_directory "$directory" "$recipient_email"
else
  echo "Usage: ./encrypt_files.sh directory recipient_email"
fi

The mobile problem

The tradeoff with that approach is that your mobile use case gets harder. I can still do something like mosh my way in to the Mac Studio with Tailscale, I guess.

I have the nagging feeling that Emacs-centric note taking wouldn’t work great for me if I were dealing with a commute or other scenarios where mobile access is more important. Yes, there are beorg, Plainorg, and a few other options, but the syncing layer is the complicator. Some people seem to live fine just using git and maybe git-auto-commit, or just generally being more disciplined about their file use. I have generally felt better served by bespoke solutions, like you get with Obsidian, Things, and others. They’re still subject to the occasional screwup, but I don’t feel like I see them as often as I do with things that simply watch a file system and try to react appropriately.

I have been doing a little personal journaling about my preoccupations with mobile stuff. After tracing things back over the years, I recently realized that a lot of my fixation on getting stuff to work on a phone came from a pretty terrible time during the 2001 downturn.

All my teammates had been laid off and I was holding down a small network of Linux/open source sites that had previously involved a much larger team. If I didn’t want things to get out of control I had to keep an eye on them over the weekend. That mentality caused a lot of lines to blur and it took years to unblur them. I was an early iPad enthusiast because I’d internalized the idea that I should be able to do all kinds of work from anywhere at any time. Before that, I was really into the netbook thing because I could put an eeePC into a hip bag.

By the time I got to Puppet in 2012, working from home wasn’t a novelty or an aspirational goal: I’d been doing it for 13 or 14 years and was really glad to have an office to go to. Covid lockdown sparked a pretty bad reaction after the initial “let’s build a fire and sing songs while we wait for the drop ship” phase because lines started blurring again.

At the same time, just last week I had a pair of things to do in the afternoon and I’d written some thoughts down about one of the events that I wanted to review while I was out of the house. Well … apparently SyncThing hadn’t picked up on the changes before the machine I wrote them on went to sleep, so none of the other machines in the mesh — including a Synology I put SyncThing on for just these occasions — knew the notes existed.

At some point, “oh, no problem, I’ll just Tailscale in to the home network and WoL the Mac Studio so I can wake up SyncThing and then sync my changes down” loses all its charm.

Ugh. Need to stop before I talk myself into doing something rash and disruptive.

Hugo previews while working in ox-hugo

I’m not sure if there’s a better way to do this, but this is working for me:

(defun mph/start-hugo-server ()
  "Run Hugo server with live reloading and open the server URL in a browser."
  (interactive)
  (let* ((root (projectile-project-root))
         (default-directory root))
    (compile "hugo server -D --navigateToChanged" t)
    (run-at-time "3 sec" nil (lambda ()
                              (browse-url "http://localhost:1313")))))

(defun mph/stop-hugo-server ()
  "Stop Hugo server."
  (interactive)
    (kill-compilation))

(map! :leader
      (:prefix ("H" . "Hugo")
       :desc "Start Hugo Server" "S" #'mph/start-hugo-server
       :desc "Stop Hugo Server" "s" #'mph/stop-hugo-server))

I get a little Compiling treatment in the modeline while the preview server is running. My browser reloads any time I save my work.

What happened to V

I always sort of wondered what happened to V between the miniseries and the regular series. I had a vague sense it had gotten worse, but I was also a teenager and didn’t have a lot of critical faculties beyond “this seems sort of sucky and boring now.” Well, now I know: They got rid of the person who created it, made it cheaper, and tossed out what someone thought were the dumb parts, which were actually the good parts.

Interesting factoid:

V was watched in more than 33 million homes, which amounted to 40 percent of all TV viewership. (The most popular series in America today, Yellowstone, averages 13.1 million viewers per episode.)

I recently tried to dig up what’s considered “good numbers” in the streaming era and didn’t get many satisfying answers. Seeing that a modern phenomenon like Yellowstone pulls about 40 percent of V’s numbers is helpful. V was hyped all to hell at the time, so its “television special event” status probably skews things a little. (The M*A*S*H finale did 105.97 million total viewers, and that record may be impossible to break as streaming-driven atomization deepens.)

“The Phony Solidarity of the American Pundit Class”

I got to this post in The Nation after it sat on the read later pile for a while.

It’s very strange to see the post-2016 realignments continuing apace. This particular link targets the slice of the center-left-to-center-right commentariat that has learned to talk about “working people.” That tic — the “won’t somebody think of the working people” tic — feels symptomatic of a kind of elite capture all its own.

I wrote a few years ago:

“I have a lot of time for some heterodox thinkers. I wish ‘heterodox’ was narrow-able to something less broad than ‘a coalition of middle class trolls, rebadged culture warriors, people who hate how much they get ratioed, and well-meaning independent thinkers.’”

I think I may need to retract that. I was going through the podcast searching for an episode and saw a few descriptions here and there that tell me “heterodox” has stopped being a word one lands on after casting about for a better one, and has become a sort of branding exercise.

I started beta testing Mimestream last year because “mail client.” It flipped to v1 recently and is having one of those Mac Commentariat moments.

My initial take was “oh, another Mailplane,” but that’s not right. It’s not a browser app. It’s a real app, and it does some helpful things if you’re a Gmail user, like making filters more accessible. Because it is using the Gmail API and not IMAP it also feels super quick and responsive.

I still don’t completely understand the effusive enthusiasm for it: No plaintext options, no local URL scheme or scripting interface, and for whatever reason the URLs you can get out of it point back to the Gmail web app instead of Mimestream. (I think that’s set to change.)

On plaintext: I prefer to start with the plaintext version of any message, and I prefer to send in plaintext. If I feel the need to flip into rich/HTML mail mode I will, and I don’t mind having to hit a key to get the HTML version of a mail if it means getting to start with the more calming plaintext alternative.

On the local URL scheme: I don’t like living out of my inbox, and I don’t like making tasks out of mails that don’t include a link back to the message. When I turn an email into an action, I want a link back to the message, I don’t want to copy the entire mail into my todo system.

On the scripting interface: It looks like there’s a single Shortcuts action available right now, which is promising in its own way. Where there’s one there could some day be more. Most days I’d rather have an AppleScript dictionary, but I get that Shortcuts are sort of the populist middle way between AppleScript and Automator.

In any event, until the app has more ways to talk to the rest of my apps, I’m a gentle no. I have the sense that the team behind it has correctly identified that email clients have a lot of baggage that needs to be left behind, but it’s a little too spare for my tastes. I don’t think “step up from the native Gmail interface” is what I am after.

Since discovering MailMate and figuring out how to work it into plaintext workflows, I’ve been enjoying its whole “GUI mutt for the 21st century” vibe.

“Quit picking at it”

This morning I was working on the bit about Mimestream and did a quick save of my blog.org file. I’m used to seeing the name of the Markdown version of the post flash by in the minibuffer as org-hugo exports the org markup to the posts directory. Huh. So I made a quick change to dirty the buffer and saved again. Still nothing.

Huh … huh. Oh … I did refactor my config.org file! Maybe … no. That wasn’t it.

Well … maybe … no, restarting didn’t help.

Around and around for, I dunno, 5-7 minutes before breaking down and Googling and realizing that at some point I’d tidied away this business at the bottom of my blog file:

* COMMENT Local Variables :ARCHIVE:
# Local Variables:
# eval: (org-hugo-auto-export-mode -1)
# End:

Just … the thing that puts the buffer in auto-export mode and I’d fiddled with it and it broke.

And a few days ago I decided to play around with spell-checking engines. Why? I don’t know. Somebody said one was better. It also tripled the amount of time it took to open files. Why? I don’t know. I didn’t even bother searching to figure out if that was true, because I just intuited what was going on by where the minibuffer was hanging when I opened a file, undid the change, and with the minor exception of losing some custom words got on with my newly re-accelerated file opening life.

I think this might be the most built up I’ve ever had Emacs, but I’m also doing much less with it that isn’t just writing, coding, or managing todos. Brief experiments with mail, RSS, and Mastodon all went by the wayside pretty quickly, so maybe it makes sense that I’m fiddling with the core functionality more.

I think I’m also ready to just start working again. Like, the knife is plenty sharp. I’ve settled into some core day-to-day tools that have been just great for doing the things I do to provide structure for myself during this period. I felt a little like a dog endlessly circling before lying down on the question of how to best take notes before taking a cue from something I figured out as I was working on my plaintext CRM, which was “work out the convention, then scaffold it into the capture process such that you don’t ever think about the convention again, but know it will be there for you.” Note-taking being a current site of influencer struggle, it took parallel work in a different kind of workflow to get me to hear through the noise and pick out the analogies between worfklows.

But having gone through that process — having circled seemingly endlessly — when I sit with how I feel about all the fiddling and goofing around, I realize the last time I felt like this I was a tech journalist getting paid a decent amount of money to goof off with Linux. It’s probably why I’m so impatient with tech influencers and tech bloggers today:

You read a review for a camera or tool and the use cases feel like they’re all “how does this work for someone whose job it is to review things,” vs. “how does this work for someone who has to do other things.” The obsessive quest to prove that iPads could be “serious computers,” for instance — with the benchmark for “seriousness” being “I can automate the process of making screenshots that document how to automate making screenshots so I can blog about the iPad’s fundamental seriousness” — felt like a “content person’s” obsession. That’s not to say that tech journalists, bloggers, and influencers don’t have work to do … it’s just that they necessarily have a conception of “usefulness” that is derived from what they have to do all day, which is not what most people who have to use computers to get work done have to do all day. Most people do not need to know how to make screenshots at scale. The fact that your niche blog about Mac automation is heavily dependent on scaled automation of screenshot production and is very successful does not make scaled screenshot production any more imperative for the rest of us.

But even still I sort of get it.

For a certain kind of person (me among them), there is something mesmerizing about the kind of hyper-competence good automation or tech mastery suggests. It’s like watching a magic trick, or a longboard dancer, or a woodworking show. One of my favorite sysadmins was incredibly fun to watch at work: all the tmux panes on full-screened terminals on dual monitors, hand never straying to the mouse, sitting cross-legged on his tall chair in front of his elevated desk. It was like watching a levitating octopus in a hoodie running a nuclear power plant.

The past several months, bereft of much to do but the dull and repetitive administrivia demanded by recruitment automation, punctuated by hurry-up-and-wait interview processes, it was sort of fun to sit and watch tech magic tricks and obsess on the relative efficiency of assorted modes of interaction with computers.

But now, knowing that this period is finally winding down, I’m trying to think about what it’s like when I’m just trying to use a computer to get things done when I’m not being very pointed about just goofing off and resting. Like, “oh, it’s time to join a meeting, and I just restarted Emacs but it’s bombing because when I added the config change that worked perfectly fine live, I dropped a paren,” or “oh, I forget to make sure that all the config for that package I decided not to use is untangled.” With enough picking, your carefully curated, meticulously optimized trusted system stops being trustworthy. It just becomes this thing that breaks when you really need it to just work, but thanks to all the picking and fiddling it isn’t just working, so you end up punting and using Apple Notes. Or if you’re me and are still living out patterns established when you were a for-real journalist in the time before there were laptops, you grab a reporter’s notebook out of the box of them you keep on hand and start scribbling.

It’s a little interesting to me that as I began to feel that mounting sense of unease about all the picking and fiddling and “what did I just change that is making this previously reliable thing break” and began to pare things down, archive experimental chunks of my config, and just generally sit on my hands until the urge to monkey around passed, I started grabbing my camera on the way out the door again, after a long period of not doing that much.

Huh. Maybe there’s somewhere non-self-defeating my creative energy can go.

Like, all the Emacs themes that have been around for as long as Emacs has had themes – since Emacs 20? They have sort of odd names, and you get this sense that a lot of them predate the sort of web-driven popularization of color science. Like, someone thought it’d be cool to make a theme where everything is just a shade of blue, and call it “Dreams of Blue,” or “poindexter-blue” or what have you. There’s also some primitivism or nostalgia. The ones that are meant to remind you of amber monochrome monitors. Or WordPerfect 5.

They predate stuff that to my mind is sort of modern and seems scientific – Solarized and Dracula jump to mind, and catppuccin is big lately. Or the things that have come out of the UX departments at big tech companies, like all the variants on Material. You know where Material is coming from, because Google probably issued a press release about it to draw attention away from its latest EU privacy violation settlement.

Anyhow, there are a bunch of them and I’ve been seeing them around forever, and sometimes they do things that strike me as perhaps quaint. Like, they use a shade I’ve come to think of as “commit pink” or “commit green,” dowdy shades that predate modern sensibilities … that perhaps don’t have the whiff of scientific soundness. Tones and choices that do a little more to introduce a sense of structure than is currently popular.

At the same time, there’s this unmistakable aura of authority just because they’ve been around forever. Or at least I feel like I’ve been scrolling past them forever. And core to Unix culture is that crushing deference to the patriarchs. The same thing you feel when you learn about man pages for the first time and it begins to occur to you that it took a lot of people a very, very long time to write that much documentation. The fact that so much of it is written in a sort of assumptive, referential style just adds to the sense you’re reading the day journals of an obscure contemplative order.

Which brings me to Leuven, which I read about because someone on reddit asked for a good starting point for themeing org-mode, but which I feel like I have been seeing around forever.

Ordinarily, not my thing:

• It’s a light theme. I thought I was all in on dark ones.
• It’s sort of contrasty. I thought I wanted low contrast ones.
• Not exactly a contemporary palette. I’m not sure how to describe the modern emphasis on things that are both vibrant and low contrast – or maybe I just did by typing that. Leuven doesn’t do that.
• It draws lines and boxes around things, in a way that feels sort of like when someone writes a console app that has an ASCII GUI. It uses background colors for headings and spelling errors.

But all of that adds up to something that makes some kind of sense to me.

Like, a lot of modern themes go to words like “soothing,” posing that contra things like “strain,” or “fatigue.”

Okay, fair. I definitely agree that there are color schemes out there that cause strain and fatigue thanks to bad color choices, bad typography, etc.

But you know, another thing that causes fatigue and strain is trying to discern structure in a document using a palette designed to eliminate contrast. Turns out a few stark lines here and there do an admirable job of guiding the eye, aiding quantification, providing boundaries, creating a sense of anchors and space.

Now, to be fair, one problem the lo-contrast themers face is probably that they aren’t in complete control of white space and typography, which can do a lot to put that sense of structure back in place. Or they’re just neglecting to do it because someone picked some tones that are appropriately uwu, done some color science, and called it a day thinking their work is done.

After trying Leuven for a day, I found myself feeling a little more situationally aware and much less washed out. When its whole “black text on white background” thing got a little much, I used the brightness buttons to dial it down and was happy that its essential contrastiness still worked. Worked even better, in fact, because less detail got lost with the dimness.

It kind of reminds me of when I screwed something up with the lighting in my office. I had a bunch of Hues and tried out some sort of automation but they got quietly stuck in a very amber-toned place on the spectrum. So for weeks my office was “well lit,” but with a permanent orange-ish sundown tint. I couldn’t figure out why it just felt soporific to go in there, or why it felt like effort to carry on a conversation.

Then one day Ben tried out some disco light app without bothering to make sure he was only targeting the lights in his room. After a few perplexed seconds of figuring out what had happened (it wasn’t that hard – we shared a wall and the lights started going bananas just after he started blasting a Sophie album) I got into the Home app and reset all the lights to the tone I’d set as “normal” years ago, and immediately felt the difference.

So, Leuven. Seems to have been around forever. I thought it was going to be a bit much, but actually find it to be … bracing. Energizing.

Screenshots and instrux.

In a similar vein, Prot’s modus-vivendi and modus-operandi themes.

Via Jack Baty, here’s Om Malik on “What’s Wrong with Leica Q3,” which, okay: “introducing the flippy-tilty screen takes away from Leica’s uniqueness. The company has been able to charge more for offering less.” Citing their monochrome cameras as an example of that is … a take.

Tilting screens add to the versatility of the device. That’s all. They make certain situations easier to manage, especially with the kinds of things you want to shoot macro, and they give you more flexibility in street shooting situations where you don’t want to have a camera up to your face.

A camera like a Q3, I’d argue, should be making some concessions on design austerity, because the machines themselves exist for the times you can’t take everything with you that you wish you could, so you’re compromising and taking just one thing.

Now, he goes on to point to the Verge review, where it sounds like the implementation is lacking:

“… the worst part of the screen, aside from it looking like it’s just been grafted on and makes the camera appear and feel bulkier, is that there’s no groove or grip on its left side to dig your nail into or grab with your finger. It has grooves on its top and bottom, meaning you have to make a much bigger reach to move it.”

That doesn’t sound great. I do like the way the Fuji X100V and X-T5 are built. It’s a simpler, easier motion, sort of planting your thumb and kind of twisting each hand to get the screen undogged and moving. I don’t like anything I need to pry open.

Om’s concern that the Q3 “design disaster” is going to infect other Leica product lines didn’t ring great with me because I don’t like the button layout on the Q2 as well as I like it on an X100, or X-T. The Q3 looks more like a Fujifilm camera in that regard this time around (well, now the Leica people are really gonna hate it). Yeah, you have an extra target to distinguish when the camera is up to your face, but you figure it out.

I’ll also admit that when it comes to a Q-series camera – $6k just to get in the door, then close to another $1k to get it fully provisioned – it’s a little harder to smile and say “well, they’ll get it right in the next rev.” I did that with three generations of Fujfilm X100s, but they hold their value about as well as a Leica (I checked a few generations and used street prices for my last post on the Q3) so that’s less of a sting.

Anyhow, I welcome the addition even if it sounds like it’s imperfect.

Every time I’ve tried to compare the Q-series to the X100-series, I walk away with a sense that the X100s are inferior on every spec (except the hybrid viewfinder), but manage to stay in the ring because they’re scrappier and looser cameras.

The thing that blunts my joy about the Q-series is pretty similar to what makes me unhappy about very early Apple products and tools: There’s a bias toward the austere that sometimes stifles. It was an easy matter for me, for instance, to perambulate between OS X and Linux for a period, because Apple was doing the “slow layering” thing and the customization ecosystem hadn’t caught up yet. Once people figured out how to leverage the BSD userland and third party people began to figure out the new APIs, we were off and running.

Even a not-perfectly-realized tilt screen, and a reconfiguration of the control scheme to introduce more flexibility and easier one-thumb use while shooting, feels less to me like Violation of Holiest Ascetic Precepts and more like an opening up and loosening appropriate to a camera that manages to be both shockingly expensive and be the thing you shrug and grab when you can’t take everything you’d like, or make up your mind about what you need.

Succession ended with integrity

Spoiler culture is out of control, but … spoiler.

I wrote that Succession was a tragicomedy and therefore needed to end a particular way to keep its integrity. It ended about the way I felt it should have, and even smeared a little spit on the rims of select audience brandy snifters with its elevation of the closest thing to a lens character had to a kind of hollow power that nonetheless commands deference from people newly laid low.

Tom Wambsgans disgusted you all along? You felt a warm glow when Shiv perforated him with as a grasping climber? Reminded you of that one VP you worked for who never fooled you but somehow fooled everybody else? Well, he’s here to put a sticker on your forehead, and he doesn’t need you to mean it when you hold his hand.

Who will win? The cockroach won. But it isn’t even winning.

A reviewer referred to Roman’s final little smile as “twisted.” I think he was the only one of the three who knew enough to feel liberated. The other three siblings were clowns masquerading as serious people. Roman was the clown who knew better than any of it. He drives Kendall to rip of his own mask, then quietly declares them all shit. His comedic aspect is reunion with himself. His tragic aspect is the relationship he lost one of the few times he tried to play things straight.

With a good ending, it joins The Wire, Breaking Bad, Mad Men, Justified, Halt and Catch Fire, Six Feet Under, and The Sopranos in the “stuck the landing” club.

Denote just makes sense to my brain

Well, after a few days of fiddling and trying this and that, I think I’m all in on Denote:

• No external dependencies
• Convention-based naming
• Portable
• Simple

… and an ecosystem is forming around it that respects its conventions but smooths out its UI. So if you want to just manage Denote via dired, you’re welcome to do that. The fontification of Denote directories is enough to make the titles and tags clear when you’re looking at a simple directory listing.

But there are also packages like denote-menu and consult-notes that provide light wrappers and convenience functions if you’d like a cleaner view, where, for instance, the title, keywords, and date are all displayed in their own columns; and there are features that help quickly filter down your view based on keyword, etc.

I sort of want to compare it to what I admire about Markdown: Fine on its own, able to support more, probably you could go a little nuts trying to do more with it. I appreciate that it participates in the broader org ecosystem, and equally admire that you’re welcome to use Markdown/YAML if that suits you.

This is occurring to me because I spent a bunch of time fiddling around with a few Denote wrappers over the weekend and ended up in that weird “why did I do this” state of mind where all the single-minded optimizing and tweaking felt sort of like a high-carb meal. Then I just opened up my notes directory in dired and realized Denote is great at its most basic.

If you use zsh, this will give you a colorized ls for a Denote directory, btw:

dls() {
    ls -1 | GREP_COLORS='mt=1;32' egrep --color=always '[0-9]{8}T[0-9]{6}' | GREP_COLORS='mt=1;34' egrep --color=always '__.*$'
}

keycast

While I was watching Prot’s Denote demo video I noticed his keystrokes and commands were echoed to the modeline, which seemed pretty cool, and was also helpful to me trying to figure out what on Earth he was doing. Then it occurred to me this afternoon that one thing I’ve been struggling with as I try to untangle what’s going on in Doom with some of the stuff I’ve wanted to fix, has been what’s going on in Doom when I use certain commands.

Like … previewing a file under point, which you invoke with CTRL SPC.

The sort of low-rent debug method I’ve observed is that people just ripgrep their ~/.emacs/ for any mention of C-SPC to see what’s bound to that.

Well, joke was on me:

Maybe it was ivy-call-and-recenter, maybe company-complete-common, prolly not org-agenda-show-and-scroll-up. PROBABLY +vertico/embark-preview, but who can say in these troubled times?

So I went looking for whatever it is Prot was using, and found something called keycast.

Its obvious utility is for screencasting, but it also has keycast-log-mode, which sends all your commands to a buffer, and which helped me establish it was, indeed, +vertico/embark-preview.

To get it to work in Doom Emacs you need to add something to your config:

(use-package keycast
  :config
  (define-minor-mode keycast-mode
    "Show current command and its key binding in the mode line (fix for use with doom-mode-line)."
    :global t
    (if keycast-mode
        (add-hook 'pre-command-hook 'keycast--update t)
      (remove-hook 'pre-command-hook 'keycast--update)))
  (add-to-list 'global-mode-string '("" keycast-mode-line)))

There are a bunch of issues mentioning problems with Doom and Spacemacs all over the place, but this is what worked for me, here in late May, 2023.

DPReview’s initial review of the Leica Q3 says:

• Tilt screen
• Actual ports (USB-C, micro-HDMI)
• Bigger sensor
• Some rearranged buttons
• Option for wireless charging
• Hybrid AF
• $5995

They stuck with the previous 28mm lens and are standing by digital crop if you want to get to tighter focal lengths. I’d still prefer a native 35mm, but you’d lose a little “take anywhere” versatility.

Anyhow:

The tilt screen is very welcome, and will make the lens’s macro mode more useful/practical.

The rearranged buttons caught my eye, because the Q2’s arrangement felt pretty unergonomic, and it was easy to accidentally press them with your face when shooting in portrait orientation. DPReview says it helps:

In addition to the new tilting touch panel, the buttons for ‘Menu’ and ‘Play’ and a custom function button have been moved, now appearing on the right to join the four-way controller. Having used both cameras, within a few hours of shooting the new one I found the layout to be a marked improvement that let me reach all the buttons with just my right thumb while the left hand stayed on the lens ready for the next shot. It’s a much faster and less cumbersome arrangement that let me get in and out of menus quicker.

Having a USB-C port is welcome. The wireless charging part sounds like a nice-to-have that makes it a little nicer to just keep near the door.

All in all, sounds like a nice step forward for the Q series, and with the tilt screen it sort of does become the $5995 Fujifilm X100V you always wished would happen, with its 35mm digital crop still outresolving the X100V by a few megapixels.

Speaking of the X100V, I did compare it with the Q2 a few years ago:

I don’t think the Q2 is four times the camera an X100V is, and I can’t think of anyone I’d be in the position of recommending a camera to for whom I’d recommend it as the better choice: Dollar for dollar, the X100V is a much better camera for almost everybody interested in a premium compact camera. At the same time, now that I own the Q2 and have not returned it or sold it in a fit of guilt, I wouldn’t easily part with it: I love shooting with it, love what I get out of it, and expect to keep it for a long time. The only reason it is not my only camera comes down to its fixed, very wide lens, which makes portraits and some outdoor photography a relative challenge.

One thing that changed a lot for me since writing that up was the arrival of IBIS in the Fujifilm ILC lineup. It wasn’t something I weighted as heavily then, but definitely started weighting more heavily as I learned how much it expanded my horizons. With the changes showing up in the Q3, I’ll just say that the gap between the X100 series and the Q series has narrowed. There’s still 4,200 actual dollars of daylight between the two to account for, but the Q3 is a more flexible camera than its predecessor.

So:

• A bit shy of 2x the resolution, uncropped sensor
• Faster, more versatile lens
• Image stabilization

I’m not sure how to go about doing a parts list that would account for the differences and leave me with some objective calculation of the brand tax you’re paying, but it’s easy to imagine an X100 Pro series because we have that in the form of an X-Pro3 with the 23mm/f2 Fujicron, and MSRP on that rig is around $2,300. So, following this reasoning, we’ve got about $3,300 to account for. You’re still a stop shy on the lens and don’t have a macro mode, you’re still trading away depth of field and resolution thanks to the sensor difference, you still don’t have image stabilization.

Okay … so maybe we stick the newer Fujiflm XF23mm/f1.4WR on our theoretical X100 Pro. That’s $500 over the 23/f2. We’re down to $2,800 difference. We’re still contending with the sensor difference and IBIS. Tough to call.

On IBIS, the Fujifilm X-T4 was an incremental change over the X-T3, and it came in at $200 more MSRP, with IBIS being one of the larger differentiators. The X-T5 introduced a much larger (but still APS-C) sensor, but kept the MSRP. So … we’re down to $2,600 difference, and still have to account for the sensor, which sort of throws the math on the lens, too. I’m not sure how to square that. Call it $500.

So, we’ve found about $1,300 in component differences (IBIS, lens, sensor)? Leaving us with around $3000 to account for.

I am assuming the red dot involves pigments mixed from the blood of unicorns.

I kid.

Silos and Denote

Last night I was finishing up some note cleanup in Denote and realized that a lot of the stuff I’d atomized from my job search was sort of interesting and useful, but not in a day-to-day way. And that I wanted to have some way to segregate, eventually, “work” from “personal.”

Denote has a siloing feature that lets you keep separate directories of Denote notes that can’t see each other. If you operate in one of those directories, all your Denote activities (creating a new note, etc.) treat that directory as home. Outside the context of any particular directory, your default Denote directory is home. There are a few other features related to suggested keywords in those silos, but for now it’s enough to be able to make broad distinctions.

There’s also a useful function for pre-selecting a silo then running a Denote command targeted at it, so you can be out and about elsewhere in the filesystem and dispatch information to different silos as needed.

For now I’m siloing by default/personal and “career,” which is what I am calling all the interview notes, work-oriented biographical stuff and generic management writing I’ve had to do. I’ll probably put my job search log, interview notes, and other stuff that’s currently all in a monolith into that directory as well, for long-term storage. And eventually there will be a “work” silo for day-to-day work stuff.

I vacillated about the segregation of big-picture career-related writing from day-to-day work writing, but realized most of that career stuff is a prompt. Interesting to read through, and good grist for first-30-day planning and thinking, but not pertinent to the day-to-day. If I end up feeling like some part of it is, I’ll just pull it into a metanote as a link.

I guess the other Denote thing of, er, note, was that Prot’s whole “this is also a good way to just learn Emacs” direction with Denote got a workout tonight. I watched his demo video, where he marked a selection of files by regexp in dired, then made the unmarked ones disappear from view in the directory. It took three or four scrub-throughs to catch which commands he was using to make that happen, because he was just doing it the way you do when something is deep in your muscle memory. But eventually I caught it all – %m to mark by regexp, t to invert the selection, then k to “kill” the lines (but not kill kill them, just hide them). It sounds like a lot, but most of my Doom menus are two or three keystrokes deep. Once I had it, it was a lot easier to narrow and triage my collection and get everything dispatched into a silo.

Update on that …

One thing I didn’t like so much about that “just use the native commands” approach was that in Doom, you’ve got to switch in and out of evil mode to use all of dired’s keystrokes. I ended up grabbing dired-narrow, which dynamically narrows a dired buffer, and then recorded a quick macro to restore the buffer view (using the native dired command, which would need a shift out of evil mode):

(defun mph/dired-unnarrow ()
  (interactive)
  (evil-emacs-state)
  (execute-kbd-macro (kbd "g C-z")))

Then I added dired-narrow and my new macro to my Denote menu structure:

(map! :leader
      :nv "n d" nil ;; Doom has deft here, so we have to nil it out first
      (:prefix-map ("n" . "notes")
      (:prefix ("d" . "Denote")
         :desc "ripgrep" "/" #'mph/denote-rg-search
         :desc "Backlinks" "b" #'denote-link-backlinks
         :desc "Move subtree" "c" #'mph/denote-org-copy-subtree
         :desc "add keywords" "k" #'denote-keywords-add
         :desc "remove keywords" "K" #'denote-keywords-remove
         :desc "Move subtree" "m" #'mph/denote-org-move-subtree
         :desc "New note" "d" #'denote
         :desc "Rename with frontmatter" "r" #'denote-rename-file-using-front-matter
         :desc "Pick silo, then command" "s" #'mph/denote-pick-silo-then-command
         :desc "Narrow dired view" "n" #'dired-narrow
         :desc "Unnarrow dired view" "u" #'mph/dired-unnarrow
         )))

Technically I guess those narrow/unnarrow commands belong in some other hierarchy, but I will tend to use them when I’m doing stuff with Denote, and they can live in more than one context if I wish.

I have the sense there are other things I could be using, like Embark, but I am still struggling with the whole Vertico ecosystem, so one thing at a time.

Update to the update

With Vertico/Embark on Doom, I don’t need dired narrow to get what I was after:

• SPC . to start finding files
• Once things are narrowed, C-c ; moves all the candidates into their own buffer
• Do stuff
• q to quit the transient buffer

I like keeping my Doom Emacs config file in config.org. I didn’t like the #RESULTS drawers cluttering up the file, especially for longer functions with copious output.

The way to selectively disable that for a given src block is to append :results output silent to the block opener, e.g.

#+begin_src emacs-lisp :results output silent
(vertico-reverse-mode)
(setq vertico-count 10)
(setq vertico-resize t)
#+end_src

The way to do it for an entire file is to put #+property: header-args :results silent at the top.

You can still evaluate a given src block by tapping return on either the first or #+end_src lines, but the output goes to the minibuffer instead of a #RESULTS drawer. If you need to really read through the output, there’s always the *Messages* buffer, or tacking :results output replace onto the src block opener to get your #RESULTS drawer back.

JOHS and the city

The city and the county are again considering extending the JOHS for just a year. I still don’t understand the division of labor there. It’s the worst of both worlds: The city drops a pallet of money on the county’s dock, but remains on the hook for the tactical response. The county takes the money, claims the high ground of long-term, strategic perspective, then has an effective veto over elements of the city’s tactical response even as it fails to allocate half its budget, and actual providers on the ground struggle to retain help with a living wage, or even get decent contracts through the JOHS.

If the JOHS were a joint office, performing some actual coordinative role, maybe it’d be different. But it’s a county office: Its reporting structure roles up to the chair, it uses county administrative structures and processes, and it is beholden to county leadership. It’s also profoundly dysfunctional, leaving millions and millions of dollars on the table, and failing in its most basic data-gathering, reporting, and contracting commitments.

But we’re in one of those situations where the dysfunction seems to be politically expedient. The city and county are at fundamental odds on homelessness policy, and the people in this policy area at the county level view themselves as a sort of superego governing the city’s id. Once one partner in a relationship predicates their participation on the notion that they’re mostly there to keep their partner from doing something they don’t like, the relationship is sunk. Burn it down and start over with a new charter.

Batteries-included situations and their discontents

I think I’ve hit the first thing using Doom Emacs that is not sitting well with me. Well, let’s scope out a little: I think I’ve hit the first time something that is inevitable with “batteries-included” situations has annoyed me as I’ve used Doom in particular.

Emacs has a bunch of “completion frameworks,” which control what happens when you go to issue a command, open a file, look up a definition or whatever. The last time I used Emacs a lot Helm was sort of the big deal, but since then plenty of others have come along. If you look in the part of Doom’s config that offers pre-packaged completion frameworks, you get several choices:

:completion
company           ; the ultimate code completion backend
;; helm              ; the *other* search engine for love and life
;; ido               ; the other *other* search engine...
;; ivy               ; a search engine for love and life
vertico           ; the search engine of the future

Which, so far so good. As near as I can parse the conversation, newer completion frameworks like Vertico are built around the idea that it’s better to build off of core Emacs functionality and think in a more modular manner. So then you look up what happens when you enable Vertico, that involves a series of complementary packages:

• consult
• consult-flycheck
• embark
• embark-consult
• marginalia
• orderless
• vertico
• vertico-posframe (maybe)
• wgrep

Because I do not want to make this about the problem I’m dealing with at this particular moment, I just want to say holy cow what a stew of possible starting points for solving a problem.

I’ve spent this morning trying to track down a UI annoyance and the mere act of changing word order in my searches has implicated four of the packages on that list. Because the Emacs community is a relatively small one — at least by the time you get done subdividing it into “Emacs users who also use Doom and who are using Vertico within Doom” — you exhaust possible resolutions quickly, and begin to realize you’ve seen the same configuration go by several different times as people in this relatively small subset share it around.

Anyhow, I’m not here to bag on Doom or complain about copypasta configs. I’m just noting that at a certain point in the world of batteries-included frameworks you are sorting through a metric ton of batteries, all tucked away behind a very smooth housing requiring a variety of Torx and jeweler’s screwdrivers to get open. One of those paradoxes, I guess, where your lower-skilled people (me) get a ton of leverage from all the layers of abstraction and affordance, but then wander into situations where it would take a very highly skilled person (not me) to sort out where the magic is going wrong (or just not going the way you wished, since “wrong” is sort of fraught, here.)

And I fall on the maximizer end of the satisficer/maximizer spectrum, so it’s hard to say of some UI glitch “well, that’s an annoyance I’ll be living with,” even if there are ample workarounds or even simple “then quit moving your arm that way” solutions.

Okay. I think I’ve gotten that off my chest. Time to go to the Doom Discourse, mention the issue, and see what I get.

Monodraw

Even if you don’t follow that link, I had an excuse to use Monodraw to illustrate my problem. Monodraw makes it super easy to make ASCII diagrams then copies them in a pre block to your clipboard.

┌──────────────────────────┐  ┌──────────────────────────┐
│                          │  │                          │
│                          │  │                          │
│     Original window      │  │                          │
│                          │  │                          │
│                          │  │      Preview window      │
├──────────────────────────┤  │                          │
│                          │  │                          │
│                          │  │                          │
│      Preview window      │  │                          │
│                          │  ├──────────────────────────┤
│                          │  │                          │
│                          │  │                          │
├──────────────────────────┤  │                          │
│                          │  │                          │
│                          │  │      Vertico window      │
│      Vertico window      │  │                          │
│                          │  │                          │
│                          │  │                          │
│                          │  │                          │
└──────────────────────────┘  └──────────────────────────┘

There is a world somewhere that I could use Monodraw in a business context and not have it be a complete distraction, but for anything other than “a box with words in it,” e.g. a more complex organizational diagram or flow chart, it is utterly distracting, either by people who want there to be boxes with colors or people who want to know how on Earth you made such a complex diagram with pipes and dashes.

It doesn’t toss you into the plaintext-n-filesystem primitivist deep end on your own. It comes with a dired mode that fontifies based on its own filenaming convention, so what seems like it could be super ungainly is actually pretty easy to scan in practice:

… and it has a collection of functions that let you add/remove keywords, rename files using its naming convention, etc. There are even a few next-level sorts of things, such as the ability to create content “silos,” so you can set up a note directory for personal stuff, work stuff, etc. without clashing label namespaces and other things that come up when you have to manage a few discrete areas with the same tool.

As “what would my exit plan be” tools go, this one is pretty good, given It’s All Just Text with no particularly difficult conventions.

It was trivial to move a bunch of notes into a directory, use Denote’s built-in tools to convert them to the proper naming convention, and start using it. It took under a minute to convert a function I cribbed from org-roam’s forums to use ripgrep to provide fulltext search:

(defun mph/denote-rg-search ()
  "Search denote directory using consult-ripgrep. With live-preview."
  (interactive)
  (let ((consult-ripgrep-command "rg --null --smart-case --type org --line-buffered --color=always --max-columns=500 --no-heading --line-number . -e ARG OPTS"))
    (consult-ripgrep denote-directory)))

(map! :leader
      (:prefix-map ("n" . "notes")
      (:prefix ("D" . "Denote")
       :desc "ripgrep" "/" #'mph/denote-rg-search)))

The obvious comparisons in the Emacs ecosystem are Deft and org-roam. I haven’t given Deft much time. I’ve used org-roam more. I like Denote’s lack of a dependency on a database. I don’t know how Denote will compare in terms of scale if it’s all filesystem-and-native-tools.

This is a thoughtful piece by danah boyd that gets to some things I’ve been thinking about re: AI.

Whether you are in Camp Augmentation or Camp Automation, it’s really important to look holistically about how skills and jobs fit into society. Even if you dream of automating away all of the jobs, consider what happens on the other side. How do you ensure a future with highly skilled people? This is a lesson that too many war-torn countries have learned the hard way. I’m not worried about the coming dawn of the Terminator, but I am worried that we will use AI to wage war on our own labor forces in pursuit of efficiency. As with all wars, it’s the unintended consequences that will matter most. Who is thinking about the ripple effects of those choices?

There is a lot of commentary in this r/metafiltermeta thread about AI, which was framed from a place of anxiety:

I’m reading about AI’s impact on coding, graphic design, video, motion graphics, architecture and law. I hear proponents say that they think AI will change jobs, and that smart workers will learn how to use it as an assistant, but when I review Silicon Valley’s contributions to labor in the U.S., mostly I see entire fields gutted, and folks moved over to poorly paying gig economy work.

The more thoughtful responses pointed, I think correctly, to the eventual Gartner Hype Cycle state of equilibrium you get to once you get unrealistic expectations out of the way, trudge through the salty marshes of “told you it was all bullshit,” and get to “how is this thing going to be used day-to-day?”

The people at the Peak of Inflated Expectations do what they always do: Try to solve their problems in a manner ill suited to the tool in front of them, or in a manner that is not reflective of the limitations of the model. The chorus waiting for them down at the bottom of the Trough of Disillusionment has no single motivation: Some of it is wise realism, forward thinking, and experience; some of it is whistling past the graveyard or just missing that “productivity gains,” like many things in technology and business, are not a series of home runs and grand slams, but rather singles and the occasional double. Reframed more bleakly, grinding down labor’s ability to resist induced precarity is a game of inches.

Which is the long way around to saying that if the people who are pointing to offshoring and content-farming mania of the naughts and tens are correct in saying they’re the closest analogies we have, and if danah boyd is right that “we tend to optimize towards more intense work schedules whenever we introduce new technologies while downgrading the status of the highly skilled person,” then it’s going to mean fewer people working in AI-effected systems that are biased toward always looking for one more headcount they can get away with removing. It’ll look different from the “prompt engineering” everyone imagines today. It’ll be software companies figuring out how to integrate existing “dumb” systems with generative AI systems acting as synthesizers, with a few humans acting as QA on top of that process, working from a weakened position.

“ChatGPT Is an Ideology Machine”

Jacobin last month:

A wide variety of Marxists have also seen ideology as a form of kitsch. First articulated by the Marxist art critic Clement Greenberg in 1937, the notion of kitsch is “pre-digested form.” Among all the things we might say or think, some pathways are better traveled than others. The form of those paths is given; we don’t need to forge them in the first place. The constant release of sequels now has this quality of kitsch — we know exactly where we are when we start watching a Marvel movie. For Greenberg, the avant-garde was the formal adventurer, creating new meaning by making new paths. Hegemony and kitsch are combined in the output of GPT systems’ semantic packages, which might miss aspects of “the world” but faithfully capture ideology.

My Things link to org stuff

Today I started using the org-protocol stuff I talked about yesterday with a set of regular todos I added to Things. For my daily writing and journaling todos, I captured links to the headings from the org documents and pasted them into the notes field of the Things todo before marking them done. Clicking on those links brings up a new Emacs frame that jumps straight to the heading in the correct file.

That pretty much recreates the workflow I had with Bear and Things for other kinds of task/notes combinations, and it shows me how to use org-protocol and org-capture to do similar kinds of workflows where Emacs participates in the rest of my tools ecosystem.

So, promising trial experience. I’m a little becalmed on heavy-duty task/work tracking right now, so I’m satisfied to just note that the idea works and that I’ll keep using it to find out where the edge cases are: Something always comes up.

The idea that keeps popping up in my head is that a lot of my past “emacsimalism” – a recurring phase I’ve experienced over several decades – was due to the fact that Emacs was pretty much a technology island. The Mac builds weren’t always very good, and the ways in which it could speak to the system around it were sort of flaky. But things like org-protocol and a little bit of utility glue with osascript do a lot to make it easier to find your way into and out of Emacs. You don’t have to make it your everything because it can work well alongside other things that might suit your individual style better. The idea I’m sort of nibbling around right now is that I don’t like org-mode for organization of work and tasks so much as I like it for organization of text and ideas. It’s less “a smarter Things, OmniFocus, or Reminders,” and more “what I wish Ulysses had been.”

Maybe that’s why assorted org syntax implementations in more modern text editors (e.g. BBEdit, Sublime, Atom, VSCode) are always disappointing: They’re usually just syntax highlighting and no smarts. Might as well just be doing Markdown at that point, because the smarts of org-mode pretty much live in Emacs and lisp. Without that, you’re just quibbling over whether a backslash or an asterisk is better emph notation.

Anyhow, we’ll leave it at that until there’s something new to say. I think I’ve visited this topic plenty.

Twitter

I disabled my Twitter account late last month, so I think I have a bit under two weeks for it to fully deactivate. I think I will thread the needle between making an announcement and merely noting that I have embarked on the process of closing my account by making it the last heading of today’s post, unmentioned in the summary.

There’s a needle to thread because my strong preference would be for people to give up on Twitter. So if you’re someone with whom I might have some influence, I’m happy for you to read this and do the primate thing – “Hm, Mike is a thoughtful, ethical person whose ideas I tend to take under advisement, and he sees Twitter as, on balance, negative and harmful, so I will take that idea under advisement, as well.”

That’s all.

Just after I was remembering it yesterday, there’s a nice appreciation of BBEdit going on over at HackerNews. One comment captured my opinion pretty well:

I read about BBEdit on HN a few months ago and realized it has one use-case where it excels: text transformation and regex search/replace across files. When it comes to this, no other editor I know can hold water: neither Sublime, nor VS Code, nor Vim. And forget about Emacs, as regexes need to be awkwardly double or triple backslashed.

Text transformations can be done via regex, predefined functions, or any scripting language, where the scripts will be listed in the menu. Regex search/replace has a history of used patterns, so you can reuse them.

All in all, it is a very lightweight editor with excellent text transformation features that no other editor can offer.

It is definitely my go-to for that kind of thing. I used to feel sort of guilty that I wasn’t trying to get heavy-duty text transforms done from the shell, then I wised up: BBEdit makes it fast, reversible, repeatable, and visually discoverable. And it will plow through large files like nothing else. I keep a license around just for scenarios like “need to do something to 2,000 Markdown files” or what have you.

Also, my interactions with BareBones for support have been so amazingly helpful and cordial.

Thirty years old and still an evolving, high quality product that I reach for when “I just need to get this task done.”

Emacs update

The last few days I’ve started getting reminders of a fundamental truth of Emacs life, which is that you will eventually push it a little too far with the new stuff and it starts getting punchy and stops feeling trustworthy.

I got a little excited about some tweaks, and I’m glad I was applying them one at a time and seeing what happened, because when one of them hard-locked Emacs it was simple to just go back into my config.org file, :tangle no the offending config, and comment out the problematic package in packages.el.

This is a part of Emacs life, though, that Doom Emacs has made better: It makes configuration simple. I love being able to organize config blocks under headings I can manage with org-mode structure editing, and I appreciate the simplicity of package management. There are a few more steps to get some things done, but they’re simpler steps than how I used to manage Emacs.

When I hard-locked it yesterday it was a small bummer but it was also easy to undo the change and get back up and running. I’ve felt the difference in how I feel when I sit down to use Emacs over the past while: It has gone from “well, I wonder what sort of fatal self-own I’m going to suffer from today” to “this is a stable tool I like using and don’t worry about much.”

It’s such an open ecosystem, and extending it involves so much complexity, that the bits like “oh, added that package and it crashed trying to open a file” are just going to be part of it. But you deal with that by following a “no new toys with an unsaved buffer of something that matters to you” rule and making incremental changes.

Organizing work – todo apps

I spent a little time watching reviews and comparisons of Things and OmniFocus 3 today. Last night I started putting together a 90-day plan in org-mode and was enjoying the “actions/prose” hybrid of org-mode, but also thinking “this is getting complex and these lists are pretty sequential and interdependent … I wonder if I want to put this weight on org-mode.”

So I watched the videos, downloaded OmniFocus 3 again (I’ve had a license for a few years), and took a stab at entering a few small chunks of work to see how it felt.

Not great.

I don’t spend a lot of time worrying too much about how apps look, but OF is just sort of unappealing in that regard.

When I look at Things, there’s a lot of visual appeal. You can’t do much to control it, but you don’t need to. The color scheme and roominess of the interface really work for me. When I look at an org-mode buffer, it is a very different aesthetic. I recently stopped doing mixed-mode and just live in good old Fira Code in a single size. But I’ve got good light and dark themes and once I figured out how to control line-spacing it opened things up a little and made it feel less like a … like smelly ASCII cave. Looking over at MailMate, I can also exercise a little bit of control, so even though it is a visually simple app, the bit of decoration it does have is clean and I can pick my typefaces.

OmniFocus has some customization options, but I’ve always struggled with its font sizes, sort of resenting the iOS-style “small/medium/large/larger/very larger” restriction on my choices, especially because there’s a wide range of text size going on within the UI. It is also cramped. The UI is packed tight and even lists of project headings feel claustrophobic and closed in.

Things 3, one might respond, has next to no customization, either. Fewer choices than OF3, even. But it’s just better done out of the box. It reminds me of something the UX designers at Puppet would have come up with in that it feels light and open.

That’s a lot of time on looks, but if you have to look at the thing all day, they start mattering.

I think mostly I just managed to remind myself that I really loved the idea of OmniFocus years and years ago, but in practice it never stuck for long.

Things is harder to discard. It’s just pleasant to work with, it’s logically organized, the mobile apps are very good, and I really like the way you can organize a project with headings that are loose enough to have whatever meaning you care to give them: Milestones, themes, phases, or whatever. There’s light Markdown sprinkled into the text areas, too. If you were not hung up on ultimate portability, the typography is clean and legible enough that you could manage prose notes in Things.

Back in the day, when I was using Bear a lot for note-taking in conjunction with Things as my task manager, I would just include a link to a Bear note in the notes field in Things. So, for instance, the Things project I had set up for my team had a heading for each member of the team where followup items went, and a link to the individual team member’s note in Bear for prose. It worked pretty well.

Connecting Things todos to org headings

I wondered if I could do that with Emacs and an org-mode heading, and yes, I can.

This StackOverflow post provided two bits of code to add navigation to a given org-mode heading using org-protocol and to yank the link from a given heading. It points to this page on how to make a simple little AppleScript app that registers org-protocol as a valid URL handler in macOS. I bound the link-grabbing function to SPC n L in Doom, and gave it a try by pasting the link into a Things note … yup … worked: Dropped me into a new Emacs GUI window with the point on the org-heading.

Will I use it?

I don’t know!

I remember my Things/Bear workflow being a very nice harmonization of two different kinds of work that lived in single-function apps. org-mode blurs those lines all on its own. I wrote a little about this several days ago in relationship to my plaintext PRM.

I really like how clean Things is for capturing stuff from all sorts of places on my phone and computer. I like its seamless integration with existing macOS and iOS calendars and Reminders. I can do that stuff in org-mode and Emacs, but it takes a little extra work and feels more brittle. There are mobile apps for org-mode, like beorg, but they do feel a little clunkier than Things.

So I guess I’ll take that small chunk of planning I was working on in Things, expand it to more stuff, and see how it feels when I can link in to org-mode documents as easily as I can now.

My traditional “poke around an API” tool is usually an irb session, because I’m probably headed for Ruby once I understand what I’m asking for. This morning a thread on r/emacs led me to verb, an org-mode-aware http client. At its simplest, you give it an org heading like this, from the project page:

       * Example request :verb:
       get https://api.ipify.org/?format=json

Then verb-send-request-on-point to get a buffer with the json response.

But it also works with org-babel:

#+begin_src verb :wrap src ob-verb-response
get https://api.ipify.org/?format=json
#+end_src

#+RESULTS:
#+begin_src ob-verb-response
HTTP/1.1 200 OK
Content-Length: 23
Content-Type: application/json
Date: Wed, 10 May 2023 17:18:25 GMT
Vary: Origin
   {
    "ip": "97.115.5.6"
   }
#+end_src

That’s delightful.

As I’ve leaned more and more into org-babel, I’ve been trying to figure out why it feels both like a big discovery but also something I remembered doing, and it finally occurred to me this morning: I used to use BBEdit’s “shell worksheets” all the time to test and model a suite of scripts I’d written to help with my copyediting work.

My main use case was “here’s a filter I wrote, I’ve got some problematic HTML from some writer sitting here, paste it over in the worksheet, run the filter on it, see how it goes.” It’s been … wow, a little while … since I was doing that. I just did a quick spotlight search on the librarified version and it looks like the last time I edited it was 2009.

org-sticky-header-mode

Sometimes, deep into an org-mode file, I get sort of lost and wondering where I am. org-sticky-header is for those times, providing a breadcrumb line at the top of the window:

More like cit-a-dumb, amirite?

Al and I saw a trailer for Amazon’s Citadel in a movie theater and being the sort of people we are it seemed like catnip. Waiting around for it to arrive, I perused the reviews and was only mildly surprised that they were savage. We watched it anyhow, and I guess I think two things:

1. It’s a very expensive spy show by people who produced Avengers movies, so yes, it is something of a pastiche. A little Mission Impossible, a little Bourne Identity, a little Black Widow, a little Agents of SHIELD, a little Kingsmen. There’s a soapy element to it. You can MST3K the living hell out of it on the first watch.

   Do I like it? I mean, yeah? It is not demanding, it’s a little silly, you could even call it dumb in an endearing way. It is for sure trope-y, anyhow. I don’t end an episode feeling resentful of the time lost – good sign! – and it is honest about how it intends to get you back each week: reveals, as opposed to more puzzles.

2. TV criticism is really tedious.

This is not a “let people like dumb things, critics!” complaint.

It would be really weird to me if a big, expensive Amazon spy show’s critics/audience enjoyment ratio skewed high on the critics side. Big, expensive, popular entertainments are miraculous constructions of cross-demographic box-checking and cynical cultural manipulation designed to do about as well in Topeka as they do in Atlanta. Television critics, on the other hand, come out of a narrower cultural milieu, and exist in uneasy tension with their reading audiences.

I’d hate having to go review an Avengers movie, or a season of the new Star Trek show, or a new Star Wars thing, because the fandom for established properties is right there, waiting for you to not like their thing they like. It’s sort of complicated by the occasional swerve: Gender-flip a property, play with elvish phenotypes, etc. and that makes it fraught in a different way and the calculation changes.

Something greenfield, though – a non-property – and I’d guess critical instincts are on clearer display. Maybe the stars bring along a fandom, but it’s just not as dangerous.

The reviews for Citadel felt a little like that. Like, sort of harsh over stuff that gets a pass when it’s attached to a big franchise. And a lot of focus on inside baseball: Changing creative teams, the production cost, etc.

So, subhead aside, you know, Citadel seems better than the critical consensus. I’d say its current “middling C” audience score is more fair than its “high F” critical average. If I had my thoughts completely in order around genre grade-curving, I might even go higher than “middling C.” Its Major Genre is “spy thriller,” and its Supporting Flavors are “breezy” “romantic,” “light,” and “cross-demographically appealing.” Your curve can do a lot of work with that.

My gut tells me it is not going to produce a lot of stans – It seems like the kind of thing I imagine every generation believes the next older generation would prefer a little more. But it’s also an okay diversion. If I watched a lot of t.v. and really believed every minute of it needed to count, Citadel probably would not make the cut. But I tend to watch t.v. when I do not want to invest the time in a movie, and feel a little too tired to read a book. Things like Citadel work great for me.

Carrion Comfort

I don’t know why Dan Simmons’ Carrion Comfort burbled back up on social media, but it did, and I was fresh off a re-read of Homicide that was sort of grueling this time, so I figured what the hell.

Which makes two books in a row that I picked up remember-expecting one thing and finding something harder.

Homicide was one of the foundational texts of what became The Wire, which I recently re-watched. The book and series share characters (real people in Homicide thinly adapted for The Wire) and some scenes in The Wire are lifted straight from Homicide.

The Wire holds up well today. The cast is diverse, and that softens some of its harder observations about racial politics in a one-party town, by which I guess I mean, “which lets it get away with Clay Davis as a character.” Homicide also holds up, despite being published in the late ’80s, but I think it probably enjoys something of a reverse pedigree, too, and I think it would bother a lot of people if it came out today: There’s much less appetite for its rough irony, even if you have no problem locating where its heart is at, and even if you know to treat it like honest reporting.

But wow was it hard to read this time. It probably should be hard to read a book about a year in the life of a homicide squad in a city that averages better than a murder a day. It doesn’t flinch. It took me forever to get through, because it was just hard to read it.

But it also felt important to read it. It reminded me a lot, this time, of David Grossman’s amazing On Killing, which I read while I was in therapy for some military stuff. (For the record, because it comes up, no, I have never killed anybody, but On Killing had a ton of explanatory power for me trying to make sense of what had happened to me in the army nonetheless.) The two feel connected by an understanding of why some people become police (or join the army) that has gone completely missing in the popular discourse, and in the poignancy with which they consider the consequences of exposing a human to the things a homicide detective, or a soldier, are exposed to. I don’t know how our society will find its way to moral balance between the cultural poles that give us law-n-order copaganda and “ACAB,” but Homicide could be an important text in the process.

Anyhow, I didn’t like Carrion Comfort much when I read it in the early ’90s. I think my taste in horror was maybe more Lovecraftian, and it felt a little overstuffed. There are places where it tells and doesn’t show. But there were a few scenes in it that stuck with me that weren’t what you might expect to stick from a novel about mind-controlling vampires. So when it came back up again and I was in need of a cool-down, I loaded it up in the Kobo.

I’m about a quarter of the way through it this time, and I appreciate it more. Like, the horror parts are more horrible to me. The parts I thought were maybe extraneous now feel like nice attention to detail. Some of it still feels a little tells-doesn’t-show, but I feel a little more patient about them and I wonder if they were just a way to get the audience to sort of pay attention where it matters in the early going.

Anyhow, enjoying the re-read, but it’s landing harder this time.

I’m not saying org-re-reveal helped me win the presentation …

… but I’m not not saying it, either.

And, I guess, by “win” I mean that superstition forbids me to say much about some paperwork I signed, but I signed some today.

I spent a chunk of the weekend working on a presentation using org-mode and org-reveal. I kept getting reminded of why org-mode is so powerful, both as a paradigm and as an ecosystem.

The presentation itself just went faster freed of having to either operate inside presentation software, or working with an eye to moving things into presentation software. You’re just outlining, which is efficient and fast with org-mode.

As you work in the early “get it all out of your head” stages, you can take advantage of org as a todo-inflected outliner, adding literal TODOs and tags to headings to remind you to follow up or help you find common themes/areas. It’s simple to reorder headings, subheadings, and lists. You can make a kitchen sink area and mark it :noexport: and quickly refile dead-ends or reminders with no place to go into it. As you move into refining, those reordering and moving/refiling features make short work of small changes/adjustments. Unlike presentation software, you don’t get caught up in positioning/layout hell.

That’s not to say that there are no positioning concerns, and the way you address them is something a lot of people aren’t going to tolerate, but works fine for me: If you want, e.g. columns – maybe two or three equally sized ones – you have to do it in CSS.

That raises a few usability questions: How much CSS, and how do you wedge it into the org format?

“How much” isn’t much, at least if you know you have full control of the display environment for your presentation. I got away with a few lines:

.reveal .leftcol {
   float: left;
   width: 48%;
   }

.reveal .rightcol {
   float: right;
   width: 48%;
   }

How to wedge it in isn’t hard, either, at least with org-reveal:

You just put it in your org directory somewhere and pull it in at the top of the presentation file:

#+REVEAL_EXTRA_CSS: css/my-reveal.css

If you get tired of repeating yourself across multiple presentations, just customize it with org-re-reveal-extra-css.

There were a few things about the revealjs theme I am using that didn’t quite work for me, and it was easy to use my extra-css file to override them after a quick session with the Web inspector.

The markup inside a doc is pretty simple, too:

* Slide Title
#+BEGIN_leftcol
*Left Heading*
  - foo
  - bar
  - baz
#+END_leftcol

#+BEGIN_rightcol
*Right Heading*
  - foo
  - bar
  - baz
#+END_rightcol

The BEGIN_ keyword just ouputs a div with the rightcol or leftcol class.

So, do I like doing this?

I mean, not in an absolute sense. The presentation I’m working on right now is supposed to represent a work plan I hope I get a chance to actually start implementing. In my ideal world, I’d have a way to hide the positioning/styling markup in a drawer so that it was there and out of the way, allowing the presentation to be a living document that flipped back and forth between a roadmap work document and a presentation.

If I wanted to make that sort of document “code switching” a priority, I’d get rid of the positional stuff, and I’d be in a pretty good place to pull it off. Good enough for my style of presenting.

And even if I’d rather not have the wasted motion, it is not a bad amount of wasted motion. The separation of concerns between content and presentation is still balanced in a direction I like, and it’s not a lot of work to take a practical working doc and turn it into a useful presentation. It reminds me a lot of early, pre-WYSIWYG word processors, like PaperClip III, and typesetting systems that needed “dot commands” to send formatting information to a spooled laser printer.

Here’s a pretty good presentation on the stuff you can do with org-reveal (as bundled into emacs-reveal). It’s where I got the CSS stuff from after a little excavation.

Zoom and Mac display mirroring

Getting ready for that presentation, I wanted to do something really simple:

• Open my presentation in Safari.
• Open RevealJS’s presenter window (current slide, next slide, timer, speaker notes)
• Put the presentation in fullscreen
• Share the fullscreened presentation
• Run the presentation from the presenter window

Which … no. Not happening.

I could do everything but last part, because when I’d move from the fullscreened Safari window to the presenter window, the thing shared on Zoom became Safari’s placeholder “ESC to exit fullscreen mode” tab, and it paused sharing anyhow.

I fiddled around for a while, gave up, and decided maybe the best option was a Firefox plugin that makes a window look mostly fullscreen while not being actually fullscreen. I knew I’d wake up this morning hating it, but also knew I had something I could live with, and that would allow me to turn back to polishing the actual content.

This morning I did, indeed, wake up hating the solution. So I went back into Zoom because I vaguely remembered that you can share classes of things besides “apps,” e.g. devices and displays. Sure enough, you can share devices, displays, and whole desktops (mostly, since full-screened Safari exists in some sort of desktop/screen netherworld, I think.)

I ended up grabbing my iPad Pro, connecting it to my Mac Studio, and using it as a secondary display/desktop. It was easy to drag the full-screened Safari presentation into the iPad Pro, full-screen it, open the presenter window, move that up to the primary desktop, and have it all work as expected.

I am positive I had the setup I thought of first working in the past with just a single monitor, and I found evidence of people noticing that something changed at some point and offering frankly bizarre and counter-intuitive workarounds. I’m glad I just have an iPad Pro to throw at the problem.

I’m also glad that I’ve fully embraced “don’t change anything on game day.” It didn’t take me long – maybe 30 minutes – to get from “I’m using a new presentation approach and I should test this” to “this isn’t working how I remember” to “I tried everthing I know” to “settling on this workaround” to “oh, right – this might work.” Just fine for 36 hours out. It would have sucked on game day.

Scrum and kanban

Interesting post: “You don’t need Scrum. You just need to do Kanban right.”

As my friend Luke is fond of pointing out, most people don’t know what Kanban even is, thinking it’s more of a presentational approach than a whole methodology.

Regarding this post, which I have read once and have marked to read again more carefully, the one thing that stuck in my craw a little was the theme of “making work visible,” because – and I need to do that second read – it seems that visibility stops at the edge of “the team.”

Scrum may, indeed, be “manager training wheels,” and it can definitely become brittle in the face of “a stochastic process such as software development.” But it also makes a team (or organization’s) work seem more legible to the rest of the business, which is busy trying to understand what’s going into the next quarter’s training offerings, messaging briefs, marketing plans, forecasts, etc.

One of the lessons the Fourth International took away from the failure of the 1917 Russian revolution (not the eventual “Berlin wall comes down” failure – the “oh, did you intend for there to be Stalin?” failure) was that you can’t have socialism in one country. A friend of mine did his master’s work on intentional communities such as the Amana Colonies, Harmony, etc. and found similar: Given a local system that is misaligned with its broader context, the broader context takes advantage of its encirclement and either forces compliance or increases pressure until internal contradictions destabilize the system and cause it to either fail, or betray its own principles in order to “survive.”

I’d love to talk to someone who’s “done kanban” as their agile methodology on an enterprise delivery footing. Not because I don’t think it’s possible, but because I’m curious about how it worked.

It’s Saturday afternoon and I am happy to be sitting here working on a presentation. Al’s out of town, so she doesn’t have to put up with me asking her how things sound, I can sit here in my bathrobe and monologue at myself, and only the cats are here to bear witness to me pacing around when I get too agitated to keep typing.

I was not happy to make a bunch of org notes then try to figure out how to get them into presentation software, and didn’t like anything available via the usual export options , but I remembered that Doom has a presentation package for org-mode, so I enabled it (+present in the org-section of init.el) .

That package provides you with a properly configured org-re-reveal, which takes an org-mode document and turns it into a reveal.js presentation. reveal, in turn, provides you with a deck you can open in your browser with transition effects, a speaker window, and keyboard shortcuts.

I’m seldom fond of the stuff that has to happen to get a bunch of HTML loaded into a simpler plaintext format, but the demands of org-re-reveal are pretty light.

I put this at the top of the document:

#+title: My Presentation
#+REVEAL_THEME: league
#+REVEAL_TRANS: fade
#+OPTIONS: toc:nil num:nil
#+OPTIONS: timestamp:nil

• toc: controls whether it has a table of contents slide
• num: controls whether it numbers the slide headings
• timestamp: controls whether it puts the creation date on the title slide

Then for each list on a give slide, I add the first line below just over it:

#+ATTR_REVEAL: :frag (fade-in)
- apples
- pears
- bananas

… which causes each list item to appear in sequence as I advance through the slide.

If you want speaker notes to show up in the speaker window they go in a little block as Markdown:

#+BEGIN_NOTES
Some speaker note
#+END_NOTES

That’s about it. In Doom, you just SPC m e v b and it opens the presentation in your default browser, ready to go. Tap s and it brings up the speaker window, with a timer, current slide, and next slide. esc gives you thumbnails of the presentation so you can go back to a slide by sight, or g to go to a given slide number.

The presentation itself is very simple and clean. You can choose from several themes, including low-contrast favorites Dracula and Solarized for the “oh! My terminal looks like that!” crowd, or some other generically named ones that just look … normal.

There are some presentation modes for org-mode that let you put your org-mode buffer itself into a specially styled mode. I did a trial run with one, but the theme choices were a little offputting, navigation was strange, and there’s a little bit of “I am doing this in an Emacs buffer” nerd glee involved. Fine for Emacs influencer YouTubers, but a little distracting for my intended audience, whom I want to expose to my particular combination of charm, reason, and attentional issues via the content, not the presentation. And I really liked that there was zero config file noodling to get it to work. It’s one of Doom’s finer “batteries included” moments.

I’ve always, by the way, liked Keynote’s outliner mode when I’ve been working on a presentation. It encourages a focus on structure, allows for iterative work as ideas come and go or shift around, and keeps you out of trying to do a bunch of custom work on each slide. Had I not learned about org-re-reveal I would have just popped open Keynote and retyped my outline. And at some point, when I’m back in the world of “we’re all supposed to use this template you can download from Confluence” I expect I will have to figure out how to use the pptx export options. For now, though, org-re-reveal provides an extremely simple, easy, direct path from “outline” to “presentation.”

Making catppuccin work for helm in Doom

I’m a fan of the catppuccin palette family and they’re simple to add to Doom: just stick the theme file in ~/.config/doom/themes and then use them in config.el:

(setq doom-theme 'catppuccin)
(setq catppuccin-flavor 'frappe)

They don’t set any values for the selection highlight color, though, which means you can’t really tell which completion line you’re on as you move the cursor around. It’s also an exercise in a very unique sort of frustration to try the usual “what is this face called” trick of desc-face (SPC h F in Doom ) in a buffer you can’t run a command on.

My own search queries about it were just poorly formed enough that I stood on the precipice of saying “sure, I’ll just eat these 50 lines of lisp off the sidewalk to number the selection if that’s what it takes,” but I reframed one last time and finally found the answer.

The face to customize is helm-selection. Just give it a background and it’s fine.

Longboarding season is here

Andy Carolan reminded me that longboarding season is here.

A few years ago Al and I decided we wanted to learn how to lonboard. I don’t remember why. I think we just wanted to get out and do something together. So we bought some very cheap Amazon completes that looked cool – 42" top-mount pintails – and spent weeks over at the nearby elementary school playground learning how to roll around on them like very upright mannequins on wheeled platforms.

Then we started watching videos and reading blogs and figuring out better choices. I finally settled on a Pantheon Trip – a little 33" double-drop. Alison got a Loaded Icarus, a really nice composite deck with a bunch of spring to it. I also had a Bustin’ Maestro, a 37" dropthrough. I had several more boards for that matter, trying to get comfortable, and ended up writing a guide for fellow olds.

We took the boards everywhere for a while: State parks sometimes have good accessible paths you can ride on, or just good asphalt around the campground for cruising. Also Saturday coffee runs and cruises down the Springwater. For a period, when I was riding the train to work, I used mine as a “last-mile” conveyance to the Lents Town Center station. A few times I did 10-mile solo rides down the Springwater.

Cruising was fun, and the Pantheon Trip is a great deck for that because it has huge wheels and rides super low to the ground. It’s low effort to push, and the giant wheels just roll over grit and rocks.

We stopped riding together when Al took her spill: She hit a seam that joined the Springwater to one of the overpasses and went over backwards. She threw her arm out and it dislocated the part of her elbow that didn’t just shatter. We spent 40 minutes out on the Springwater while emergency responders from three jurisdictions argued over who should come get her. She’s got titanium in that joint now, and exceeded the doctor’s predictions, regaining full mobility. The only reminder is the bad-ass scar and some aches when the weather is cold and wet.

I kept riding, and absent the sort of mellow vibe we’d established as a couple got interested in downhill, so I took a class from a local longboarding champion. We met every Wednesday night at Mt. Tabor. It was one of the most fun things I’ve done in a while. Completely padded up, helmeted, and doing the hills we were doing, it was no big deal to wipe out, and it felt great to get knocked around a little. I’d leave class feeling the same way I felt at the end of a day in the sawdust pits or the swing-landing trainer at jump school.

Anyhow, last season I traded in my hard pads for some nicer G-Form elbow and knee pads that go under my shirt and pants a little more easily, and I traded my Pantheon Trip in for a Pantheon Pranayama, which is pretty much the Trip except with traditional kingpin trucks, so it’s a little more nimble. I went with the 7-ply deck, so it’s also less stiff than my 8-ply trip. I thought that might have been a mistake, but I’m down about 25 pounds from last season and I think it’s going to be okay.

Anyhow, it’s 10 a.m. and time to get back to that deck for a little while. Presenting Tuesday!

Looking around for other people who have done CRM/PRM-ish things in plaintext, I found JacobEvelyn/friends. It’s written in Ruby, uses Markdown for its home format, and gives you a command line interface to a record of your friends and activities. I appreciate how thoroughly it thinks about what it is trying to do, and I sense a set of concerns similar to mine about the “keeping up with personal contacts” challenge.

Some things I like about it:

• Simple CLI data entry syntax
• Some “habit tracking” style reporting to help you understand if you’re keeping up your practice.
• Clean reporting with a lot of flexibility that would let you build more reporting.
• Simple use of Markdown, with no elaborate syntactical overlay. If you gave up on friends, your data would be easily readable.

It’s probably good to note that friends isn’t a full contact management system. It’s better to think of it as a sort of journaling and habit tracking tool with a tight focus on keeping up with people, not a way to manage all your contact details. If I could extend one thing about it, it would probably be to be able to store email addresses with contacts: Email addresses aren’t great keys, but also they’re fine keys sometimes, and they’d open friends up to interacting with other tools.

ox-json and the wisdom of Neil McCauley

As I was looking through the docs for friends and waming up to it some I wondered how readily I could migrate my org-contacts information. My home language is Ruby, so I tend to start there when I’m looking for a library. There’s one org-mode gem I’m aware of, but its primary preoccupation is converting org-mode to HTML or Textile for presentation purposes.

Another way to come at the problem is to get the org markup into something more universally parseable, which is where ox-json could help. Does what it says on the tin: Converts an org-mode file into JSON, including, crucially, the data stored in the :PROPERTIES: drawer. Currently it passes by the :LOGBOOK: drawer, so that limits what you can do with it, but it still opens up possibilities.

Why?

ox-hugo update

I started blogging with ox-hugo several weeks ago, going into it a little warily.

Recap:

• You write all your posts in a monolithic org-mode file.
• Each heading is a post.
• Heading tags become post tags.
• Headings in a TODO state are drafts.
• Metadata can be stored in the :PROPERTIES: drawer (tidy, but the templating syntax gets cluttery if you’re not a lisp native) or additional metadata src blocks (more visually cluttered when writing, but easier to read the template if you’re a YAML native)
• You can set it up to automatically export the Markdown version into your Hugo content hierarchy whenever you save the buffer.

Why would you want to do this?

As someone who does a lot of digest posts, I like having my pre-publication notes, links, etc. in the org-mode ecosystem, with all of its text manipulation affordances. If a topic I’m working on isn’t ready when it’s time to publish that day, I just refile the subheading under my * Daily Post Overflow heading and keep going. I also like org-mode’s structure editing features. It’s simple to move headings and their content around within a post.

I thought the “all-in-one-file” thing would annoy me, and there is part of me that still doesn’t like seeing all the surrounding context, but that’s what subtree to indirect buffer is for. I drop into an indirect buffer for the long-haul writing, then pop back out of it if I need to pull things in from the overflow area or check on something from a previous post.

I did stub my toe on one thing, which was that the org-capture template I found to make the post setup simpler was setting :EXPORT-HUGO-DATE:, which updates dynamically when you save a post heading. I went back to make some edits to a post, saved my work, and it altered the date metadata in the Markdown output and jumbled my post order. The answer seemed to be to switch that to :EXPORT_DATE:, and now it behaves.

I also put off cleaning up my capture template so all the metadata could go in the :PROPERTIES: drawer. At first It was easier to just embed some YAML at the top of the post body with #+begin_src yaml :front_matter_extra t rather than working out the Lispier syntax for post image and cover image in the context of writing a capture template. It just took a few minutes to fix once I decided to bother with it, and the template now outputs :PROPERTIES: metadata:

:EXPORT_HUGO_CUSTOM_FRONT_MATTER+: :cover '((image . "" ) (caption . "" ))
:EXPORT_HUGO_CUSTOM_FRONT_MATTER+: :images '(/momo-logo.jpg)
:EXPORT_DESCRIPTION:

I only sometimes use cover images, but I like to include my site logo in social posts, etc. when I don’t have some other image to show, so the template defaults to an empty cover image and image metadata that Hugo’s OpenGraph templating can pull in.

Several weeks in, I like the workflow. One tiny part of my soul is troubled that I have org source and Markdown output, but on the other hand the org source overwrites the Markdown output on edit, so the two don’t drift. Realistically, the Markdown would be the more migratable content were I to shift off of Hugo, and it’s simply better to author in org-mode. So there’s no associated toil and each format gets to be useful in the way it is best suited to be so.

That Royal Enfield Himalayan

I complained a little about my Royal Enfield Himalayan a few days ago: a little big for the power it has, and it had some QA problems that took some time to track down I am pretty sure I am going to sell it to fund something similar. But I did swap in a fresh battery and cleaned it up from winter storage, and rode it up to St. Johns for lunch yesterday, which meant a few dozen miles. It ran pretty well!

Last year, after dealing with rough idling and stalls, I finally broke down and installed a BoosterPlug. Himalayans run too lean out of the factory, and the difference after installing one was pretty amazing. It was about a five-minute operation and it made the difference between a very rough first five minutes and “let it idle for 30 seconds and it’ll be fine.” The machine never stalls now. I do think it still idles a little low, but that’s a fine-tuning thing.

Anyhow, it was nice to ride around. Yeah, it’s a little big, but it’s not a big bike. There’s plenty of pep for the city. Running up HWY 30, it did fine with the lunch crowd and there was plenty of power to overtake or squeeze out of spots at urban parkway speeds. I’d do exit-to-exit on the Portland bypasses with it.

I was also glad to see an RE dealership up in St. John. Wasn’t a fan of the Harley dealership I was getting service at and had to do a lot of research on my own to get help when it was suffering from factory QA problems.

I recently recommended Mackup, a Mac config syncronization tool, but I’m having a few issues with it now. In general, it does a pretty good job with most apps, but I ran into a weird bug with Mailmate where it kept forgetting all my settings. After a few go-rounds I opened up the Console and searched for Mailmate messages and found it wasn’t able to write to its prefs file. I put Mailmate in Mackup’s skip list, removed the symlinks and let it write its files again and all was well. Searching Mackup’s issues, I found someone experiencing a similar issue with Xcode and learned it seems to be a thing with Dropbox and iCloud and certain apps. In the case of Dropbox, it has come with that app’s move to the CloudStorage folder.

I’m not sure this is enough to get me quit using it. It works quite well with my Emacs config, gpg, ssh, zsh, and other stuff. I also like using it for syncing my ~/bin. It doesn’t work so well with Terminal.app, and gets a little weird now and then with a few other things.

Just … proceed with caution, I guess is the advice. For now I’ve got Mailmate, Terminal.app, karabiner, and Bartender on the skip list. That’s fine for most of them: They’re generally best configured a little different between laptop and desktop anyhow.

My org-contacts file and Things

I stopped using mu4e. I was uncomfortable with the interplay between several different clients (both automated and user-facing) and my Maildir and IMAP. That left a a small hole in the functionality I’d built into my org-mode PRM: being able to quickly mail a contact from a Doom Emacs menu. So I made a quick function that just turns the email address in the org-contacts record into a mailto: link and open call to the system that invokes my preferred mail client (Mailmate at this point). So if the point is over an org-contacts heading I can SPC C m (“leader - CRM - mail”) and get a new message.

I’m on the record somewhere about not liking the emphasis on URL schemes for Mac automation. I don’t like the ins and outs of encoding values and cramming data into that format. At the same time, it does seem to have kept the idea of Mac end-user automation from fading away. So as I sat there looking at my new mailto function, I wondered about how all the contact data I’m keeping could interact with the wider Mac ecosystem in a sort of “if needed” manner, hence this little thing.

It just provides an interactive menu for selecting a contact activity (ping, call, write, etc.) and an interactive date picker, then makes a Thing todo that includes the tags for the contact, with a “start date.” I can get at it with SPC C g (“leader CRM thinGs”). I don’t mean to use it? I was just curious. I’m not sure.

What I am learning as I use org-mode day-to-day again is that there are things that come naturally to it and that do not come naturally to it. I’ve got working integrations with my calendar, for instance, but calendar syncing is another one of those things that eats the one thread you have to work with when it runs, and sometimes it does mysterious things if you mess with a plaintext representation of a more complex data structure that was never written with direct human interaction in mind.

That’s always the struggle with Emacs: What can it do, and what should it do?

The temptation is to crawl into a uni-environment and torture everything into some kind of alignment, but that’s brittle. It might feel good if your temperament or proclivities lead you to feeling comfortable with that particular shape, but there are tradeoffs whether you acknowledge them or not. In this particular case, the line I am sensing is the line between “getting things done” in a very mixed, tactical, “chores, obligations, and interrupts” kind of way, and getting things done in a very “life is an information problem” kind of way.

I love org-mode as a way of organizing information and thoughts. In particular, I am very fond of all the refiling capabilities it offers, because ideas and information can be shuffled around between different contexts inside the broader org-mode context without lifting a hand from the keyboard. As a day-to-day “chores and household projects” tool, I’m a little less certain about it, mainly because of the mobile piece. beorg is great, but it is also a little bit of work to use, and its syncing model is borrowed, so it’s not as good as a purpose-built solution. Further, it is not consistent with my desktop org-mode environments when it comes to things like the agenda views.

So, you know, the interesting thing to me becomes “how can this sophisticated text manipulation environment fit into a broader toolkit?” How can all these things interconnect and complement each other? What are the kinds of work that makes sense living in a purpose-built tool because their typical context favors less thinking and less complexity, vs. the kinds of work that are broadly the same thing (“a thing I need to do”) that benefit from more thinking and more complexity? What kinds of tasks can be “dead” and in a little purpose-built silo, and what kinds of tasks benefit from a little bit of added complexity to exist in a better context? How could a thing move from one environment to the other?

Interesting to me, anyhow, because my tendency, at rest – my unconscious tendency – is to want everything in one tool, but I continue to learn over time that the one-tool outlook breeds its own kinds of complexity.

Anyhow, here’s that function. It works okay so far. The one glitch is that the Things URL scheme won’t make a tag if it doesn’t exist, so I had to go in and tag an existing todo with all my contact types (friend, network, recruiter, etc.) to get the function to properly tag a contact todo.

(defun mph/org-contacts-to-things (contact-kind)
  "Create a Things to-do item based on the current Org Contacts record.
   CONTACT-KIND is a string that specifies the kind of contact ('ping', 'call', 'write', 'schedule', or 'follow up')."
  (interactive
   (list
    (completing-read "Contact Kind: " '("ping" "call" "write" "schedule" "follow up"))))
  (let* ((name (org-entry-get nil "Name"))
         (email (org-entry-get nil "Email"))
         (phone (org-entry-get nil "Phone"))
         (note (read-string "Note: "))
         (notes (format "Email: %s\nPhone: %s\nNote: %s" email phone note))
         (start-date (org-read-date nil nil nil "Start Date: "))
         (start-date-string (format-time-string "%Y-%m-%d" (org-time-string-to-time start-date)))
         (tags (org-get-tags nil t))
         (tag-string (if tags (mapconcat 'identity tags ",") ""))
         (title (format "%s: %s" contact-kind name))
         (url (format "things:///add?title=%s&notes=%s&when=%s&tags=%s"
                      (url-encode-url title) (url-encode-url notes)
                      (url-encode-url start-date-string) (url-encode-url tag-string))))
    (start-process-shell-command "open" nil (format "open \"%s\"" url))))

Conversations, not interviews

Refreshing interview closer of the month:

“We have a few minutes left, any questions of me?”

“No. I came into this thinking you’d either say ‘did you even read the job description? Now good day while I go fire the recruiter,’ or you’d see something that would lead you to want a conversation, which I hope we’ll continue so I can learn more.”

And there we were, having a conversation.

I’ve been very lucky to have had several conversations recently. It’s reminding me of the times I had interviews and how those things went wrong down the road. It’s great to end a conversation hearing the person you were conversing with say “wow, the time flew by … but this felt so organic.” You can enter a conversation with curiosity, and with a good conversational partner you can see where things go, make connections to your experience in the moment, change course or call up other experiences when they say “well, that’s not quite what we’re dealing with here.” That’s much better than pre-thinking a bunch of answers and poring over “ten most common questions” or (if Nigel or Chris are reading) “you’re trapped in a 20’ blender” scenarios.

(I learned about that from this post by James Sulak (another Emacs person, as it turns out), who shared a set of helpful Alfred workflows for working with MailMate.)

This function grabs the EMAIL property of a given org-contacts heading and runs the open shell command:

(defun mph/open-mlmt-quicksearch ()
  "Open a quicksearch URL for the email address at point."
  (interactive)
  (let ((email (org-entry-get (point) "EMAIL")))
    (if (not (string-empty-p email))
        (shell-command (format "open 'mlmt:quicksearch?string=%s'" email))
      (message "No email address found"))))

MailMate search is very fast. The results are there in an eyeblink.

… and that sort of led to this, which searches Google Calendar for an email address from a contact:

(defun mph/open-gcal-search-for-email ()
  "Open a Google Calendar search page for the email address at point."
  (interactive)
  (let ((email (org-entry-get (point) "EMAIL"))
        (search-url "https://calendar.google.com/calendar/u/0/r/search?q=%s"))
    (if (not (string-empty-p email))
        (progn
          (message "Searching Google Calendar for events with email %s..." email)
           (browse-url (format search-url email)))
      (message "No email address found"))))

… and that suggested this one, which gets a date from the interactive org date picker and creates an all-day Google Calendar event with the contact as an invitee:

(defun mph/create-gcal-all-day-appointment-with-contact ()
  "Create a new all-day appointment in Google Calendar and invite the contact at point."
  (interactive)
  (let* ((date (org-read-date nil t nil "Date: "))
         (formatted-date (format-time-string "%Y%m%d" date))
         (next-day (format-time-string "%Y%m%d" (time-add date (* 24 60 60))))
         (contact-email (org-entry-get (point) "EMAIL"))
         (url (concat "https://calendar.google.com/calendar/u/0/r/eventedit?dates="
                      formatted-date
                      "/"
                      next-day
                      "&pli=1&sf=true&action=TEMPLATE&add="
                      contact-email)))
    (browse-url url)))

I preferred just setting it to all-day, because I’ve learned a few things about scheduling time to catch up with people in a non-business context:

1. It’s usually gonna be a few weeks out. PTO, busy, etc.
2. Setting a day is pretty easy, but setting a good time can be hard when it’s that far out. Schedules do things, or we know a given day is usually our good day, but specifics can shift around.
3. Setting an all-day item and a reminder to lock down the details several days out makes it easier to agree to something and work out the details when calendars are a little more clear. No constant shuffling if one party or the other isn’t in complete control of their own calendar.

I wonder if I should go read a book about how to stay in touch with people. I know there are several.

I’ll include that below, but the other thing to link to before your eyes glaze over with a hunk of Ruby is this useful post on using consult-ripgrep with org-roam for fulltext search from the org-roam Discourse. I’ve been careful to tag everything I’ve put in so far, but I won’t get to that with this batch of files, and I usually remember a keyword, anyhow. So they’re just tagged with “quotes” and “commonplace” for now.

The script just consumes the JSON that DayOne’s export function provides and coughs out formatted org-roam nodes. It uses DayOne’s uuid’s, but tacks on a few words – just in case? Maybe over time I’ll go clean up the titles but for now they’re just there to provide a hint when I search.

#!/usr/bin/env ruby

require 'json'
require 'date'

# Set these up before running
src_json = "/path/to/file.json"
destination_dir = "/path/to/export/dir"

# Read the JSON file
json_str = File.read(src_json)

# Parse the JSON string
data = JSON.parse(json_str)

def write_json_to_org_roam_files(json_str, path)
  data = JSON.parse(json_str)
  entries = data['entries']
  entries.each do |entry|
    created_date = DateTime.parse(entry['creationDate']).strftime('%Y%m%d%H%M%S')
    title = entry['text'].gsub(/^"/, '').gsub(/"$/, '').gsub(/[^a-zA-Z0-9 ]/, ' ').squeeze(' ').strip # replace non-alphanumeric with space, remove extra spaces
    first_words = title.split.first(5).join(' ').gsub(/[^a-zA-Z0-9]/, '-') # replace non-alphanumeric with dash
    uuid = first_words + '-' + entry['uuid']
    content = JSON.parse(entry['richText'])['contents'].map { |c| c['text'] }.join("\n")
    filename = "#{created_date}-#{first_words}.org".gsub(/^-/, '').gsub(/-$/, '').gsub(/-{2,}/,'-') # remove leading/trailing dashes and collapse multiple dashes
    file_content = <<~ORG_NODE.gsub(/^\s*/, '')
      :PROPERTIES:
      :ID: #{uuid}
      :END:
      #+title: #{first_words}
      #+filetags: :commonplace:quotes:

      #{content}
    ORG_NODE
    file = File.open(File.join(path, filename), 'w')
    file.write(file_content)
    file.close
  end
end
# Iterate over each entry
data['entries'].each do |entry|
  write_json_to_org_roam_files(json_str, File.expand_path(destination_dir))
end

“The more a thing tends to be permanent, the more it tends to be lifeless.”

A few days ago I wrote about Zettelkasten:

In the end, it just wasn’t for me. I tried it, and Obsidian is an excellent tool for organizing your work that way, but I think the problem I had with it was that the ratio of “volume of stuff that’s just there in my head” to “volume of stuff I need to keep in a second brain” didn’t justify the existence of the second brain, or at least not one organized in classic Zettelkasten fashion.

That remains true. However …

In the process of thinking about what to make of old blog posts I realized that one of my bigger impediments to blogging at all was a little personal confusion about what a blog is. In the past year I had a small crisis around my personal domains and realized things had sprawled and gotten a little too tangled up, so I got a new domain that solved a few problems the old one caused, and I went to some effort to establish new email addresses and sites. It was time to do all that, because I was pretty sure I was about to get thrown out of my work nest, and I had some ideas about what I needed to do to be ready for that.

But solving one problem – correcting for a lack of intentionality in my web presence over years – led to another one I only recently figured out, which was about having the wrong intentions once I got more intentional.

The brochure site months

I got very into the “personal branding” aspects of my web presence. I had some ideas about a small book, I had done some writing about work, and I was feeling defensive about what exactly it was I said I did there. So as I sat down to think about why I wanted to have a website, there was a “professional considerations” piece to it that loomed larger than it ever had, and I was thinking in the direction of “content marketing.”

I built that site and really enjoyed doing it. It was a chance to stretch a few web development muscles, and I really loved the way I’d managed to blend my photography and writing. And I liked the idea of positioning it as a slow-moving, professionally safe space where I could pull in work from past sites, but keep the focus on The Work Persona. I didn’t discount the value of a more personal, faster-moving site, so I focused on fixing up my microblog, too.

Actually maintaining that sort of web presence turned out to be a drag. The second the site was up and running it became a gigantic, statically generated Blank Page Problem. Over on the microblog I was just being me; on the “core” site I was struggling with being the kind of writer I sort of hate to come across out in the real world, trying to sound authoritative and opinionated about matters of professional import. I completely get that some people manage to strike a very authentic balance with writing about what they care about, and what they care about happening to be, in part, their professional life. I couldn’t make myself fill the page, so the site mostly sat.

Then I did get thrown out of the nest, and something I thought was kind of irritating but would eventually be surmountable when push came to shove actually became even more of an issue for me, because what had been a simple but misguided idea that I’d just gradually fill that site up with stuff as it came to me felt inadequately urgent.

I am very lucky to have a supportive partner and some other good voices around me, because after I spent maybe six weeks last fall using a period I’d known for months was meant to be restful downtime doing anything but resting, thrashing around, coming up with Big Projects, I just settled down and actually rested. I just stopped. Or rather, I stopped doing anything I would ordinarily believe I was supposed to do, and let myself do what I wanted to do as it occurred to me to do it:

… I am feeling good because I realized at some point over the past couple of weeks that I am doing all this because it is playing. I used to do a lot of little utility scripts and silly gadgets because it was fun and absorbing, not because it was hugely practical or efficient. It was just playing. I stopped playing for a long while. It feels good to play again.

Since January, I’ve slowly turned back to what I need to be doing, and I’ve been immensely grateful that my friends and network have been there for me as I find my way back to a job because there are parts of The Job Hunt that are a colossal drag – the grind of getting opportunities into the top of the funnel – and there are parts of it, once something works its way down the funnel that are hard in different ways.

The value of this site has played out a little differently than I imagined when I thought it was going to be a content marketing thing. It definitely does come up in interviews, because I’ve done writing for it that is about work stuff, but less HERE IS A BROCHURE OF MY THOUGHT LEADERSHIP and more “oh yeah, you know, I wrote about this very thing a few weeks ago, and found my thoughts changing a little once I thought it out more.” A few people say “oh, I’d love to read that if you don’t mind sending me the link,” but not many. But when they’ve asked there’s been, in funnel terms, a 100 percent conversion rate from top-of-the-funnel to middle-of-the-funnel. That’s great.

But the hidden half of that has been the very real struggle, after ten years in one place, of getting back into the swing of looking for my next thing to do, and shifting from that mode of sitting quietly with your hands folded politely in your lap answering questions as correctly as you can muster, to finding the people who want to have actual conversations and welcoming the opportunity they present.

It took getting all the way to the end of one very mechanistic, flat, incurious hiring process to flip a switch in my brain.

One of the interviewers as good as said “well, you’re coming from this environment you were in so you probably are this certain way” in the midst of a “here are nine questions, prepare your three-minute responses, we are not permitted to have a conversation that deviates from you answering this question” session. It was incredibly belittling and frustrating, and it finally sparked the thing that I guess you have to have sparked if you’re going to continue the process of going around asking people to give you money in exchange for having to use Outlook or whatever, which was a sense that my background – the places I’ve been, the things I’ve seen, and the work I’ve done – adds up to something more than a collection of self-published pamphlets about businessing.

Anyhow, the switch that flipped was, “this could get harder before it gets easier, but it’s going to suck hard and it’s not going to end well if I keep looking over my shoulder.” I, er, contain multitudes, and I have come to believe that the best way to get across who I am is to quit trying to draw a circle around me.

(I do not, by the way, have a “so I told that guy to shove the job” story to tell. I got declined, apparently very narrowly. I definitely would have taken the job, because I’m fine working against expectations. You cannot go from “studied philosophy” to “worked at a newspaper” to “administered UNIX systems” to “volunteered for airborne school” without feeling comfortable being misunderstood by everyone around you.)

So this site is now the way it is, instead of the Brochure About Mike it was meant to be, because this, more or less and as much as I’m willing to disclose, is me.

Okay, but something about org-roam?

Right. As I was saying. A few days ago I wrote about Zettelkasten, related some reasons I decided at the time it was not for me, and then gently defended what I took to be a mild challenge from someone who wished I’d given it more of a chance.

But if the point of this site is less to represent me as a unit of productive capacity and more to think out loud about my preoccupations as they emerge (and hence become its own sort of representation), then it did its work in this case, because over the weekend that post ended up being just a thesis that I applied to what I thought I’d want to use a Zettelkasten system for, flavored in part by my natural (and not always flattering) skepticism about why people get into these things.

But like all good theses, it is subject to dialectical forces – new contexts, conditions, or information.

In the process of trying to salvage something from hours of over-preparation, I realized I had a bunch of good material about what I think about certain things that was suffering from being stuffed into the mold of a very rigid and dysfunctional interview process that nevertheless had forced me to rethink my value proposition and set my sights a little higher than they were going in. And I also realized I have a few opportunities coming up – and will no doubt have more – to use that material very soon.

As I killed a little time waiting for Al to get home, my mind first went to “well, turn it all into a couple of very thoughtful essays about IT, inclusion, etc. the better to stock your website with brochures.”

Then I thought, “we told ourselves we don’t like doing that.” Or as a friend put it, “I thought you said you were over the idea of writing weird shit for LinkedIn.”

Then I thought, “but wow, it can’t stay in this form, because it’ll always smell like the janitor’s closet at the county jail when you try to get any good out of it.”

I realized I wanted to do with it what I’d sworn 48 hours earlier didn’t really make sense to me, which was to sort of draw dashed lines on the surface of that big, strangely shaped accretion of thought, then go at it with a hammer until I had a bunch of chunks I could label and repurpose. So I took some time to re-read the org-roam manual, look at some half-understood config I’d put in place when I was giving it a try post-Obsidian, and clear my head of the idea that I was going to some day write eight-dozen books about management thanks to Zettelkasten, or do anything particularly public at all, really.

Having done that, I started chunking out the ideas in that writing and “inserting nodes,” in the org-roam parlance.

I didn’t get too much into linking anything for now, preferring to start at the level of tagging. I once went to a talk then years later had an interesting exchange with the guy who invented the term “folksonomy,” and his ideas about free-tagging have stuck with me since. People often screw it up by assuming that free-tagging is somehow antithetical to “categorization” or other ways of making associations … oh, just read this for the problem with that. Briefly, I have gotten hung up in the past with the advice to build MoC pages, etc. but was encouraged by that guy to think instead of tagging as cow-pathing. Eventually, you will want to put up lights and signs, and before that you may even want to make a map of the best ones. For now, I am just being careful to tag. When there is a nugget in something that I didn’t manage to break down or separate from something close to it, I am giving it its own heading so I can make it a node with a tag.

Anyhow, I’m giving the whole thing another try because I have a practical thing to do try it out on, and it is already helping me: I have a presentation coming up and it’s great to go through that previous work shorn of a little of the original context.

Less a big thing to write about and more a thing I learned that was helpful after pounding my head against this wall:

mixed-pitch-mode allows for both variable and fixed pitches. It’s nice for org-mode, where you’ve got a mix of prose and more code-looking stuff – headings and body text look nicely typeset, property drawers and tags continue to use a fixed face.

My Doom font setting is pretty basic:

(setq doom-font (font-spec :family "Fira Code Retina" :size 15 :weight 'regular)
      doom-variable-pitch-font (font-spec :family "SF Pro" :size 16))
(

… but for reasons that eluded me, when I entered mixed-pitch mode, my variable pitch font was way too small, except when it was way too big.

I did a lot of poking around, a lot of searching, and a lot of scrolling forums, then I broke down and asked ChatGPT, which told me to add this:

(setq mixed-pitch-set-height 16)

That did it. Combined with the doom-earl-grey theme, I’ve got a pleasant, low-contrast, paper-like display to work with.

A rare political link

I was braced to hate this column, but ended up appreciating it a lot:

No, You Absolutely Do Not Have to Hand It To Tucker Carlson (The Nation)

“… there’s every reason to view Carlson’s alleged anti-war politics and putative politics as a fraud. It’s true that Carlson worries about escalation in the Ukraine/Russia conflict and has pushed for diplomacy. But his position on that issue is based not on any aversion to militarism but a belief that the United States should focus its firepower on other enemies, notably Mexico and China. Rather like the late Gore Vidal (who, alas, made this argument in the pages of The Nation), Carlson wants an American-Russia alliance against the non-white hordes. International relations scholar Daniel Drezner observes, ‘It’s also hard to claim that Carlson was opposed to U.S. military adventurism; it’s more accurate to say Carlson preferred aggressive military adventurism closer to home. Carlson repeatedly called for using the military south of the border in Mexico.’”

… and

As for economic populism, Carlson is far more likely to criticize big corporations for “wokeness” (in other words trying to keep up with changing social mores) than union busting. His populism is the kind that worries about gender ambiguity in M&Ms candy—not rampant inequality. He’s all too quick to revert to GOP business-class norms when there is a partisan battle. Business Insider reported on a telling moment in 2021 when Carlson “accused President Joe Biden of proposing a tax hike on wealthy Americans to ‘punish’ them.” This was a tax on people earning more than $400,000 per year—hardly a fitting target for proletarian outrage.

In sum:

His occasional populist and pacifist sentiments only exist in the context of a politics that aims to take justified anti-establishment outrage and harvest it for far-right ethnonationalism.

Why was I braced to hate it?

Because one of my core theses about What is Going on Right Now is that formerly cherished political categories are disintegrating, but we’re not doing a great job of understanding what that means, or allowing each other to explore what that means. So while it’s good to call out a charlatan like Tucker Carlson or assorted other faux populists (fauxpulists?), it’s not great when we just shoot on past that useful distinction-making and on into the territory of “therefore, nothing they’re saying should have any resonance with decent people.”

The danger of Tucker Carlson and others like him is not, to me, that they think bad or dangerous things. It’s that they are accomplished ideological entrepreneurs. They’re good at catching scent of shifts in the popular mood, understanding the language of those shifts, and then folding those shifts into whatever their real political commitments are. I’m not sure who you could name on the left that has shown the same acumen for that kind of political marketing. Bernie Sanders, AOC, Elizabeth Warren, and Katie Porter come to mind as politicians working the left populist beat. In terms of commentators? Not sure.

One bad side effect has been the rise of commentator who exist outside the mainstreams of conservative or liberal thought and engage in their own entrepreneurialism despite being badly confused about their own political commitments.

I’m thinking of people like Batya Sargon Unghar, who wrote a snarling takedown of student loan forgiveness as a populist issue because, she said, it wasn’t helping “enough classes of people,” implying that there couldn’t be any working people with student loan debt. She has made some good observations about the cultural and class proclivities of the professional media “class,” but that’s just it: She doesn’t see a working reporter as a “working class person.” The top one percent of households in the US control a third of the wealth, the bottom half of US households control 2.6 percent of it, but let’s pit the nurse (or reporter, or software developer, or corporate recruiter, or technical writer) paying off their student loans against the person working a job that didn’t require college.

And I’m also thinking of the contrarian class – people who probably have some sort of left political commitment but respond poorly to reflexive rejection of an idea because the wrong person coopted it, and who end up contributing to a feedback loop: They become impatient with the echo chamber, they resent the lazy dunks and thoughtless inconsistencies of politics built around cultural antagonisms, and they get lumped, in turn, with “the dark side,” tainting anything they’ve ever put forth regardless of its worthiness.

Anyhow, my point, I suppose, builds off this one:

The strategy of selectively borrowing left-wing ideas in order to bolster a program of nationalism, racism, and gender conformity is not new. As Meyerson and Mavuram rightly observe, this is a familiar tactic of fascism, which typically emerges in a time where establishment politics are in crisis and the public is open to multiple solutions.

I appreciate an article that can acknowledge that selective borrowing, and remind readers that Carlson and other fake populists like him are identifying “what works” about left political ideas. That doesn’t mean we should spend our time understanding how we could rehabilitate Tucker Carlson: He does not want to be rehabilitated. He is a cynic whose commitments are not mine. But we should spend some time understanding what in there both resonates with our own politics and speaks to people who are suffering.

Affiliate links and ethics

If you truly think a product is too bulky, pointlessly prods people toward buying a thing that replaces a shared good they probably already have, is hard to use, leaks water, takes forever, and is only worth a score of “5/10” even though you couldn’t even get your own spouse to try it out, I’d propose that you not put affiliate links in your review.

I think this cuts to the core of my issue with modern review sites. The only way to get the reviews is to accept that they need affiliate link revenue; but you end up in situations like this, where the product is a sustainability nightmare about which the only nice things you can say are “doesn’t smell,” “looks cute,” and “good if you don’t have an outlet” (even though you also note it is too big and heavy to actually carry anywhere there are no outlets). They still feel okay tossing up the affiliate links, even though their review nets out to “useless; do not buy.”

I’m just picking on this review because it went by in the news stream last week. There’s much worse.

But man it could also be better. There is so much electronic junk in the world – drop-shipped ripoffs, poorly thought out Kickstarters, parts-bin garbage. There should be less of it. It should not be okay to make something out of plastic and toxic battery components then render it useless in six months.

It’s fine for the Verge to do its journalistic duty by fairly reviewing a bad product and saying it’s bad. It’s correct for the Verge to disclose the existence of affiliate links to better educate people on how they’re incentivized. It would be awesome if the Verge, and sites like it, would go one step further and say “we’re not going to help you buy this thing” when they plainly don’t think the thing is worth buying, and when that thing is going to be turning up in a landfill.

Okay. That’s it for today. This afternoon is spoken for.

I also looked at Monica, an open source PRM. The promising part of Monica is its API. The web UI itself shows comprehensive data for each contact, but does not do anything in the way of bulk editing and has no automation at all. It’s laborious to bootstrap.

In the process of trying to figure out how I could write some automation to move Contacts information beyond the basic vCard fields into Monica I did end up having to learn about how macOS Contacts work and realized you can create custom labels for date fields then add them to your card editing template in Contacts’ preferences.

The data entry widget for these fields expects a date and is tolerant of not entering a year (which helps it support, er, “polite” birthdays). You can, in turn, use it somewhat opaquely in a Contacts smart list: There’s a generic “Date” field you can filter on that looks at date fields in the card. Paired with a “within/not within,” or “in the next” parameter, you can make a smart list of “people not contacted in the past 30 days,” etc.

If Contacts smart lists could also use groups, you could do a lot by just setting a “last contacted” date field and making a set of smart lists based on group membership. Contacts smart lists can’t use groups, though, which is a strange oversight.

As I was trying to figure out, though, how to get my contacts uploaded to Monica in a way that would let me use its API to add tags to them once they were imported, I worked out some AppleScript that let me prepend a contact’s group into its note as a hashtag. Contacts smart lists can filter on the contents of notes.

As a solution goes, it’s in the category of “cheap and cheerful.” If you wanted to use macOS Contacts to keep track of your most recent touchpoint with someone, and drive a little automation to surface contacts you haven’t reached out to in a while, you could do it with one custom field and adopting a simple convention for notes. You’re also well into the territory of things AppleScript can do to help out, too: It is trivial to write scripts that automate logging, etc. or even write reminders or make events in a contacts calendar. In fact, here’s a script that operates on the selected contact and lets you log activity in its note:

set theDate to current date
set noteDate to do shell script "date '+%Y-%m-%d'"
tell application "Contacts"
	set selectedPeople to selection
	repeat with thePerson in selectedPeople
		set customDates to custom dates of thePerson
		set lastContactedExists to false
		repeat with aCustomDate in customDates
			if label of aCustomDate is "last contacted" then
				set value of aCustomDate to theDate
				set lastContactedExists to true
			end if
		end repeat
		if not lastContactedExists then
			if length of customDates > 0 then
				set firstCustomDate to first item of customDates
				set newCustomDate to make new custom date at after firstCustomDate
			else
				make new custom date at end of custom dates of thePerson with properties {label:"last contacted", value:theDate}
			end if
		end if
		set theNote to note of thePerson as string
		if theNote is "missing value" then set theNote to ""
		set prependText to text returned of (display dialog "Enter text to prepend to the note of " & name of thePerson & ":" default answer "" buttons {"Cancel", "OK"} default button "OK" cancel button "Cancel")
		set noteUpdated to "[" & noteDate & "] " & prependText
		if theNote is not "" then set noteUpdated to noteUpdated & return & theNote & return & " " & return
		set note of thePerson to noteUpdated
		save thePerson
	end repeat
end tell

So, looking at that, would you want to glue all this together with Applescript?

I don’t think so. I don’t, anyhow. It just took me a morning to figure that out.

In the process of roughing out automation for creating reminders, for instance, I managed to get Reminders.app to beachball on every run with a simple five-liner. Why? I don’t know. Stack Overflow didn’t know. But after a good 15 years of using AppleScript for jobs large and small, I know that sometimes you find its weird little corner cases and that’s all there is to it. I’d rather tell Jamie Zawinski that I don’t know who the author of XScreensaver is than ask Apple to fix it.

When I ask myself “would I want to build something on top of this ecosystem that I mean to use forever?” I can’t even figure out three scripts I would need to write then get to the end of debugging the second one before I know the answer is “no.”

I mean, what does forever mean? Because my personal belief is that we have to assess the foreverness of the competing candidates, and probably think about how amenable data kept in the least forever of those formats is to being migrated to a more forever format/system:

• macOS Contacts
• org-mode
• vCard
• plain text with moderately elaborate markup amenable to some automated processing

(I put that list in ascending order of longevity/permanence, feeling very appreciative that org-mode allowed me to reorder it with opt arrow).

I trust macOS Contacts a bit. I don’t how much money I would be willing to risk on a series of bets about it working as it does today in 2, 5, or 10 years. While trying to understand my AppleScript options with it I was brought face-to-face with changes to the underlying scripting model several times. In all fairness, those changes played out over decades and it’s only because I’m at a point in life where I can still think “OS X is new” that they even seem mentionable. It’s also completely possible to get Contacts info out into some other format. There’s also just the whole “ramming your head against AppleScript” aspect of the problem.

Moving up the Pyramid of Forever, I trust org-mode to be around for a very long time, but can also see how the API is still subject to change. Functions come and go so automation can break and make it hard to keep a contacts list maintained. On the other hand, I’m not doing much now that couldn’t be done by hand until I figured it out, and the things I’ve bumped into are pretty small so far: changes in the namespace, functional replacements, etc.

Moving on:

I trust the vCard standard to stay how it is a bit more. It’s on … version 3 or 4? … of the spec? There’s a spec. There are a lot of stakeholders interested in that spec. Even Apple quietly crams a whole vCard property into each contact, even if it has its own version of each property you’d find in a vCard anyhow.

So, moving on to the top of the pyramid:

I trust structured plain text to be useful for the rest of my life.

So something built on org-mode seems like the smart play for data longevity? Even if all my automation broke, core org-mode makes it easy to do the things I do: change todo states, add values to the PROPERTIES drawer, add tags, log changes, etc.

The one thing that I’ve mostly decided not to worry about is the disconnect between my contacts list and my org-contacts file.

One useful feature of contacts via Fastmail is the dynamic “Autosaved” group. If I write someone, they go into that group. Periodically moving contacts that surface there into one of my permanent groups then removing them from “Autosaved” provides a simple, organic workflow for keeping up with new people. There is also a bunch of useful automation present in macOS/iOS for surfacing things about contacts from other apps, so you’re constantly being offered the opportunity to pull in new information. This morning, for instance, going through my Contacts list, I noticed that something somewhere in the bowels of macOS or iOS was beginning to notice connections between my contacts and Ivory, the Mastodon client. That’s pretty cool.

On the other hand, this is well within AppleScript’s wheelhouse:

tell application "Contacts"
	set selectedContacts to selection
	if length of selectedContacts is not 1 then
		display alert "Please select exactly one contact."
		return
	end if

	set theContact to first item of selectedContacts

	set theName to name of theContact as text
	set theEmails to value of emails of theContact as text
	set thePhones to value of phones of theContact as text
	set theNote to note of theContact as text

	-- Format the contact data as an org contacts string
	set theContactString to "** " & theName & "
:PROPERTIES:
:EMAIL: " & theEmails & "
:PHONE: " & thePhones & "
:NOTE: " & theNote & "
:NAME: " & theName & "
:END:"

	-- Copy the contact string to the clipboard
	set the clipboard to theContactString
end tell

“Look through new contacts, run that script from a keyboard shortcut, paste the new contact into my contacts.org file.”

I could go one step further and append the text to my contacts.org file, but I don’t like operating on busy files like that.

AppleScript was plainly built to do little things like that. You have to learn its sort of crabbed, verbose way of doing things, but it’s not too hard (and Shortcuts is getting pretty good if you can deal with the sudden drop in functionality that can appear out of nowhere when you hit the limits of some Apple engineer’s imagination or time).

Anyhow, it all just comes down to aesthetics and preferences, right?

I’ve got a draft heading sitting in my blog.org file with a title of “Plain text is calming.” I’m not sure where that little essay is going, but I know where it started: When I’m staring at a text editor I feel much better than when I’m staring at a web or app UI. I might have some challenges with discoverability, or a lack of forgiveness for little slips of the finger, or whatever. But I still feel better because I’ve been a happy citizen of Plaintext Land for over 30 years, and there is a governing mentality there that does not exist in other parts of the technology world. I’m not saying the occasional wheel doesn’t get reinvented, but I am saying that with most plaintext stuff you get to choose your tools, or make them for yourself if there are no good choices. So it’s calming because I don’t have that feeling of always looking for the exit when I encounter a plaintext system. I know it’s there. That’s the preference, anyhow. I made money for a few years being really, really good at turning CMS databases into plaintext and massaging them into other CMSes, so my patience for finding the structure and working with it is high. I don’t worry about where the exit is because in my 40-year history with computers, it has never eluded me in the plaintext world.

The aesthetics are another kettle of fish, and plaintext people run a weird gamut from “text editors are like samurai swords” to “mastery of a plaintext interface is a kind of performance art.” Right now I’m sort of luxuriating in Evil mode, because I finally get the emphasis on ruthless elimination of motion vi engenders. I’ve made terrible fun of people over this in the distant past and feel a little bad about that, but less than two months into this particular experiment, I don’t want to go back. Evil mode is like the end of the first Star Trek movie as far as I’m concerned.

Anyhow, I do want to get back to the whole “plaintext is calming” idea and do some more writing about it. Today’s jaunt into “what if I could make what I wanted in the macOS ecosystem?” was one of those processes I go through when I’ve gone so far with an idea and wonder if I really want to commit – if I’m not making life a little harder on myself than I need to, or if there’s not some simpler way to do it (even if still in the DIY mode,) and the answer came back “don’t think there is.” I’m at home in what I made.

I was scrolling through /r/emacs today and came across someone asking for help configuring GNUS and IMAP. It has been a very long time since I did that, so I had nothing useful to contribute – that config predated me using version control – but I did notice a link to https://useplaintext.email, which intrigued me.

The last time I allowed myself to have a strong opinion about email I was writing a “how we work” for Puppet’s engineering department. The boss and I believed that this was our big shot at putting a lot of email evil to rest – the scourge of top-posting, the blight of replies too widely scoped to too many groups, the simple, everyday harm done by needless reply-alls that add nothing.

It turns out the top-posters won and we just have to live with that.

But there was https://useplaintext.email reminding me of a more innocent time, using the word “harmful” in conjunction with HTML mail, taking one more swing at putting paid to top-posting once and for all.

It also had a list of plaintext email clients that I gave a quick scan, and one jumped out because I’d heard of it but never really gave it a spin: MailMate. It’s a Mac email client, it defaults to plain text but will read and send HTML email (via Markdown formatting on the sending side). It’s also super keyboard-centric. And it has a “bundles” feature that lets you write your own plugins. It comes with a bunch, including one that saves a link to a message in an org-mode file.

I’ve been fiddling around with it today and like it a lot. Besides its plaintext-centricity, keyboard-centricity, and extensibility, I love that you can open up a font picker, select a piece of the interface, and define a font for it. I went through and set everything to Fira Code Retina.

So, what about mu4e? Or mutt? Still on the docket.

mu4e has been bugging me a little because it has a very strange and possessive set of keymappings that collide with Doom Emacs. It hijacks the space key, so my muscle memory around the spacebar as the leader key is all messed up.

mutt remains mutt. I have a lot of affection for it, but its main advantage over anything at all is its customizable keyboard-centric nature, and MailMate has that, too, with less fussing.

And there is something a little weird about running isync on two machines in the house. I mean, theoretically it is no weirder than running two IMAP clients of any kind on two machines in the house. It’s just an IMAP client. But it’s a busy one.

Atomic Chrome/GhostText

There have been a few “use your favorite editor for text areas in your browser” things over the years. Atomic Chrome seems to work very well with GhostText, an extension that works with any of Firefox, Safari, or Chrome. You just install the package in Emacs, and invoke the listener with (atomic-chrome-start-server) somewhere in your init. It listens for the browser extension, which can be invoked with CMD SHIFT k, and opens a buffer for editing.

As I said, this kind of thing has been around for years. The Atomic Chrome/GhostText combination just seems to be reliable in a way I haven’t come across in the past.

org-recur

Scheduling recurrence in org isn’t that bad, but org-recur makes it really simple. It just extends org-mode’s syntax and allows you to add recurrence rules in a heading using notation like |+1|, |Wkdy|, or |1,15|, for “every day,” “every weekday,” and “1st and 15th of every month,” respectively.

Captee

org-capture, like assorted “use your favorite editor everywhere” plugins, is one of those things I know people have had working for a while. I remember having it set up and working a very long time ago, then I lost that config and just forgot how to do it. Captee is a little macOS app that worked pretty much out of the box once I had an emacsclient app set up.

It sits in your Mac share menu and grabs URLs from browsers and browser-adjacent apps then does … stuff … to them. If you want a simple Markdown link, it’ll do that. If you want an org-mode link, it’ll do that, copying both to the clipboard for you. It’ll also work with your org-capture template of choice and send a link + title + selected text to org-mode.

The thing I really like about it is that it works well with my RSS reader, Reeder. I’ve just bound it to C in the share actions list and it saves links/titles to my org-mode inbox.

More on my org PRM

I guess the thing I’ve been calling a plaintext CRM belongs to the “PRM” category (for “personal,” not “customers.”) So, it’s my org PRM now. I’ve been getting real use out of it.

Building it has followed a familiar pattern of feeling a gap, thinking surely someone has filled it, realizing that is not true, then going through the same loop of “maybe this general purpose tool?” and a halting attempt to use it, then a realization that it doesn’t matter how many rounded corners and AJAX transition effects the roach motel has – it’s still a roach motel.

It’s just a bad category I can only assume is as bad as it is because nobody wants to pay for it at the consumer level, and I think nobody wants to pay for it because social media has ushered in an era where we’re all sort of performing the family holiday letter on Facebook every day of the year. And also our “contacts” are all over the place. Every attempt to consolidate them and de-dup them is a minor catastrophe, with your sister-in-law manifesting nine times in the same address book and Siri forgetting where “home” is because something has pulled in your address-free doppelganger.

Anyhow, the thing I built a few weeks ago? I am using it daily:

• Agenda reports that tell me who I haven’t been in touch with, but want to.
• Reminders to schedule time with people or follow up on plans.
• Easy,fast access to past messages from contacts.
• Quick notes about conversations.
• Reminders to ping recruiters.

There are a lot of contact management apps. There are a few apps that will issue general-purpose “AI-driven” reminders to contact people. There’s nothing that feels as easy to use. I tried one that featured a lot of nice automation, but it was iOS only and there was no way to mass-select and tag contacts. Even with my relatively modest list I would have been an hour pecking in tags. With a contacts.org file, it was very fast and simple. There’s not even a smirky “only free if your time is worth nothing” rejoinder, because most of these products are harder to use and take more time to deliver less, or cost astronomical amounts for what they do.

Being plaintext and org-mode/elisp driven, it’s also super easy to extend and modify. If I don’t like a decision I made about how something works, it’s an easy change. With org-mode capture templates, the input is all uniform and structured, so I don’t worry about backing out or moving the content elsewhere. Basically, it’s as calming for me as text ever has been.

Anyhow, I use it daily, I like it a lot, and it feels good to use.

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.

I started trying to cultivate a social maintenance habit with the thought in mind that I had no idea what I was really thinking, just that during this current period it is important to me to keep up social contact in ways large and small. Pretty soon thereafter I realized I had an organizational problem on my hands: My address books were kind of a mess. Not very well organized, old data, a ton of contacts with old work addresses, etc. I spent a day straightening that out and got to a place of mostly clean.

The next problem that presented itself was that “personal CRM” is just an awful software category. Whenever I see a new contact management app, I think “oh, this is surely the one that will let you do something with your existing information, or add useful information,” but it never seems to be. The more competent looking entries in the market cost a lot. Searching yields a lot of “make one in Trello,” “make one in Notion,” etc.

I just stopped thinking about it and decided “do it off the top of your head until something comes up for you.”

So this morning, Al was on her call, and I had a Social Maintenance habit popping up on my agenda as a thing I was supposed to do today, and I’d been reading about org-contacts, org-vcard, and the ways they can integrate with an org-mode agenda to show birthdays or other anniversaries. By a few blocks later I’d thought of how I might wedge CRM-like data into that system with org :PROPERTIES: drawers:

• desired frequency
• date last contacted
• notes on the last contact

This is all stuff you could do in a spreadsheet, and I think a lot of people do it that way. I have an aversion to spreadsheet applications, though.

By the time we were home, I had the beginnings of a plan: Export my macOS address book to a big vcard file, use org-vcard to import it into a contacts file, then start figuring out the mechanics of adding the fields I needed to drive org agenda views.

Getting my contacts into org-contacts

There’s an org-vcard package that theoretically handles the process of moving a vcard file into an org file. The maintainer has announced that they’re not going to work on it any longer, and it seems to have problems with macOS Contacts output.

I put together a script (well, ChatGPT and I put together a script) that parses a VCF file and dumps the contacts out into the right format. I just cat’d its output into the right file. It is probably best described as a menace to your data. I had so recently scrubbed my contacts that I trusted it enough.

An org-contacts record looks like this:

\* Joe Grudd :social:
:PROPERTIES:
:EMAIL: joe@grudd.com
:WEBSITE: http://joe.grudd.com
:CONTACTED: 2023-04-12
:END:

There are a few other fields, like birthday and physical address, too.

On its own, it doesn’t do a ton. You can add notes to a :NOTES: property if you like, and you can search the entire file with an org-contacts command that lists results instead of just doing a normal text search operation.

Tracking contact information

There are a few ways I thought of to come at what I wanted to do, which amounted to:

• Keeping track of whom I’ve had contact with

• Keeping track of when I last had contact with someone

• Keeping track of useful details about people

• Surfacing people I haven’t seen in a while

  The NOTES property in a vcard record is fine, but org-mode provides a way to add a log to each record in its own drawer, which changes the record to look like this:

\* Joe Grudd :social:
:PROPERTIES:
:EMAIL: joe@grudd.com
:WEBSITE: http://joe.grudd.com
:CONTACTED: 2023-04-12
:END:
:LOGBOOK:
  - Note taken on [2023-04-12 Wed 11:16] \\
    Caught up over IM for the first time in a while. He's moving to California next month.
  :END:

org-mode pretties all this stuff up, so the LOGBOOK and PROPERTIES drawers aren’t always visible.

I also added the CONTACTED field to PROPERTIES. It’s just an ISO-8601 date meant to reflect the last time I had some kind of contact, even if it’s just a ping.

So at this point, I could just use this as is and it’d be no worse than a spreadsheet.

Automating updates

I wanted a way to quickly note a contact “touch” so I made a few functions for that:

(defun org-set-contacted-today ()
  "Set the CONTACTED property of the current item to today's date."
  (interactive)
  (org-set-property "CONTACTED" (format-time-string "%Y-%m-%d")))

(defun org-set-contacted-date ()
  "Set the CONTACTED property of the current item to a chosen date."
  (interactive)
  (let ((date (org-read-date nil t nil "Enter the date: ")))
    (org-set-property "CONTACTED" (format-time-string "%Y-%m-%d" date))))

(map! :mode org-mode
      :localleader
      :desc "Set CONTACTED property to today"
      "c t" #'org-set-contacted-today
      "c d" #'org-set-contacted-date
      "c z" #'my/org-remove-todo
                )

Those two allow me to set the CONTACTED property either to today’s date (spc m c t), or by interactively selecting a date (spc m c d). There’s a third mapping that lets me z out the TODO status of a contact (spc m c z), which I will get to.

Agenda customization

Next up, I wanted some kind of agenda automation – custom views that’d let me see contacts overdue for some kind of ping. I made a few driven by a combination of tags and age of the CONTACTED field.

Here’s one of them, driven by a function that finds aged contacts:

(add-to-list 'org-agenda-custom-commands
             '("N" "Professional network last contacted > 90 days ago"
               ((tags "network"
                      ((org-agenda-overriding-header "Network contacts, not contacted in the past 90 days")
                       (org-tags-match-list-sublevels t)
                       (org-agenda-skip-function
                        (lambda ()
                          (unless (org-contacted-more-than-days-ago 90)
                            (or (outline-next-heading)
                                (goto-char (point-max))))))))
                )))

So in Doom, I can tap spc oAN and get a list of contacts tagged with network whom I haven’t had any contact with for more than 90 days.

Setting priority by touch date

I wanted a way to see which contacts were aging and decided to use plain old priorities for that, so a function looks at the difference between today and CONTACTED and prioritizes more aged contacts higher:

(defun my/org-update-priorities-based-on-contacted ()
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (while (re-search-forward "^\\*+ " nil t)
      (let ((contacted-date (org-entry-get (point) "CONTACTED"))
            (today (format-time-string "%Y-%m-%d")))
        (when contacted-date
          (let ((days-ago (- (time-to-days (current-time))
                             (time-to-days (org-time-string-to-time contacted-date))))) ; calculate days since CONTACTED date
            (org-set-property "PRIORITY"
                               (cond
                                ((< days-ago 45) "C")
                                ((< days-ago 90) "B")
                                (t "A")))))))))

It’s connected to a save hook, so every contact’s priority gets recalculated at save:

(add-hook 'after-save-hook
          (lambda ()
            (when (string-equal (buffer-file-name) "~/org/contacts.org")
              (my/org-update-priorities-based-on-contacted ))))