Exploring the database format of Things

I was think about switching from #Things to #TaskPaper. Task-management is the last piece where I still don’t use plain text, albeit using Markdown in Things notes (see 2023-12-09_12-09 Things to-do journaling template).

  • Why I like Things
    • Nice UI
    • #Markdown support in notes
    • Really good #Shortcuts integration
    • iOS and iPadOS versions, which are at the same level of excellence
    • There is a link to everything
    • No attachments
      • People tend to dislike this. Having no attachments support forces me to have better attachment management in dedicated apps like DEVONthink
  • Why I don’t like Things
    • Uses a database
    • Sync is not end-to-end encrypted
    • No Spotlight integration
      • On the Mac, I periodically run a script which creates .hook files linking back to projects as way to have a fake Spotlight index.

Knowing that the database is fairly easy to understand, I’m a bit more confident that I can export my to-dos out of Things. I can even use the SQLite database directly as an archival format too.

The non-existence of end-to-end encryption is still bugs me though.


When we keep a journal we automatically keep bookmarks for ourselves

Programmers complain about distractions all the time. But when we journal and document our actions, we can drop them in the moment and pick them up later from where we left off. It’s like bookmarks for our lives (see next actions 2.7).

We will also have a history of our actions in the journal, which can be used as a reference when we have to go back in time.

#Drafting #Journaling #NextActions

I can keep automation scripts in Git repositories

Automations should be exported into Git repositories. They have to be installed since most automation tool expects a script, a shortcut, or a macro to be imported into a library, or installed in a special place, but we can still export and assemble files from our tools into a repositories.

Keeping these repositories up-to-date can be a burden, since we have to manually export files. But it’s still beneficial to keep these under version control, since sync problems can happen, so we can go back to a previous version more easily.

Keeping an issue thread ensures we have a background information on a code change

  • Timestamped documentation
  • A timeline of changes
  • An issue thread is like background information on what decisions we made about our code at a point of time.


Documentation should live in the same repo as the code

Documentation review should be part of the code review. By forcing us to store the documentation in the same repository, we can keep it up-to-date with the code directly. We can catch missing documentation updates in PRs while doing code reviews.

The documentation is versioned in a way in Git that ensures it aligns with the same version of the code, thus automatically synchronizing it’s history with older versions of the app.

Question: how we can migrate existing documentation from an external wiki into the repository?


We don't need to create a PR if the commit is atomic

When committing atomic changes of a “thing”, it has to have the following items included:

  • Actual code changes
  • Tests / specs
  • Documentation
  • Reference to an issue number (or a link to an external issue tracking software)

If the commit includes these, we can commit it into the main branch directly.

This wouldn’t work in a team setting though, since it requires too much disciple from other people. Also committing directly to main branch can be dangerous.


Things to-do journaling template

This is my standard notes template for journaling about a #Things to-do in its notes.

# 2023-12-09_12-07

Notes about what happened with the to-do…

# 2023-12-09_12-09

Yet more notes about what happened with the to-do…


Displaying Hookmark icon on the Dock

Source: Hook: getting out of the Dock - Discussion & Help - Hookmark Forum

To display the icon on the Dock:

defaults write com.cogsciapps.hook background.app.mode 0
  • #BugsQuestions
    • The problem with the Dock mode is that the Hookmark app still kept active after copying the link.
    • It doesn’t switch back to the original app.
      • LaunchBar has a Dock mode, but it doesn’t steal the focus when it’s activated.

To revert it to be a background only app:

defaults write com.cogsciapps.hook background.app.mode 0

I’m going to keep my interstitial journal separate from my Zettelkasten. My journal doesn’t need Git and all the bells and whistles of my Zettelkasten. I just want to have a simple place to quickly draft ideas.

Some notes may move over to my Zettelkasten, which I can automate, but it’s very private, so I don’t want to accidentally publish something.

#Journaling #TaskPaper #Zettelkasten

The Arc style tab and bookmark management

People seemingly like Arc because of its tab management. I think it can be replicated with Safari as well using tab groups.

Arc doesn’t even have bookmarks, but Safari does.

  1. A bookmark can live in the temporary tab space
  2. It can be moved into more specific tab groups
  3. From here it can be even bookmarked into my Inbox tab group
  4. I can organize the bookmark in my Safari bookmarks, or move it into other apps for long term storage.

I should manage my Pull Requests like this, since they are very important.


I can quickly search today’s notes by typing fdate into The Archive’s omni bar. Typinator will expand today’s date.

I also modified my Open Current Note in Zettelkasten shortcut to give me an option to open the note in The Archive too. I just figured out that it searches for the note and gives me backlinks.

#Shortcuts #Workflow #Journaling

Refactor Things journaling

  • Create a repository for the original shortcuts
    • automation-things-journal
  • Journal About Things To-Do
    • Save the Things URL of the selected item
    • Create a new Drafts document with the date, published, things_url, title attributes in the frontmatter
    • I could also create a new text file directly using iA Writer URL schemes, and the Shortcut
      • Get the Things URL
      • Format the frontmatter
        • title → name of the selected Things item
        • date → the current date
        • publishedfalse
        • things_url → URL of the selected Things item
      • Create the Markdown file with a timestamp and a slugged version of the selected Things item
  • Open Things To-Do Journal

