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.

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.

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.

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

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

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

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

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

Dug out my old org-mode config

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

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

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

Anyhow, by making simple configs, like this:

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

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

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

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

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

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

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

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

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

Fixing Doom’s busted leader key in mu4e

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

Yesterday someone on the subreddit finally replied with a recipe:

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

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

Picture taking. I’m not doing it much.

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

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

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

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

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

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

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

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

Nice to have that feeling.

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.

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

Last year I went on a tear around personal knowledge management (PKM). It started with discovering Obsidian and really appreciating its out-of-the-box capabilities. I do think, if Emacs is just more than you can bear the thought of, that Obsidian is an excellent choice for the sort of text-as-organizing-data approach org-mode is simply best at.

That said, its fatal flaw is basically Markdown, which is not meant to bear the load of text as organizing data. You can use it that way, but after … two decades? … of Markdown, we are not conditioned to think of it that way, and any superset of the core emph/strong/link/image markup comes at the expense of its overall feel. I’m not saying it can’t bear more, I’m saying that the more you add, especially when you start getting into multiple characters to do things like wedge in HTML or what’s essentially XML, the more burdensome it becomes and the more unreadable your source text becomes.

Realistically, org-mode has a similar problem: To get the really good stuff out of it you are adding metadata at at least the heading level. The difference is that for the balance of its lifespan it has been like that, and its development is both enhanced and constrained by the fact that it is a creature of Emacs. There are affordances that can hide the worst of the clutter, and the inline formatting syntax is not much more verbose than Markdown when it is at all. Deciding to use org-mode is not a “buy the ticket, take the ride” proposition. You bought the ticket when you edited your init.el the first time, and org-mode is just part of the ride.

Anyhow, You can’t really get into Obsidian without being exposed to the whole Zettelkasten thing. It led me to Sönke Ahrens’ How to Take Smart Notes, a small book about how to build a Zettelkasten system and what to do with it, and I found that book very compelling.

When I contextualize my reaction to it, I’m going to own a few things up front:

• Like a lot of people, I was in the process of climbing out of a few years of lockdown, isolation, and anxiety. I had a certain kind of mental energy that was very inward-focused.
• I had a strong sense that my job was not going to be long for this world, but was just beginning to get some traction on things that mattered to me, so that energy was searching for an outlet.
• I had a few ideas for projects that I’d shelved for a period, but I was beginning to think that I needed to get going on them as part of my preparation for either being displaced or hitting the job market.

So I was primed for the Zettelkasten pitch.

But I’ve also been a sort of tech/nerd-adjacent type for decades, and was around during the heyday of GTD, 43 Folders, “lifehacks” before “lifehack” meant “refrigerate bologna and you won’t get sick eating it!” or “don’t run up the balance on your credit cards!”, and all the other productivity manias that blew through. This is me in 2005:

Sometimes I read a comment from someone who insists that his routine involves some insanely arcane and convoluted use of yarn and a special shell script he whipped up that reads crap down from his Backpack account and then squirts it into his Palm, makes a redundant backup on the server he maintains in Malaysia and produces printed 3x5 copies in triplicate, one of which he pins to his infant son’s sleeve before leaving for the morning (“If I died, I couldn’t live with him thinking his father went out the door without an action list and a plan!”).

… and me again in 2007:

While looking around for some info on “Getting Things Done” so I could share a summary, I came across:

“Allen says his martial arts background helped him appreciate the value of eliminating distractions.

“‘If four people jump out at you in a dark alley, you don’t want to be thinking about two e-mails you haven’t answered,’ he said.

Fending Off Four People - A Plan

@street, by alley

• run down street flapping arms and yelling for help (?) (save breath by not yelling?)
• run into nearby store? (make “nearby store” context?)
• make Bruce Lee noises to see if that works then run? (split into two actions? or is that too much?)
• prioritize possible ambush choices … by absolute order or relative priority? (make note: plan this ahead of time for future – someday)
• make folder and list for “@street” context … hasn’t come up before
• muggers in @mugger agenda list or defer due to one-time nature of encounter?
• followup – could I have run faster or yelled louder?

Basically, I guess, there is a part of me that reads these things as largely aspirational (which is fine), but also very hung up on the idea that we are one special system or weird trick away from realizing our greatness (perhaps naive, but also fine), and that once we’ve mastered it we will finally become productive (which is fine(ish?) to the extent it means “does enough work to keep job” but is terrible when such a mushy word becomes a proxy for human worth).

How to Take Smart Notes hits all those aspirational notes, recounting the remarkable tale of Niklas Luhmann and his astounding lifetime run of 60+ books and hundreds of articles. It’s an inspiring story, and I’m going to grant one point for sure: If one choice is to be inspired by a prolific academic who expanded the sum of human knowledge with his little slipbox, and the other choice is to be inspired by someone whose productivity system is self-evidently great because he has used it to organize a small empire of retail productivity enhancement books and accessories, I’m goin’ with the perfesser over there.

