It’s fun watching the threads around what people have been doing with Journelly.

A lot of people are very into the fact that it uses org-mode underneath. I am, too, because unlike Markdown, org-mode is super amenable to a variety of plaintext workflows that you could probably pull off with Markdown but without all the supporting infrastructure to make it easier.

Take, for instance, the small problem of recreating reverse-chronological posting to a file:

Part 1. Content authoring vs. information management

When I wanted to do that with org-capture and Journelly, it just took this:

(after! org
(add-to-list 'org-capture-templates
'("j" "Journelly" entry (file "~/journal/Journelly.org") "* %U @ Home\n%?" :prepend t)))

… because org-mode provides a ton of infrastructure, including the ability to assume that if I tell an org-capture template to prepend to a given file, it will know to skip all the metadata at the top of the file and just plop the new level-1 entry on top of the top-most heading. Done. (Though I didn’t realize prepend was that clever, so I’ll just not show the eight or ten lines of lisp I thought I needed to do that with before Álvaro kindly straightened me out.)

I guess the thing about org-mode is that it’s not just a kind of markup, but is also an information management framework and its internal tooling has grown up to reflect that.

But when we take the use case of reverse-chronological posting to a Markdown journal, it can get dicey. The infrastructure really isn’t there, because at its core Markdown is just there to ease authoring, not management. I once ran a team of technical writers who struggled with The Markdown Revolution, because technical writers are also technical information managers who want to think in terms of efficient content reuse and refactored and recombined information. They ended up migrating to DITA (sit with that home page for a while), which was hugely alienating to the developer teams they worked with, but which allowed them to do stuff like localize their docs or effectively refactor documentation for a bunch of different kinds of presentation. I still grind my teeth on their behalf when I run into Markdown reductionists.

Anyhow, the reverse-chronological posting thing in Markdown:

There are three ways assorted Markdown systems I’ve come across handle how to set the title of a file.

YAML (or TOML) frontmatter:

---
title: "This pretty good file"
---

“The first H1 is implicitly the title”:

# This Pretty Good File

… and even one “piece it together from the slugified file name” case I spotted somewhere:

this-pretty-good-file.md

… which makes my gums itch.

All of those require some footwork to get a new Markdown H2 wedged into a file, and because Markdown is fragmented all to hell in part to solve information management problems it wasn’t designed to consider in the first place, there is no general-purpose solution. The best you can do is pick how you’re going to do it and build your tools accordingly.

In a situation where you’re making a logging tool, I imagine most people would just punt and append to a log file and live with chronologically-ordered entries. I happen to like reverse-chronological logs, so I made md-capture.el to recreate the org-capture experience in Markdown, and it is 105 lines of Emacs lisp that is to org-capture as a donkey in a dead lion’s pelt is to Aslan. If anything, md-capture convinced me that I should just use org-mode for any writing I care about and that needs to be part of a larger body of writing or interact with other parts of that body.

Part 2. You don’t have to care about any of that with Journelly

org-mode’s “problem,” to the extent it has one, is that it’s a creature of Emacs and lisp, so it inherits their marginalized status. It was sort of fun when Puppet started using Clojure, because overnight I started seeing Spacemacs start popping up on developer screens: lisp was back! As someone who’d been thinking of Emacs as home since 1992, I felt vindicated!

Talking to a Puppet product manager in the ensuing years, how much of a win that shift was for anyone is an open question: Even Puppet’s traditional Ruby foundation was a touch exotic for the average sysadmin who might also be willing to submit a PR, but was way more legible than Clojure. I don’t know if Puppet was cooling off anyhow, or if Clojure just made it impenetrable to would-be contributors, but the claim was made that community contributions to the core seemed to drop off with Clojure.

Well, anyhow, you don’t need to understand org-mode to get benefit from Journelly. This is the third tool Álvaro has made that bridges the world of org-mode with iOS, and does so in a way that lets “app people” just have an app they can use, while “org-mode people” can take advantage of the wider org-mode ecosystem if they so choose.

There are other org-mode “bridge” apps out there, but my observation has been that even with a touch-driven GUI they seem to prefer to expose the functionality in a way that is still visually anchored on org-mode as a way to markup text for information management. Journelly, along with Plain Org and Flat Habits, does a great good job of “just working” without needing to know about all the infrastructure available to you if you care to use it, and without making you deal with UI elements that want to remind you of their plaintext counterparts. Technically its use of hashtags probably counts as an extension of org-mode, since they’re not, as near as I understand, in the org-mode spec. In day-to-day use with standard Emacs tools, I’m not sure how much it matters.

So with Journelly we get an app that a non-Emacs person who just wants to have a flexible, elegant journaling tool can pick up and use: It has hashtags, you can add pictures to your entries, there’s search, etc. etc. and you don’t need to know about the plumbing that holds it all together. You still benefit, because if Álvaro announced tomorrow he was done with it and pulling it from the market, your stuff could be exported into a format that might not be popular but that is easily processed into something that is by Pandoc.

Part 3. Forgetting the plumbing helped me use Journelly better

So I mentioned that I’m not sure about the place of #hashtags in the org-mode specification.

“Tagging” in org-mode happens at the heading level:

** This is a sub-heading about particular fruits :grapefruit:citrus:

When you search for tags in assorted parts of the org-mode ecosystem, you are searching for :tag:, and :tag: occurs at the end of a heading.

The social-media-era #hashtag doesn’t exist in org-mode, so you don’t get any of the org-mode infrastructure benefits of using them in an org-mode file. They’re still perfectly searchable as a matter of being a string that starts with #, but org-mode has no place for them semantically. People have behaved unpleasantly to each other about this.

When I first picked up Journelly, I remember seeing the little # button, and not even knowing how to process it, because I knew Journelly was using org-mode underneath. So I ignored it. I was sort of excited that there was this very friendly journaling tool that I could use as a plain old mobile app, and that underneath it had this familiar, feature-rich format if I wanted to do something with my data in Emacs. In my mental model of how to use a tool that uses org-mode underneath, I was doing the same thing some other org-mode app designers have done, which is try to exist inside org-mode’s markup model.

I don’t even know why I decided to see what the # button would do. I think I had just downloaded the latest Testflight beta and maybe tags were mentioned. Maybe I was bored. So I tapped it and added some text and saved the entry. Oh … huh … that text had become a tappable link that listed my one entry with that #tag. So I went back to some past entries and stuck some tags in and proved to myself that #tags do something in Journelly that is technically a divergence from org-mode proper, but which are useful and intuitive in the app context.

It was the “technically a divergence from org-mode proper” part that stuck with me, because in the moment I had to make a decision, I guess:

Ignore #tags because they wouldn’t work quite like :tags: in Emacs, or accept them in the context of Journelly because they’re useful.

An exchange I’d had with Álvaro gave me another useful nudge. I was trying to solve the problem of how to edit my Journelly file from the desktop without blowing it up in a sync error, and sort of problem-solved my way into thinking it’d be interesting if Journelly could handle multiple files and maybe interleave them since the entries are all predictably time/date-stamped. He said he liked having a monolithic file because he could find everything with swiper searches. I’d never used it myself, but I had my Doom config going and it’s already wired up with SPC-s-s (or SPC-s-S to search for the thing at point), so I learned it’s a fuzzy search tool.

Well, there’s your “how a #hashtag would work in org-mode” solution: It’s just text. Use a native tool in the context of a monolithic journal. And there are plenty of other fuzzy search tools for multi-file search.

So I got unstuck on using hashtags in Journelly and decided Álvaro wasn’t trying to embrace/extend/extinguish org-mode to build his app empire.

Part 4. mindful journaling with hashtags

Which is what brings me to something I’ve never used a journal for before: Checking back in on how I think or feel about something, which I stumbled into.

Once I decided to start using hashtags in my Journelly entries, I wasn’t sure how to use them. Semantically, in a social media context, they are a discovery tool. I’ve read it recommended that if you’re using Mastodon you should really lean into them, because say what you will about the toxicity of algorithmic discovery, without it you need to figure out some other way to discover stuff.

I won’t use Microblog because it has taken the position that hashtags aren’t okay, and the one time I mentioned the discovery use case I got a snide “why is it so important to be discovered?” from the founder that was just … like … because I want my writing to be discovered by people who may share my interests or even express appreciation for my writing or photography or other endeavors. Why the fuck do you have a first and last name, asshole? For a period I wedged hashtags into my Microblog blog with a Hugo shortcode that linked to a Mastodon search for a given tag and a custom social posting feed that made sure the tags were injected into the description, but decided if a service has set aside a very basic and commonly understood tool for discovery because the founder thinks hashtags ruined Twitter, why bother?

So I was just putting tags on all sorts of things to see what would stick: People, moods, places, kinds of events, themes, etc. etc.

The most useful pattern to emerge was completely coincidental:

I was struggling to manage interactions with someone at work, to the point I was dreading every call or meeting. I had deeply internalized the idea that this person was impossible. If asked “what do you think of this person,” I’d have described someone who could not be worked with, would not respond to basic interpersonal communications strategies, and for whom I’d resigned myself to merely co-existing.

Over a few weeks, as I’d come out of meetings or interactions, I’d do my best to remember the positive parts of the interaction: Things where maybe they were their usual intransigent self, but had surprised me by showing up better, or responding well. But when talking about them over dinner, after work, my “they’re impossible” narrative would crowd out any in-the-minute observations.

Then one day, having just finished a post-meeting entry, I tapped on their name hashtag and got all my past entries where I’d mentioned them, and had a ton of evidence in front of me that for weeks I’d been seeing good things, positive signs, indications that they were not, in fact, impossible or hopeless. That most of the time they were showing up okay. The “omg nothing good came of that” entries were pretty sparse.

I guess if I were faced with a solid cube with no apparent openings that didn’t respond to anything I did to find out what was inside it, or a solid cube with a small number pad that required a eight-digit pin to open, I’d probably complain that seven digits is a documented boundary of our ability to memorize a string of digits, but would prefer that to not being able to open the cube at all. I would probably save the eight digits in 1Password or write them on a sticky or make a snippet of them.

Which is sort of what using hashtags for a difficult human being helped me do in Journelly.