#Journaling #Things

Refactor checklist journaling

Automation repository creation

I created the new repository for my first automation script. https://github.com/zsbenke/automation-taskpaper-checklists

It would serve as a demo.

  1. Include all files that are needed for the automation.
  2. Create a README.md file which describes what it does.
    • I could include the keyboard shortcut which triggers it.
  3. Record a demo.mov file
  4. Upload the demo.mov file to Vimeo with the name of the automation
    • Automation – Automation Name
  5. Link the demo.mov from Vimeo in the README.md

#Automation #Reference

Plans for TaskPaper journal changes

Since I want to use TaskPaper as just another editor app, I should move my interstitial journal file out of it.

I cancelled some parts of this project. → 2023-12-09_10-04

#Thread #Shortcuts #TaskPaper #Journaling #TheArchive

Switching to my Zettelkasten as a journal

I think I’m going to give up my TaskPaper journal. I just think The Archive app makes so much sense as a journal and Zettelkasten.

I can develop notes and journal about stuff here. It’s even have images integration, and I can use the old style Notational Velocity app.

Increase your productivity on personal projects with comprehensive docs and automated tests

  • Author: 2023-12-08_20-16-simon-willison
  • Increase your productivity on personal projects with comprehensive docs and automated tests - DCUSDEVONthink Archive
    • The Perfect CommitDEVONthink Archive
    • Using PRs and squashing commits is similar
    • GitHub issues can be archived → https://github.com/dogsheep/github-to-sqlite
    • Using GitHub as Zettelkasten
    • 2:58
      • Perfect commit
    • 4:00
      • Commit changes of one thing
    • 5:30
      • Incrementally building tests
    • 7:32
      • Documentation should live in the same repo as the code 2023-12-09_13-27
      • Catch missing updates in PRs
    • 8:55
      • Documentation tests
    • 10:10
      • Issue threads
    • 12:10
      • It’s like Bike planning
    • 13:40
      • Timestamped documentation
      • A timeline of changes
      • Keeping an issue thread ensures we have a background information on a code change → 2023-12-09_13-35
    • 14:08
      • Issue driven development
    • 14:55
      • Have this for Shortcuts
      • I can commit and export a shortcut
      • Keep them in one repository
      • I can keep automation scripts in Git repositories 2023-12-09_16-05
    • 15:20
      • Get back to something when you have notes
      • Programmers complain about distractions
      • When we keep a journal we automatically keep bookmarks for ourselves 2023-12-09_16-10
    • 16:40
      • Issues for everything, even life stuff
      • At this state, this is a project management app, like Things
      • I keep stuff like this privately, not in GitHub issues
      • I link it using Hookmark
    • 16:56
    • 18:14
      • Publish Markdown files to GitHub issues
      • I can create a new comment to have a way to I document my stuff
      • It will make my work more transparent
    • 19:30
      • Have an output about what did you done
      • Journal about what you did
      • Twitter threads
        • Or small status blog posts
      • PR description
      • Get a blog



I developed a coherent Zettelkasten content pipeline

The following diagram explains the flow of my #Zettelkasten content pipeline.

  • Incoming information: reading
    • My primary reading sources are Apple Books, Safari, and DEVONthink.
    • I’m taking notes while reading.
      • I use the built-in annotation tools in Apple Books.
      • I use Quick Notes in Safari.
      • I use the built-in annotation tools in DEVONthink or PDF Viewer for marking up PDFs.
  • Incoming information: fleeting notes and ideas.
    • Fleeting notes and ideas are things that I came up with from my mind.
    • Usually, these are triggered via external events like reading.
  • Processing
    • All of these annotations, ideas, and notes are collected in my Things inbox, where I process them using progressive summarization / sense-making.
    • I highlight the interesting parts and then add these to separate Bike outlines with a link to the source.
    • I’m organizing these ideas in Bike, and then I export them into Zettelkasten notes through Drafts.
    • They will end up in my Zettelkasten as new notes ready for drafting.
  • Drafting
    • I use the #Drafting hashtag to keep track of my notes in iA Writer using a smart folder.
    • While editing my notes, I expand new ideas into separate notes created on the fly and linked.
      • I usually add the #Drafting hashtag to these too.
    • When a note is finished, I mark it with the #Linking hashtag
  • Linking
    • I also have a Linking smart folder in iA Writer for notes that must be added to my main outline.
      • I do linking on my Mac because I need a bigger screen.
      • I keep my outline source in Bike and add new notes there.
    • I find the note most appropriate place in my outline and add its ID and title there.
      • I have a shortcut that finds the corresponding note for the selected Bike row, assigns an ID according to its place in the outline, and links it from the Bike outline.
    • The next step is finding and linking related notes, which can be done in Bike or my outline directly on my Zettelkasten site.
      • This is the hard part, where I have to find a connection between the new notes and existing ones.
    • When satisfied, I export the Bike outline into a raw Markdown file for Jekyll and sync it up with my Zettelkasten site.
  • Searching
    • I mostly use The Archive to search and browse my Zettelkasten.
    • I also have private notes there, which are hidden from my published Zettelkasten so that I can keep track of other information in my Zettelkasten, too.