So I tossed myself into Zettelkasten-via-Obsidian. I had a few things I wanted to work on, I had years of material in different formats that needed to be atomized, and I was reading two or three books a week, plus dozens of articles. Like I said, I had a ton of nervous energy to displace because a ten-year run was about to end, and the last time I’d felt thrown out of the nest my comfort zone was “crabby, introverted autodidact.”

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’s not to say I can hold every consideration of a writing project in my head. I benefit greatly, for instance, from the whole project notes thing that integrates magit and Projectile: I have an org-capture template that adds a note to a todo file in the top level of a given project (read: “repo”) linked to the parent heading. If I’m out and about and think about something material to my writing project, I put it in my inbox. It’s a vestige of GTD and the idea of a trusted system. I just don’t think it will help me in a mugging, and the way I write, share experience, and organize my thinking isn’t amenable to the atomicity of Zettelkasten.

Maybe I could have gotten there! I believe other people who say it helps them! I understand the gentle pull of tending a little digital garden! I just don’t think organizing knowledge is my particular life struggle, and I do not think getting better at it will be a huge life enhancer.

So, all that said, I really appreciated this post (somewhat) about org-super-links, which describes how you can get automatic back-linking into your org-mode headings. Even though Zettelkasten isn’t for me, I did come to appreciate automatic back-linking in Obsidian (and my brief excursion into org-roam).

Spring is here, so time to take Lou out

“Lou” is my Yamaha TW200, a little farm bike I bought as a compromise between the tiny and “bounce it between your thighs at stop lights” Honda Grom and the bulkier, vaguely miserable Royal Enfield Himalayan 400. “Vaguely miserable” because mine was a victim of a bunch of factory QA problems that left me feeling like I could never really trust it during break-in.

It is meaningful to me that when the tender cable for my Grom came undone and I didn’t notice it for six months the Grom had so little in the way of parasitic drain that the battery still had life when I got back to it. The Himalayan? It needs to be on a tender 24/7, and never off one and parked for more than maaaaaybe two weeks at a time. It’s just like that, and who knows, and the dealer I bought it from shook the whole issue off with “that’s how this price point is,” which helped me clarify why a Harley dealer was selling Indian-made motorcycles to begin with: You walk in, run over to that Harley, surreptitiously glance at the price tag, realize you’re in over your head but cannot abide the thought of not riding your new bike off the lot on that particular sunny Saturday afternoon, so maybe that Royal Enfield that looks sort of classic will do the trick, for about as much as the down-payment on your Harley was gonna be.

I mean, I went in wanting to buy mine up front. I’d read good reviews, liked the looks, and wanted something of about that displacement and size. The QA stuff, though, is miserable. It took two goes just to figure out that the bleed lines from the fuel tank were tied too tightly to the frame, creating a vacuum that constantly caused stalls. The dealership was plainly sick of my face before I could even get 500 miles on it, and it lives in this weird space where it is too big and not powerful enough. If anyone asked me today, and if they were not interested in the “adventure” pedigree, I’d tell them anything but an RE Himalayan. A Rebel 300 would probably out-perform it, and my TW200, at half the displacement, comes pretty close without having to wrestle the bulk.

Anyhow, Lou is my Yamaha TW200 and I love it. Fat tires, low-slung, pleasant, low rumble. It is simple and sturdy and it is the perfect bike for SE Portland’s pothole alleys and torn-up 82nd Ave. It goes just enough to hold its own for a ride up to Sauvie Island or maybe the back way out to Estacada. It’s a great in-city commuter.

This week it was finally warm enough and dry enough to start Lou up for the first time this spring.

TW200’s (t-dubs) are notoriously cold-blooded, so it didn’t want to go. I dumped some fuel treatment in and shot some starter spray in its intake and it turned over. I let it sit on high choke for a while, then turned it off, rinsed, repeated an hour later and then took it up the side of Mt. Scott. It was still sounding a tiny bit uneven while it ran the old fuel through, but the two runs since it has sounded smooth and healthy, and it turns over right away.

I love it.

Al’s still up in the air about finishing up her motorcycle endorsement, so we have the TW200 and the Grom sitting here. If she decides nothing doing on motorcycling, I’ll find the Grom a home and consider something that can handle two-up a little more gracefully. We enjoy summer date nights on a motorcycle, and the TW200 isn’t quite up to that.

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

And because I’ve chosen to treat org-contacts as TODO items for purposes of remembering who to PING, FOLLOWUP, SKED, etc. it has to take the extra step of stripping those keywords from the returned name. Otherwise, my mails to Joe Grudd would be addressed to FOLLOWUP Joe Grudd.

That’s a small bit of inelegance in my plaintext CRM setup: As I’ve figured out more about how org-super-agenda works, I’ve had glimpses of how the plaintext CRM metadata could just be content in the :PROPERTIES: drawer, and hence invisible for purposes of tools like this, but a few other pieces of passive automation would have to become some sort of org-mode hook and I’d lose the utility of tools like Beorg, which can’t provide the automation of native Emacs.

