I fiddled around with Workflowy a while back, and it has been in the back of my head, since. There is something about the whole outliner thing that is compelling, but when I see examples from people who are heavy outliner users in the wild I get this sense there’s a sweet spot between “useful chunking of information” and “stilted and hard to consume/digest,” and … we all have different cognitive styles, I guess is all I’ll say.

As near as I’ve been able to piece together some ideas out there in note-taking land, I’d like my personal notes setup to involve:

• A daily log
• A daily personal task list
• The ability to digress from the log

I’d like my log to be somewhat structured, meaning timestamped entries of a consistent format.

I don’t care if my personal task list for the day has much metadata, because we’re closer to the “shopping list” end of the spectrum than the “project management” list. I guess it can have no metadata besides “have I done it yet.”

Digressing from the log doesn’t mean much besides, “is it easy to think of something, quickly make a new node/page/tiddler and start typing.”

The apparent term of art for all this stuff is “intersitial logging.” That is fewer syllables than “keep track of what you’ve done during the day,” but has the benefit of higher syllabic density.

An outliner is a pretty good tool for those things because it brings some structure, favors the terse, and frees you from worrying about managing the arrangement of the text in favor of managing the arrangement of the content.

Outlining with Streams

Digging around for outliners for Tiddlywiki I came across Streams, which sticks a little outliner widget in each Tiddler. Click the “+” button, and you’re in a node in your outliner. Tab to indent, shift-tab to outdent, grab the nodes by their handles to reorder. Each node, in turn, is its own Tiddler.

I am not entirely sure how I feel about that last part, and if it were not for a filter you can apply to your sidebar to hide all the subtiddlers Streams produces in the open and recent lists, I am pretty sure I would hate it. But you can drop some code into the sidebar shaddow Tiddler to clean all that up and only see the root of a stream.

There’s enough there to play around, anyhow.

I made a simple Espanso trigger to timestamp my log entries:

# Make a timestamp
  - trigger: ":log"
    replace: "''[{{mydate}}] '' "
    vars:
      - name: mydate
        type: date
        params:
          format: "%r"

So, open a new node in the outline, type :log, start typing.

Finding the escape hatch with Streams Fusion

Because I’m a nervous soul who is always wondering how to back out of things like this, there’s also the Streams Fusion plugin, which gives you a little icon at the bottom of a stream to merge all the sub-nodes in a stream into a single, unified chunk of text.

That’s cool, because in a daily log you can be creating a proliferation of digressions and sidebars, not all of which qualify as full-fledged chunks of thought or interesting directions. So, click that button at the end of the day and all the nodes in the outline are turned into normal markup (links intact, if you added any) that looks like an outline, but all the child tiddlers from the root are removed and nodes you linked in a digression become backlinks to the newly merged daily log.

Alternately, you can turn the outline nodes into simple paragraphs. This morning I came across something while I was reading, started outlining, said all I’d had to say about that stream of thought, and went ahead and merged it all into a normal tiddler.

In evolving practice I don’t know whether I’ll fuse many daily pages or not. The part of me that doesn’t like the underlying sprawl of nodes even if I’ve hidden it from myself is still paying too much attention to what’s going on underneath. It’s a fine line between due diligence and unhealthy perfectionism. The benefit of fusing logs will be improved searchability for log entries themselves, since search results will go back to a single day’s log page instead of its child nodes. That seems to be kinder to future me.

Tasks in my log with Espanso and regexps

Once I decided to let the Streams experiment run, I waffled around about how to integrate tasks into my log. The “interstitial logging” people encourage a single, unfified stream of log entries and tasks created as they come up. Tiddlywiki’s core conception of tasks is that they should be nodes (“tiddlers,” yes) with a todo tag. That’s a little cumbersome in the Streams workflow.

So I did a quick experiment with the Sticky Todo plugin as a way to make a Streams node a task.

Sticky Todo uses markup like this to turn any text into a todo that appears in your sidebar:

<<sticky "Take out the recycling">>

That’s not too hard to remember, but it’s sort of type-y, so I made an Espanso shortcut that leverages its ability to do regexps:

- regex: ":todo\\((?P<todo>.*)\\)"
    replace: "<<sticky \"{{todo}}\">>"

So I can start a node with :todo(some task) and Espanso replaces it with <<sticky 'some task'>>

It’s 7 keystrokes minus the task content instead of 13? Plug it into the table and bask in the efficiency!

Espanso is useful for stuff like this where there’s no way I could figure out how to get Tiddlywiki to automate this in any reasonable timeframe.

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