There’s an org-mode bundle for MailMate that works pretty well: You invoke it, it drops an org-mode todo in a given file using the subject for the heading and a link to the MailMate message.

I added a bunch of messages with similar subjects and found it sort of hard to know which was which without opening them, so I made a small patch to the bundle that adds the name of the sender to the org heading. While I was in there, I made it a little easier to find the hardcoded file target and added it to the README instructions.

Here’s the fork, with all credit to Max Andersen, who wrote the original.

(MailMate previously. I ended up buying a license. I could do much of what I do with it with plain old macOS Mail.app, but MailMate is much easier to tune and ends up feeling more personalized.)

more org-gtd

I mentioned being not so happy about my liminal state. It was good to get org-gtd up and running because I was able to quit fussing with how to get everything out of my brain and just concentrate on getting it out of my brain. Therapeutic, even. It didn’t take long to start looking at a little of the other core GTD stuff, adding contexts and “Area of Focus” to all the stuff I got in there. org-gtd has some good agenda views that incorporate areas and contexts.

So, you know, it took a day or two to tour the options and figure things out for the next while and it’s just … good to be using the tool, not thinking about the tool. Which reminds me …

The dysfunctional embrace of Linux and Windows

My friend Ed reminded me a little about tool fixation with this pretty interesting video about the ways Windows’ bad UX infects Linux desktops:

My weird Electra Townie

I have an e-bike and love it for anything further than a couple of miles. Earlyish in lockdown I realized I had more time to get around the neighborhood during the day and went out looking for an acoustic bike. I was hoping for something sort of easygoing – upright ride, plush, didn’t need to be fast. In retrospect, what I was really looking for was some kind of Dutch bike.

Supply chain hell and demand made that tough, but my local Bike Gallery had a sort of weird, niche bike on the floor: An Electra Townie, but more tricked out than they usually are, and on super steep discount. It has front and rear racks, a dynamo hub, disc brakes, and it’s a 27-speed. It’s also sort of tall for a Townie. I just went to the Electra site to make sure I haven’t completely misunderstood what’s “normal” for a Townie. This thing is not normal, and I got it for less than their current cheapest model. I’m assuming it was an experiment in making a “pro” Townie of some kind that failed, so maybe they just dumped existing stock and got back to the simpler baseline.

I love it.

I test-rode a Townie a very long time ago … about the time all the bike manufacturers were in some sort of “nobody bikes anymore” crisis and were coming out with things like the Trek Lime with automatic shifters and relaxed geometries that wouldn’t “intimidate” people. Because I wanted something that could do a nine-mile commute, the Townies and Limes didn’t work for me: The forward-pedaling geometry made it hard to stand up on a hill, and they were geared in a way that made them feel like renting a U-Haul with a throttle governor.

This bike still has the forward-pedaling geometry and the relaxed, swept back handle bars. To get it to fit correctly I did have to move the seat forward more than I have on other bikes, so it seems like a bike that would stop being a good fit for anyone under 5'9" or so, but could accommodate someone around 6'2" or 3. In fact, Ben rode it comfortably and he was easily 6'1" or 6'2" at the time. Combined with the big seat and the inability to really lean forward and bear down, it’s content to live in the middle gears and just sort of roll along.

The built-in lights are probably best used to look for potholes at night, and you should have supplements for visibility. The front rack isn’t huge, but comfortably carries a box of Trader Joe wine. The rear rack is a little weird: It doesn’t seem to be compatible with any of the assorted fitment standards, including the Townie basket we got for Al’s Trek e-bike. But it works fine with an Ortlieb or Banjo Brothers panniers, and there’s always the milk crate treatment.

Oddities and almost-but-not-quite features aside, the thing I love about it is how upright and comfortable the ride is, and how smoothly it rolls on its largish wheels. I have taken it all the way downtown via both the Springwater and Clinton St. (8 and 6.5 miles, respectively) and it has been comfortable. You just can’t try to put too much through the drive train or crank up any hills. You don’t really corner with it: Turns are more like a kind of gliding swoop motion.

So it feels to me more or less like what I imagined the Dutch bike I wanted would feel like. Probably less efficient and more wasted power, but upright and easygoing. When I go around the neighborhood, up to Foster, over to Woodstock, or down the Springwater, it feels more like a sightseeing tour than a commute.

Anyhow, I’ve had it out for the first time in a little while over the past week and was reminded how much I enjoy it.

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 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.