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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Forsaking mobile

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

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

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

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

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

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

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

kitty and denote

Okay.

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

Sure.

Make an org capture template like this:

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

… then add this to kitty.conf:

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

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

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

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

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

… name it something like denote.conf

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

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

terminal maximalism?

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

Is this all some sort of terminal maximalism thing?

Maybe, I guess?

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

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

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

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

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

• awesome-cli-apps
• awesome-shell

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

the working world

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

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

Okay. I have a little more to say.

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

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

We took a weekend trip down to the Alsea Falls area, west of Corvallis. We camped in the federal campground there, and spent Saturday hiking up Marys Peak.

This is the second season we’ve had our Garmin inReach Mini, a small GPS device that offers basic tracking plus emergency satellite communications (SOS and texting) and live weather. We got it after a small scare on our trip to the Redwoods last spring.

I’m a hardware GPS holdout. I’ve used a number of iPhone apps including Gaia GPS and AllTrails, but my issues with using an iPhone in the backcountry amount to the unpredictability of the devices: I’d like better guarantees about the stability of the data I keep on them, I don’t trust their power management over the course of a day on the trail, and I live in a biome that makes fussing with a touch screen in the field a nightmare six months out of the year.

Before we got the Mini we already had a Garmin GPSMAP 64sx. Even when I’ve been experimenting with iPhone apps on the trail I’ve preferred to download my routes to the 64sx, even if I’m leaving it off and buried in my pack. It’s a good insurance policy that paid off a few years ago when we were hiking through burned out areas in Central Oregon and lost the trail thanks to massive deadfalls: the extra topo layers I had loaded into it made it easy to look up the trail on the spot and figure out where to rejoin it.

I’d like to shed the 64sx and I’ve eyed the inReach-enabled handhelds Garmin’s got on the market. They offer rechargeable or AA batteries, do all the handheld GPS stuff, and include the same emergency comms options. The Mini is so small, though, that it’s not a huge burden to have two hardware devices. The Mini has a ‘biner I clip to whatever pack strap is handy up near my shoulders and mostly stays out of the way. I just make sure to plug it into the car to recharge it whenever we set out on a trip. So I don’t think a whole new device is necessary and I’ll just live with the extra hardware.

This weekend convinced me I could probably loosen up a little on using an iPhone on hikes, though. Marys Peak isn’t that remote, and there’s even 5G cell coverage at the top, so the stakes were lower and made it easier to experiment.

People dis the company for limiting the connectivity of its devices to preserve a focus on hardware, but Garmin’s Explore app does a decent job of turning your smartphone into an expensive dongle that offers better ergonomics if you’re mostly sticking to easier dayhiking situations. Once paired, the Bluetooth sync between phone and GPS device is solid and fast, and Explore includes topo maps and the ability to add tracks and waypoints to your Garmin account. So you can download a GPX file before heading out, import it into Explore, and it will both sync to your Garmin account and — once paired up — your dedicated GPS devices. Any tracks you record on your hardware sync to Explore, where it’s much easier to use the phone UI to rename, relabel, and organize once you’re off the trail. It also offers a map on a larger, big screen you can consult in a pinch. It’d still suck in the rain, but it’s there for quick use.

This weekend I addressed a few of my hangups about how little I trust iPhones to behave when my back is turned by making a pair of shortcuts that alternately power down all the radios and put the phone in low power mode or bring the radios back up, and saved them to my homescreen. When we got to a point on the trail where we weren’t sure what it would mean to take one route or the other, Explore’s topo map made it easy to do a quick consult and make a decision. Having a bigger, brighter, faster screen to explore with was better than the slower, smaller, harder to read 64sx. Then the phone got put away and off we went. For the kind of hiking we usually do, that seems like a workable use case. So I expect the 64sx will be spending more time at the bottom of a pack.

I did spend some time imagining an iPhone Ultra during the more boring part of the trail, though.

Wikiloc