For now, it’s one of those “this design isn’t the cleanest, but it’s simple and only creates a few easily solved problems” things.

Here’s the script itself. I put it in ~/bin as orgcontact.rb:

#!/usr/bin/env ruby

# Get the query string
query = ARGV[0]

# Set the path to your Org-contacts file
orgmodefile = "#{ENV['HOME']}/org/contacts.org"

# Read in the whole contact file
raw_contacts = File.read(orgmodefile).split("\n** ")

# Iterate through each contact
raw_contacts.each do |contact|
  if contact.match?(/#{query}/i)
    # Extract the name and email from the contact
    name = contact[/^[^\n]*/].gsub(/(PING|INVITE|WRITE|PINGED|FOLLOWUP|SKED|NOTES|SCHEDULED|TIMEOUT|OK)\s+/i, "").strip
    email = contact[/:EMAIL:\s+(.*)$/, 1]
    # Remove tags from the name
    name.gsub!(/:\S+:/, '')
    puts "#{email}\t#{name}\t(org-contacts)" if name && email
  end
end

Adding m_org_contacts to the METHODS setting then including a little wrapper in ~/.lbdbrc doesn’t follow the canonical advice on how to configure an lbdb backend, but it works, and it’s one less file to put somewhere:

METHODS="m_osx_addressbook m_org_contacts"
MODULES_PATH="$MODULES_PATH $HOME/bin/lbdb"

m_org_contacts_query() {
   ~/bin/orgcontact.rb "$1"
}

So, the outcome is just:

1. Start a new message in mutt and start typing the name/address/etc.

2. lbdb provides a list of matches from a few sources I’ve set up: org-contacts and macOS address book

3. ENTER to select a candidate

   b

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

That prioritization shows up in the agenda views I set up, with [A] priority contacts getting their own section.

Custom TODO states

Finally, I wanted a way to keep track of where a given contact is, or cue myself on next steps, so I set up custom TODO states just for my contacts.org file:

#+TODO: PING(p) PINGED(P!) FOLLOWUP(f) SKED(s) | TIMEOUT(t) OK(o)

By putting a ! inside the shortcut parens, org-mode will automatically log changes in and out of those states. For now I just have PINGED wired up that way, and TIMEOUT and OK, as DONE equivalents will similarly trigger a log entry.

FOLLOWUP and SKED are there as reminders that I need to do something next. TIMEOUT is a way to tell myself I gave it a shot and nothing came of it. OK is just an interim state on the way to no state until the agenda surfaces someone again.

The logging for these state changes looks like this in a given contact entry:

\* PINGED Joe Grudd :social:
:PROPERTIES:
:EMAIL: joe@grudd.com
:WEBSITE: http://joe.grudd.com
:CONTACTED: 2023-04-12
:END:
:LOGBOOK:
- State "PINGED"     from "PING"   [2023-04-11 Tue 20:21]
- Note taken on [2023-04-12 Wed 11:16] \\
  Caught up over text for the first time in a while. He's moving to California next month.
:END:

This is also where that last “z” keybinding comes in:

(defun my/org-remove-todo ()
  (interactive)
  (org-set-property "TODO" ""))

With spc m c z I can zero out the TODO state of a given contact without triggering a log entry, keeping a little bit of noise down.

What else?

That’s the system. I guess the summary is:

“I’ve used org-contacts to keep my contacts in a plaintext file. By using existing data features and agenda customizations, I get prompts that will help me cultivate my Social Maintenance habit when it’s due. With a few custom functions and a save hook, I can use light automation to make the text more dynamic without a lot of day-to-day effort.”

And I’m a little more clear on what “social maintenance” can mean, now. I think I’d created an ill-defined monster the longer I let it sit there with no shape. As I put this together I got to think about what would be meaningful, and I realized it just makes my day when I get a text from someone asking how it’s going, so that’s a fine standard to apply.

And yes, it was an interesting ChatGPT exercise. It would have taken me days to suss all this out on my own. I just don’t have the elisp. It took much less time just dialoging with the bot, and it let me work much more iteratively if an idea didn’t test quite right. I wonder how this would have gone if I’d thought of trying it when I was using Obsidian a lot, or if I’d been in more of a Rails or Sinatra mood.

I think the whole thing will seem like overkill to some, but I am not good at keeping up with people. I am not going to go all autobiographical to explain it, I’m just gonna say that there is what I want to do and there is what I do, and they aren’t aligned, and I know enough about myself to know that in the absence of a supporting system my good intentions will not mean anything.

And I’ve had a few recent interactions with people I haven’t spoken to in a long time. It feels really good to reconnect, even if it’s just a few lines of “what’s up with you?” So I’ve built a system to help me get more of that.

I tried out org-superagenda a while back. It improves on the vanilla org agenda by creating customizable sections, which help it scan a little better. I bounced off of it because while I wanted the quality of life improvements it offered, I was struggling a little with the syntax, and was caught up in that brainspace you can get into where you just want the thing to work and it’s throwing off your sense of time and perception of the required investment to make it work.

This morning I was looking at my agenda and hating it because it was in a “mostly correct except where it is glaringly incorrect” state, so I figured it’d be a good practical task to throw at ChatGPT:

Describe an orgmode super agenda configuration that shows habits, important items, overdue items, and items due in the near future

I got a copy-pastable example that met the requirements.

Could you add items due today to that list

Yep. That worked.

could you move the today list to second place and add a list at the bottom of unscheduled todo items

That response worked well, too. It does a decent job of explaining what each piece of the solution does.

Using the org agenda

Figuring out the org agenda has been key to how I use the tool.

With a good agenda setup I can feel pretty on top of things. When it’s broken I know there are things out there in my file collection that I’m not going to see. As I’ve leaned into org capture, that’s become even more true, because capture buffers keep you out of the file you’re adding something to: You don’t see the other things in there because you don’t go past them to get to where you’re adding new content.

Besides surfacing stuff, the agenda is also the nerve center. You can do basic scheduling and status changes from it, and maybe even more importantly for a sense of organizational calm, you can refile from it. So rather than visiting each file to find stuff and move it around, you can see it all from the agenda overview and refile it from there.

With a restored agenda, I made the connection between my literate Emacs config and all the other stuff flying around in my org mode ecosystem: Links I gathered about configuration tweaks or things I’d like to try can more easily go into a literate config file, so I made an “Ideas” heading at the bottom of the file and started refiling my the Emacs-related things in my agenda’s inbox into my config.org file.

People love hooking into org, too, so even things that started life without org mode in mind can pick up org affinities. The pinboard mode I adopted, for instance, doesn’t natively use org’s link storing function when copying a link, but someone wrote a function to do that. Now I can retrieve a link and add it to a post without taking my hands off the keyboard or switching contexts.

Which reminds me …

I discovered winner-mode today.

It’s annoying when an Emacs mode splits the window into frames, then leaves two frames behind when I quit it. winner-mode “records the changes in the window configuration (i.e., how the frames are partitioned into windows), so that you can undo them.” It’s useful to me because I want to use pinboard-mode as a link retrieval tool for blogging. Once I’ve grabbed the link, I just want to tap q and get back to my blog buffer, not find myself with a split window. winner-mode closes the pinboard buffer, then removes the frame, and I’m back where I left off, able to add my link and keep typing.

Custom Doom keybindings

I’ve been digging Doom’s modal interface, and waiting around for a reason to extend it. Yesterday’s addition of pinboard.el finally gave me an excuse, since Doom was killing its keybindings out of the box.

The p prefix in Doom’s menu system is already occupied by projectile, so I used P:

(map! :leader
      (:prefix-map ("P" . "Pinboard")
        :desc "open Pinboard" "p" #'pinboard
        :desc "open current link" "o" #'pinboard-open
        :desc "copy org link" "l" #'org-store-link
        :desc "edit link" "e" #'pinboard-edit
        :desc "copy URL" "c" #'pinboard-kill-url
        )))