Screenshots of iA Writer smart folders setup


Using my Zettelkasten in DEVONthink

I indexed my #Zettelkasten notes in DEVONthink and also turned on syncing without uploading indexed items. On other devices, I also want to have this database synced, but I should also set it up the same way as on the original laptop.

I want to use DEVONthink to browse my Zettelkasten locally. It can even get and parse hashtags. But I can’t use hypens in the name of the hashtag for the Hungarian suffixes.


Manage multiple libraries in The Archive

There is a way to open a different archive when starting The Archive app from the Terminal.

$ open -n /Applications/The\ Archive.app --args -archiveURL "file:///Users/YOURUSER/path/to/notes/"

For example, I can open my Running Lists folder with this command.

$ open -n /Applications/The\ Archive.app --args -archiveURL "file:///Users/zsbenke/Documents/Running%20Lists/"

This will open a new instance of The Archive app. I’m not sure if that’s intended behavior, but it works for quick checks.



Ulysses writing workflow

  • Create a new project for each post
    • Posts that are long
    • Projects has their own set of rules
    • Duplicate the Post Template project
  • Writing
    • 🏷️ Drafting
    • 🏷️ Revise
    • Use the Resources folder for assets
  • Publish to the blog
    • I merge all revised sheets
    • Run them through Grammarly
      • Or use the built-in grammar checker in Ulysses
    • Publish the post to my blog
    • Let it sit for a couple of days
    • Archive the project




Leave permanent note linking to the Mac

  • Writing notes requires a different environment than linking notes.
    • Linking is about finding the connections between notes, while writing is about getting out our ideas from our fleeting notes in a focused manner.
  • When I do linking, I need to have a bigger display with multiple notes open so I can easily review them. An iPad screen size it’s just too small for this activity, so I like to do linking on a Mac.
    • Can linking be done on an external display on iPad using Stage Manager? 2023-11-17_21-44
  • I added an outliner-like JS module which converts Markdown lists into a togglable outline.
    • So in this note, this item can be hidden by pressing the arrow before the parent element.
  • I can also link to list items.
    • The outline-toggle controller calculates a checksum from the text on each item, and links them using the toggle arrows.
      • The checksum algorithm I used is available here.
    • When I paste the copied link back to the browser, I get a highlight effect for the linked block.

The capture log is an append only system

This note connects “2.16 Appending information is way to keep a history of changes” to “2.14.12 The capture log is an automatic journal”.

So I can see the capture log in the descendants of “Appending information is way to keep a history of changes 2.16”.


Git can be used for keeping the history of non-code based source files

  • I can set a Git repository for almost any source material which I’m working on, and I’ll have a nice history for these files.
  • Keeping a Git repository only works for file-based apps. It doesn’t work for database based apps like Ulysses, or Bear.
  • On top of Git, it’s still worth to keep manual versions for writings around, especially after reaching a milestone like the first draft, the first edit, or the version before spell checking. Manual versions usually work in database based applications too.
    • 2.16.3 Keeping manual versions in Ulysses.

The capture log is an automatic journal

A capture log is a journal-based version of the inbox, where ideas are getting captured. This was an idea mentioned by Merlin Mann for the first time, where he wants to yell into the void and let Siri capture his ideas, with automatic metadata like creation date, a location, and optionally the weather.

A capture log is kind of a journal about our ideas. It’s like a tail for our life.

There is a difference between the Inbox and Storage

The Inbox is a medium which contains items that change frequently. It is a temporary place that holds new information in the short term. It’s like a tail for our life as Merlin Mann said it. → 2.14.12

The Storage is a place which holds processed information on the long term, optimally organized in some form of fashion. Organization categories should have clean edges, so we know what to store where.

By using these two information holders, we can separate the processing and organization part of #GTD.



There similarities between naming things in programming and naming things in a Zettelkasten

  • When we have to name something we’re forced to think about its meaning.
  • Naming a #Zettelkasten note is similar to naming a class in programming.
    • In programming a class describes a set of related behaviors.
    • A name have to describe these behaviors in a way that makes sense for us (and other developers).
  • Phrasing a title for a note will force us to came up a simple clarification on the content of it. This requires understanding.
    • A jegyzetcímekre API-ként kell gondolnunk

Change the outline level display

Follow-up on 2023-10-30_07-54:

I think the best possible solution would be to keep just the 1st, 2nd, and 3rd levels in the outline.

  1. 1st level should be visible since that’s my entry to a main branch.
  2. 2nd level should be visible because these are idea threads which can be developed.
  3. 3rd level should be hidden though because these can be real rabbit holes which needs digging down into actual notes. I show them by expanding the 2nd level.

All other levels can be removed. This would keep the outline usable.