Another iPhone GPS challenge involves downloading GPX files. Some apps make it pretty hard to do from mobile even if they do offer the option via a desktop interface, and you’re sort of swimming upstream when you do anything on iOS that involves a data file. I found Wikiloc, which has a reasonable $9.99/year subscription and a 14-day trial, so I’m going to give it a try on our trips over the next few weeks. The subscription includes a simple interface to save GPX files to your phone’s storage, send them to your Apple Watch, or share them to Garmin devices. I learned I can just use the share sheet to send them to the Explore app, where they sync to my Garmin account. That’s a big improvement over AllTrails’ mobile app.

Wikiloc is crowdsourced, so you’re better off using it when you have time to vet the trails at home, or the connectivity to do so in camp. The ones I’ve looked up so far seem fine based on past experience, you just have to choose between several for a few locations, and people don’t always clean up the ten minutes they spent walking around the trailhead, visiting the toilet, and walking back and forth from car to picnic table from their GPX files.

We have a few guidebooks to Oregon trails we use to get ideas for hikes, then compare and contrast with the online tracks. It can make for some amusing triangulation: The books are a little dated and fusty, preferring trail names that don’t always line up with the names the forest or park services use on the signage. The crowdsourced online trail resources sometimes feel like they were annotated by someone who thinks “walk a mile or two and turn left where someone left a Snickers wrapper in the weeds” counts as expert guidance.

Anyhow, we’re headed to the Diamond Lake area in a few weeks and there are some trails to try it out on. I don’t know if we’ll make another run at Mt. Bailey this year, though.

Anchoring on The Denote Way

I’m a month into “Obsidian but with Denote file naming and frontmatter conventions” and it’s surprisingly calming.

I’ve settled on 12 plugins, several of which are discretionary or just around to be used for the API they provide to another plugin, and I’ve discarded the things in my setup that were sort of nice but unreliable for syncing. It’s smooth, syncing is reliable, and 30+ days into a new job I’m finding search works well.

I felt a little itchiness about the setup a few days ago, and the thing that kept me from doing anything about it was the sense that settling on the Denote formatting conventions for file names and frontmatter means the option’s there to move between Obsidian and Emacs whenever, so why bother now? They’re just Markdown notes. I will probably not revisit north of 75 percent of them ever for anything more than digging out a fact here or there. I can type them into anything. If I ever get to a point where org-mode’s better syntax is called for, I’ll just slip over to Emacs and carry on. Both formats work in Denote.

Def curious about Bear 2 tho. It keeps the content in some sort of db though, right?

Belonging

I had a chat with a senior executive in my foodchain today. I found myself saying, “there’s some stuff that’s a little messed up I have to deal with, but I belong here and I’m the kind of person you need handling this stuff.”

Little moments like that have been happening here and there, when I feel a little frustrated that something is just sorta dumb and dysfunctional or broken, then I pause for a moment and think “Good. I’m the right person to fix this. It’s why I’m here.”

I love my Puppet friends dearly, wouldn’t trade the experience for the world, and had the good fortune to go out with a great person to report to who did a lot to help me get back a sense of what I could do, but on balance the last few years of that place did me no favors, and I let a lot of self doubt seep in. It feels good to begin recovering a little more sense of what I’m supposed to be about. I’m so glad I got to take a break before I jumped back in.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Given my usage patterns, either seems fine?

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

Anyhow, it’s a hobby.

espanso

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

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

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

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

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

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

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

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

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

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

Demo/tutorial video:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Obsidian.el

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

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

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

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

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

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

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

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

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

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

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