So spc Pp will open the pinboard buffer (or switch to it), spc Po will open a given link, spc Pl will store an org link (for retrieval via spc mll), etc. etc.

One thing I’m struggling with here is a vagary of Doom as an environment. The logical place for all of that is in the bindings.el file, but the bindings don’t “take” when I put them there. They do when I put them in config.el. The docs weren’t super helpful in debugging that, and the things that look syntactically intuitive didn’t seem to solve the problem.

It’s no big deal, and I’d rather just have all of that stuff travel together with the mode it addresses, anyhow, but it’s a thing I Do Not Understand About the Environment except at a very vague “well, there’s a lot of lazy loading going on to keep things fast” level, and it’s going to bother me.

I should just add an INSOMNIA state to my TODO lists and save it for the next “welp, it’s 3 a.m. and I might as well screw around with this problem” session.

Yellowjackets again

Well, we finished the first season last night.

• Standalone season score: 8
• Prospects for the future score: 5

Basically, my “endless puzzlebox” antennae are quivering.

The season all on its own was gripping and kept our interest. I felt invested in the characters and whatever they were dealing with. I love the way it walks right up to the Mandy line a few times. It has a dark sense of humor but it’s not mean.

The 2 missing points for the standalone season score are because it had some minor pacing/bog-down stuff in the middle, and because some stuff going on just felt like gratuitous puzzlebox misdirection. It felt at times like it was written too self-consciously aware of recap culture and a certain kind of mock-obsessive over-read/over-think that comes along with that.

The “prospects for the future” score is a function of how I felt as the credits rolled on the season ender, and it honestly wasn’t great. The episode didn’t feel energetic, it suggested an appetite for “surprise reversal” that will exceed my patience over the long haul, and it reminded a bit too much of the first couple of seasons of HBO’s Servant, which I abandoned with no remorse at the end of the second season.

I feel a little bad about my reaction, because maybe I’m suggesting that television productions should simply abandon the only tools they have to get more seasons. In some ways, they have to pander to recap culture. They have to pander to fannish over-analysis. They have to end each season with a hook and a sense of incompleteness. They have to live within a fickle system run by people addicted to the analytics streaming affords, who will happily kill a property and move on to the next with no sense of investment.

But, you know, don’t point out a problem without pointing out a solution:

For All Mankind (Al prefers to think of it as Space is Trying to Murder You Again This Week) does a nice job with this conundrum: Each season has an arc and a sense of conclusion. There’s payoff. Then it does an end-credits thing where it flash-forwards to the next season’s era and offers you a look. It doesn’t appeal to your thwarted expectations of closure, it appeals to your curiosity.

And to make note of a counterpoint, Succession isn’t above leaving things on a hanging note of tension, but I’ve stuck with it. It’s not terrible to leave things unresolved, or end a season with a directional cue in the form of an unfinished arc. Maybe the thing I’m reacting to with the puzzlebox stuff is the garish palette those shows paint with, swinging for the meme fences.

Anyhow, we have a few episodes of Yellowjackets season 2 cued up. The prospect of watching them, having skimmed a few episode descriptions in Plex, is not sparking a “full-body yes.” There’s just so much other stuff out there that I’m okay with the thought of letting it have its run then deciding whether it’s worth it to watch through the whole thing.

That has always helped me feel a little in control, at least.

I noticed Doom Emacs has a literate module in its init.el, so I did some reading. The very high level summary is that Doom lets you use literate programming principles via org-mode to build your config.el file from an org file:

• You enclose your actual configuration code in src blocks:

#+begin_src emacs-lisp
(setq doom-font (font-spec :family "Fira Code Retina" :size 14 )
      doom-variable-pitch-font (font-spec :family "Fira Sans" :size 13))
#+end_src

… and those blocks are “tangled” into a config.el file.

You get to use all of org-mode’s affordances for document structure, so you can add headings, and your comments can just be prose:

** Base Appearance

*** Line spacing 

#+begin_src emacs-lisp
(setq-default line-spacing 0.5)
#+end_src

*** Font Settings

#+begin_src emacs-lisp
(setq doom-font (font-spec :family "Fira Code Retina" :size 14 )
      doom-variable-pitch-font (font-spec :family "Fira Sans" :size 13))
#+end_src

So this morning I moved my still-pretty-simple config.el into config.org to see what I thought.

It’s pretty cool!

The traditional ugliness of Emacs configs, for me, has always been the slow drift out of organization. Maybe for a while all the UI stuff, personalization stuff, appearance stuff is traveling together, but something makes its way in at the bottom of the file, then something else, and you’re left with a bunch of things that aren’t near their logical neighbors. There are the things you comment out that just become a big chunk of … something … it’s hard to read because they aren’t syntax highlighted anymore. There’s verbose documentation that makes it hard to scan. etc.

Literate config in Emacs allows you to bring semantically meaningful structure to the configuration file: Broad categories of options can go under headings, commentary is written as prose, and you can use all of org mode’s structure editing tools to quickly move chunks of configuration around into a more readable, logical order.

Doom’s default config.el comes with a ton of comments. I’m glad they’re there when I need them, I hate having to scroll through and past them. Moving everything into config.org let me just move the comments into a Docs heading for each section, so they stay folded away unless I need them.

I’ve got a few chunks of config that need some work. I can research how to use a given module, toss in reference links and sample snippets, and only allow certain code blocks to be compiled into my final config.el.

And I can also evaluate a src block by hitting enter on the last line of the block, so if you’re in an iterative mode, trying things out and testing them, it’s a few keystrokes less to make sure something evaluates cleanly, returns the value I was hoping for, etc.

I’ve known about literate programming in the context of org for a while. A very long while ago, when I was first playing around with web analytics reporting, I had some simple code blocks embedded in an org file that allowed me to pull basic website numbers into my org file by getting the output of a script. That could all then be exported into a status report. It was cool but also trivial. It didn’t feel like a huge quality of life improvement. This feels like something that, with very little time spent getting it into basic shape, will be more maintainable over time. It’s easy to see where to insert something in the document, so things are more likely to stay organized, and it’s easy to test.

It was very little work to set up in the Doom Emacs context:

1. I enabled the functionality in init.el by uncommenting literate
2. I copied my config.el file into config.org wholesale.
3. I put every config stanza under a level 2 heading to start.
4. Short (5 lines or fewer) comments became leading prose blocks.
5. Long comments went into level 3 Docs subheads.
6. I collapsed my view to headings only and moved everything related to each other into proximity of each other with org’s section up/down keys.
7. I added top-level headings for basic config, my more extensive org mode stuff, and utility functions.

I’m still building up my Doom config, so it didn’t take long. Maybe 15 minutes to get to something much more easy to scan:

Sitting here thinking about it, I guess it reminds me a little of the first time I sat down and wrote a real Puppet manifest for a real purpose and not a “how does this thing work?” purpose. It felt like clarity was emerging from the writing process.

Seems like a keeper.

Well, it took less than 12 hours to go from “I’m not going to even touch that” to “huh, I wonder if it’s cool?”