[[things:#foo]]

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

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

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

Automating dblock-driven metanote updates

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

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

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

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

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

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

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

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

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

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

Cleaning up org publishing exports

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

org-html-divs

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

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

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

org-html-preamble

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

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

org-html-head

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

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

espanso

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

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

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

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

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

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

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

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

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

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

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

Anyhow, that’s the background infra stuff.

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

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

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

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

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

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

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

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

Anyhow, seems to be a fine v1.

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

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

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

Eh. Whatevs.

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

A bit more on the Leica Q3 and the Fujifilm roadmap

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

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

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

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

Fright Night (2011)

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

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

Old man coos at cloud

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

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

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

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

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

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

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

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

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

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

Here’s the LinkedIn version:

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

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

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

Reflecting on my time off after Puppet:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Our world of note-taking compromises

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

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

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

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

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

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

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

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

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

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

So, net:

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

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

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

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

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

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

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

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

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

With that in place, you can do:

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

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

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

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

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

#!/bin/zsh

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

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

  echo "File encrypted: $encrypted_file_path"
}

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

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

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

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

The mobile problem

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

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

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

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

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

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

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

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

Hugo previews while working in ox-hugo

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

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

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

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

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

What happened to V

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

Interesting factoid:

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

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

“The Phony Solidarity of the American Pundit Class”

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

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

I wrote a few years ago:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Succession ended with integrity

Spoiler culture is out of control, but … spoiler.

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

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

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

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

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

Denote just makes sense to my brain

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

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

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

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

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

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

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

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

keycast

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

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

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

Well, joke was on me:

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

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

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

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

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

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

DPReview’s initial review of the Leica Q3 says:

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

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

Anyhow:

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

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

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

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

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

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

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

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

So:

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

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

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

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

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

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

I kid.

Silos and Denote

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

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

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

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

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

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

Update on that …

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

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

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

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

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

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

Update to the update

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

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

Years and years ago, before it was what it is today, which is horrible, Electronic Arts did some interesting marketing things that would lead you to believe that it was less a software company than some sort of rural artist colony that happened to make software but otherwise spent its time in rustic pursuits. They had a “Construction Set” product line that let you make your own stuff: music, racing games, pinball games, and adventure games.

I had the Adventure Game and Racing Destruction Construction Sets and they were really fun. The Adventure Game set gave you all you needed to make a world with regions, rooms, things, and creatures. Things could do magical stuff, and creatures had a very simple set of behavioral rules.

That was my first experience with a software tool that let me make things inside a computer.

Jump forward a few years, and Borland came out with Sprint, an extensible word processor with a modifiable UI that let you pick from several basic keybinding profiles (WordStar and Emacs, at least) and then add your own customizations if you wanted.

I was reminded of Sprint this morning as I sat down to extend Doom’s menus for use with Denote, which I wrote about yesterday. It’s just very clean and easy to do:

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

It took me a few minutes to find my way back to how to deal with a keybinding collision in Doom’s mappings – it has Deft bound to d under the notes (org) section. I don’t use Deft and didn’t want to skirt around the binding with D for denote so I had to nil d out before I could use it.

Otherwise – five minutes of work to build out a submenu for Denote with a mix of things I’ll use all the time (making new notes, doing a ripgrep search of my Denote directory, showing backlinks) plus a few things that are useful in the short term, such as renaming a file on the disk after changing its metadata (since Denote uses file naming as metadata) or removing provisional keywords I used to move a bunch of notes in and operate on them in steps.

It’s simple, mnemonic, but also offers visual prompts to help with learning. After a while you’re not even going to look at the menu because the simple three-key sequences sink in after enough repetition.

It has made learning how to do new things much, much easier than it used to be. I’ve just taken to opening a scratch buffer, copying over an existing menu config and clearing it out, then I start trying to do things with a new tool, figuring out over the course of a few hours what things I’d like to be able to get to with a few keystrokes instead of remembering the function name or native keybindings. As I figure one of those things out, I add it to the menu, evaluate, and keep going. That is so much better than all the chord memorization I used to do.

A little more on Denote

I also spent some time this morning figuring out how to do things “the Denote Way,” which means leveraging existing tools in Emacs instead of learning a bunch of functions that significantly duplicate functionality you already have.

“Part of the reason Denote does not reinvent existing functionality is to encourage you to learn more about Emacs,” says Denote’s creator, Prot. Like, just bookmark your Denote directory and use the built-in find-file command in (SPC . to narrow by tags in dired in Doom), because tags are embedded in filenames, and lead with _. If you need fulltext search, ripgrep is there for you, and you’ve probably already used it somewhere else.

I appreciate the approach. I think it will lead to learning how to do more by using fewer things across different use cases, instead of learning shallow functionality across a plethora of hyper-specialized tools.

I also learned that Denote leverages org dynamic blocks, so you can create dynamic backlinks blocks with live links:

#+BEGIN: denote-links :regexp "_management"

#+END:

C-c C-c in the block and it dynamically updates all the items tagged with management. All that stuff is just atomized interview prep notes from my job search, which I broke down and stuck in org-roam and spent a little time converting to Denote’s format to try things out.

Fully equipped

I took my Townie down to Foster Rd. for lunch today, then stopped off at one of the local bike shops in the Mt. Scott neighborhood. At some point early in my ownership I stuck hybrid pedals on it. Years ago Shimano came out with the Click’r pedal, which offered some of the stability and torque advantages of a clipless pedal with a little more ease of use. The hybrid pedals were supposed to make it easier to just hop on and ride with street shoes on if you didn’t want to change, or to snap in with cleats if you wanted to do a longer ride (or ride in the rain).

In practice, I don’t think it was a great idea. I very seldom wanted to wear the cleats, and don’t use the Townie for more than a few miles at a time. The right side of the pedals never seemed to be facing up. And they were small under normal street shoes.

So I just got some decent pedals with good traction today, and also added a cup holder, which seemed to tickle the counter guy.

“It’s complete now,” he said.

I’ve got a six mile ride for lunch on Thursday … that’s a little farther than I usually consider, but new pedals and a cup holder seem to demand a celebratory cruise.

Fences

I need to do some reading on fences. The one around our property is in bad shape. The way our house is built and situated, the east and west sides don’t need one for privacy at all. The north side sort of demands it during the summer months – our neighbors on that side are as avid about their back yard time as we are.

But also, fences are sort of weird to me. Whoever built our house took the initiative to put one in. Our neighbors to the east sort of built off of it to fence in the south side of their lot. Our neighbors to the west don’t care because their garage is our west property line. My thought is just “there is a total of one east window in this house, and it is a high window that doesn’t line up with the neighbors’ west window, and there are no west windows at all, so why even have fences on those sides?”

I’m wondering if there’s a way to handle the north side … the longest part of our lot that shares a boundary with a neighbor … without a fence fence. Or if the answer is something relatively high back there, but not as high (and hence more durable?) on the other two sides.

But mostly I just don’t understand anything about fences at all.

When I look at them, sometimes they seem to be for privacy – they’re high and block people on the street seeing in – and other times they seem to be kind of for security? Like, you’d have to make an effort to vault a waist-high one made out of chain link, or they wall off access to the back yard, or they (more rarely) seal in the driveway (though good lord do I get annoyed with all the old chain link driveway gates that just sort of loll around blocking the sidewalk). Sometimes they just seem to be there to demark the property line, which would suggest something less elaborate would do, and serve mainly as lawn mower guidance.

They weren’t a common feature in the small town where I lived in Indiana. They weren’t common in the Virginia neighborhood I lived in, or else they were low, chain link things. They were unheard of out in the Pennsylvania coal and dairy country I lived in except for one place that was half house, half mechanic’s garage there in the hamlet. I remember low, chain link fences around every yard in Houston, TX as a child. The only childhood home I can remember having tall fences was when my family lived in a townhouse in suburban Pittsburgh, and everyone had a tiny patch of back patio. They’re very common in this neighborhood, more tall than not for newer construction, more likely to be low chain link things for all the smaller postwar houses.

Anyhow, I need to learn more about them. There’s the part of me trying to engage with the whole topic by observation – a mode I get into that Al tolerates, but barely – and the part of me that has a vague inkling that fences around yards might be one of those things that are common but also not thought through in detail, which means there are lots of opportunities to step on norms people didn’t even know they had.

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

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

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

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

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

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

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