Yes, org-roam is cool. It’s a Zettelkasten implementation built atop org-mode. To make it work in Doom Emacs you just add it to the org-mode line in Doom’s init.el:

(org +roam2) 

… and then run doom sync.

You should add a roam subdir to your standard org files location or it will complain when you try to use it.

You can instantiate a new node with spc n r i (’n’otes, ‘r’oam, ‘i’nsert)

That gets you a roam buffer and you can start typing. As with most transient Emacs buffers, C-c will save and exit.

If you want to link to a separate note, you can start typing its name in the body of the current note and get an autocomplete list.

If you link to a note from another note, Roam takes care of adding a backlink at the bottom of the target note.

As with all things Emacs, there are org-roam configs you can go find on the street and stick in your mouth. As with all things Emacs, I didn’t describe it that way because I thought that would make such an approach attractive to you. I want you to be repulsed by that approach because it is unclean. One of the advantages of Doom Emacs (or Spacemacs, or Prelude) is that if they include a package, they probably include some basic configuration, so you can kick the tires then start layering on capabilities.

Anyhow, in its basic Doom Emacs config, org-roam is unremarkable. If you want a zettel and don’t want Emacs, go get Obsidian or one of its competitors. I’m going to stick with it for a while. As I mentioned yesterday, I like org-mode’s intertwingling of tasks/actions/todos and prose, so it suits me.

The pleasures of a straight razor competently wielded

A brief history of me and professional grooming:

• My grandmother paid for my first stylist haircut when I was in 7th grade. I had no idea how to maintain it.
• I spent a few years just telling barbers to take it all off.
• The army taught me the pleasures of walking in, paying your $5, and getting a high-and-tight. Once I’d been in a few years, I’d modify the request to say “leave a little up top.”
• Over the past 20 years I developed an appreciation for Great Clips because they store your preferences and last cut in the computer under your phone number.

Then last year I walked into a barber shop near the office because things were dire and I had a few minutes. The barber handled the basic cut, then offered to do some detail work with a straight razor since he had time. That part was amazing, and it made my day.

I started going back, partially because it was a great first experience and partly because the barber was utterly disinterested in small talk. Just enough to establish we spoke a common tongue, then nothing except the occasional request for a decision. We did enter into an extended dialog about my beard made up of very sharp exchanges in the ensuing months. He was in favor of taking more of it off, and I would say “no, I’m not there yet, please just do what you can with it.” He’d mutter and then cluck when he got to the part where it began to curl at the bottom. “I can’t do anything with this … you’re sure you’re okay?”

Then last week I had a video conference and was wearing a shirt with a collar and a jacket and I realized I couldn’t see my collar under my beard. I couldn’t really see my mouth, either.

I recently read about a study that suggested people with beards will ultimately be perceived as more trustworthy and accessible once they are given an opportunity to smile. Until that point, the unbearded have all the social advantages. So I decided it might be best to make my mouth observable. COVID and masking did reveal me to be a proficient eyebrow flasher, but I don’t think you can completely rely on that.

So I booked time with my barber and left out the haircut (I’m good for a few more weeks) but did add the razor true-up.

When I sat down he resignedly asked “the usual, just fix the scruff?” and I said “no, I’d like to get some of that length and volume out of there.” He started to nod vigorously, and we entered into an extended negotiation measured in finger widths (“okay, but top of finger or bottom?”) and ultimately settled on something that would both reveal my mouth and also let you see my neck and/or collar.

Then it was just closing my eyes and enjoying the hot towel, thick lather, and precision work of a sharp straight razor, including temples and neck.

Restorative.

I go all the way across town – the barber moved from near the office to even further west – but it’s worth the train ride once a month to have a good barber.

Movie: Decline of Western Civilization

I rewatched Penelope Spheeris’ Decline of Western Civilization for the umpteenth time. X is one of my top 5 favorite bands of all time, so I love everything with them in it, even if John Doe’s trolling over “Johnny Hit and Run Pauline” makes me cringer harde with every viewing. The people around the periphery are great, too, including Club 88’s owner, who is determined to greet the whole freak show playing out in his venue with a certain patient equanimity I hope I can equal as the world moves on around me. And I’m grimly fascinated with Fear, and Lee Ving in particular, and his theatrical hate.

Punk was the first real subgenre I embraced. I was up at 2 in the morning in 10th grade, working on a paper for my journalism class, when the college radio station I’d been listening to jazz on hours earlier suddenly crackled back to life from its post-midnight-signoff hiss because someone had snuck into the studio and announced the first (and possibly last) installment of “Goshen College’s Guts Radio.”

Then they peeled my skull back with Fear, Black Flag, Dead Kennedys, and stuff I never heard again.

I mentioned it to the stoner who sat in front of me in American History and he came back the next day with the Dead Boys’ Young, Loud and Snotty on one side of a cassette tape, and a hastily assembled tour of more vintage punk on the other.

Anyhow, Decline: X are the odd ones out there. A punk act, yes, but with the seeds of their eventual trajectory present if you look for them. The case has been made that they were a case of tragic mistiming and I think it might be true: There they were at the height of their energy in 1980, but the sensibility they anticipated was years away from the eventual saturation it achieved with vintage scavengers and billy boys. My affection for X is undying: They were my bridge from a sullen, resentful anger toward all the normal people to a belief that maybe I was one of the decent people, too.

Reasonable default configurations have been a pleasure of [Doom Emacs][]. Even org-mode, which I had somewhat dialed in on my own, works well enough, and maybe better, under Doom. When I took my org-conf.el apart I realized how many geological layers of features that sounded interesting but never made their way into regular use were sitting there, gumming things up and slowing things down.

I posted last night about a nicely wired up Projectile/org-mode pairing:

Whenever I get bit by the org-mode bug, the first thing I notice and remember loving is the intertwining of text and tasks. Sitting down and making lists in an app has never felt completely comfortable to me, and the notes capabilities of a lot of task apps leave me cold. They look and feel like afterthoughts, and the text is dead and inert inside them. Once the task is done, the text is effectively gone unless you take time to pull it out and put it somewhere.

When your todos and text are happening on equal footing with each other, your “todo list” stops being a todo list and starts being a sort of log or journal. Structure your notes correctly within todos, and org-mode makes it easy to copy them into another file or hierarchy, or you can just leave them in place and keep moving.

Preparing for a meeting this week, I loved sketching in the things I needed to cover as headings that happened to be todos, then launching straight into notes underneath those headings, roughing in initial thoughts or leaving myself prompts without clicking into a cramped little box.

I loved org-mode when I worked in a status report work culture because my weekly report was also my todo list. I wrote an exporter that kept out the stuff nobody else cared about, but showed the most recent log entry in each item. As priorities shifted, my status report was always up to date. As I wrote each week’s update, I could see the previous week’s just below it in the item drawer. Items that were delegated, on hold, or dropped, reflected reality at the moment of export. Attempts to do similar with other tools never came close, no matter how robust their scripting libraries.

So, having an Emacs distro that feels very solid underfoot and presents a clean, useful, uncluttered org configuration is a real joy.

I am also enjoying Beorg, an iOS/iPadOS app that works well with org-mode, syncing via iCloud, Dropbox, WebDAV, or Box. It tilts toward the todo/agenda-oriented parts of the org-mode experience, but you can edit your prose notes with it in a pinch. It can also integrate with iOS Reminders and Calendar apps, so your agenda view can reflect your org stuff and your phone stuff if you have to live in a split ecosystem for things like shopping lists. It’s not a completely seamless experience, but it is smooth and works well.

And the whole experience reminds me that, speaking only for myself, as much as I think it’s possible to get work done on an iPad, I can’t get it done as well as I can on a laptop or desktop machine.

C25K phone app

“Try to get more exercise” has found its way onto the medical agenda, so I am trying to get more exercise. My routine over the past couple of years has involved 3 or 4 miles of walking most weekdays, and upwards of 6 or 8 on weekends. That has served me pretty well, but after a few experiments and some measuring, it’s pretty clear that 30 minutes of running every other day is helping even more.

Couch to 5k has been my go-to “get back into running” program over the years. It’s a slow ramp – slower than I’d like some days. When I compare how well I’ve kept up a running habit (and kept feeling healthy) ramping myself up vs. sticking to C25K, it’s clear I do better letting myself be held back a little.

When I first did C25K I did it using a Timex Ironman and watching the stopwatch. That wasn’t great because it kept me from just going to my running place. In early smartphone days I was happy to use an app, but wow was iOS terrible for that kind of thing back then: Music never coming back after a voice prompt, bad UI ideas, etc.

I’d always hoped Apple Watch would address it, but for a few years it was even worse, and I went through a series of hacks and workarounds, but was resigned to just keeping my phone on me for runs.

This time around it seems Apple Watch is finally mature enough to support a standalone C25K app in the form of WatchTo5K. It’s part of a crowded field, and there may be others that work just fine, but WatchTo5K had decent reviews and has gotten me through three weeks so far with no complaints. It just works, it’s simple, and it talks to Apple Health so I can correlate runs with a few other biometrics.

The only other wrinkle isn’t a big deal: I run in a park across the street from my house, so the watch is constantly picking up then dropping my Wi-Fi network. Even though my running playlist is downloaded to the watch, it causes the music to stutter every time I run back out of range. Putting the watch in airplane mode addresses that.

It’s pretty nice to just put on my watch and Beats Fit Pros, start my playlist, start the app, and start running, with nothing else to think about or fiddle with for the next 30 minutes.

Custom Hugo RSS

I made a small tweak to my site’s RSS feed, adding a shortcode to list the tags for each post and adding it to each entry’s description. It’s a small adaptation to reflect the ways I use my feed to cross-post to Mastodon and Twitter. Mastodon is especially on my mind, given that tags are what drives discovery. For my daily posts it’ll be a little redundant and I guess I could build some logic in to handle that, but not today.

Here’s the shortcode (rss_tags.html):

{{- $tags := .Language.Params.Taxonomies.tag | default "tags" }}
{{- range ($.GetTerms $tags) }}
  #{{ .LinkTitle }}
{- end }}

… and here’s the tutorial I used to figure out how to customize the feed. It just involved changing the description element:

<description>{{ .Summary | html }} <br />
  {{ partial "rss_tags.html" . }}
</description>

It works like this:

It is not controversial to assert that Emacs is an environment all its own. You can find libraries and packages that allow Emacs to acknowledge and talk to outside environments, so it’s not a closed environment, but it’s different enough that there’s some fiddling involved to get it chatting with the outside world.

The iPhone could also be considered an environment all its own, but it’s an environment built with an eye on a broader context. iPhones have a pretty easy time doing things like talking to iCal or Outlook with a few button clicks, for instance. Now, unlike Emacs, there’s a point with the iPhone where no amount of grunting or straining will matter, and if you want it to talk to something else nobody else has bothered to make it talk to, there’s an SDK you can download.

All that said, when Emacs and iPhone can both respond to a particular requirement with “there’s an [app | elisp package] for that,” the iPhone variation will usually involve a quick download and three or four fields in a configuration screen, tops.

When I got an iPhone, I was a pretty heavy Emacs org mode user. The smartphone I had prior to the iPhone was a BlackBerry, and the BlackBerry never really talked to my Mac on any useful level: lost contacts, extra contacts, a new contact for every phone number I had listed for what had once been a single contact, crummy calendar syncing, forget about bookmarks syncing, etc. etc. etc. Because the BlackBerry sucked for me as a Mac user, and because iCal was anemic when it came to todos, org mode was able to fend off everything.

I won’t go into a lot of detail about org mode except to say that it’s neat. You just open a “.org” file in Emacs and start typing using a pretty simple notation. For instance …

* PracNet

** TODO Look at reviews: can we get user information to the front page? (ASP)

   DEADLINE:

** TODO Look at inside pages: make a toolkit for callouts that can fit into the CSS

   DEADLINE:

When that text appears in an Emacs buffer in org mode, it’s nicely color coded. A few keystrokes make it easy to cycle between “TODO” and “DONE” or some other status.

As with all things Emacs, it’s very customizable.

Then the iPhone came along and promised me that if I would accept a few small tradeoffs, it would sync up with a lot more of my stuff: bookmarks, addresses, e-mail, etc. etc. etc. I’d have all that stuff in my pocket, and when I returned home my Mac would automagically commune with it to learn what had changed in my absence.

org mode fell by the wayside, and the little ecosystem I’d created within Emacs crumbled because it was no longer a place to live … just a place to visit when I needed to push text around.

So MobileOrg strikes me as fascinating and horrifying at the same time. All it does is this:

You save your Emacs org mode files on a WebDAV server, load MobileOrg onto your iPhone, and you’ll have org mode on your iPhone and it’ll all sync up, just like Remember the Milk or ToodleDo or any of the other todo services that have “an app for that.”

“If you are a MobileMe user, you already have access to a WebDAV server: iDisk,” says the MobileOrg site in a manner I cannot help but read as insinuating.

“Sucker … walked away from Emacs and even took the extra step of slurping the MobileMe kool-aid thinking it’d harden your resolve against ever returning. Well … fine … keep your precious iDisk … it will become the tool of your re-liberation.”

Less than two years ago, when I was venturing forth from org mode and getting to know the iPhone as a way to keep all my Stuff in sync, MobileOrg would have had me at hello. Now it just gives me the shaking fits.

With Emacs, you don’t just go “la la la … I’m gonna add org mode back and call it a day!” You think to yourself, “I love org mode. I wish there was an easy way to turn an e-mail message into a todo …” and the next thing you know you’re dealing with how to configure GNUS.

Then you think “All my calendar stuff is in Google calendar … how can I get it into my org mode agenda?” and that means you’re off reading this guy’s page and just getting angrier and angrier.

Then you go in the kitchen and make a drink, and while you’re making it and calming down you think to yourself, if I’m doing all this stuff in Emacs anyhow, what would it hurt to follow Twitter in Emacs?

Now you’re not drinking because you’re angry … you’re drinking because you wonder what happened to you and it makes you sad. But you’re drunk, so it seems like a perfectly good idea to build an entire Web site using nothing but Emacs because then you can get a LaTeX version of it for if the asteroids hit and their radiation destroys all HTML. And having decided to do that, part of you thinks about how glad you are you have org mode, so you can organize the lengthy process of making sure you never have to leave Emacs again.

It’s knowing what’s in store for me as I sit here with MobileOrg on my iPhone and the necessary WebDAV share all set up that makes me read this and just want to spit nails:

At its core, Org-mode is a simple outliner for note-taking and list management. You can learn the basics for using it in five minutes. This may be all you need, and Org-mode will not impose more complex features on you.

That’s right … because org-mode is just a collection of lisp running in an editor. It cannot impose more complex features on you. The genius of org-mode is that you will eventually impose more complex features on yourself.