Note taking, TODOs and PKMs

I've been taking notes and scribbling TODO lists, anywhere, for years. It's never been particularly useful until recently. This is the story of how chance, podcasts and silly decisions led to a complete transformation of my noties. How all that note taking effort is actually worth it.

If you keep losing "that post-it" or your table has a stack of half used notebooks, this article could be helpful.

Zim-Wiki started it all

This story begins, many years ago, when I joined Electronic Arts in Madrid. I was starting in the team in charge of making sure the titles were LOC-ed, voiced and language tested in record time. This process was executed at breakneck speeds at the very last months of the projects. Every title in the portfolio had a different tech stack, formats, string notations, file handling, points of contact, ... and so on. There was a lot to learn and very, very, little time to start producing stuff.

I needed something where to jolt some notes, something searchable, perhaps a couple tags to group stuff. In essence I wanted a digital notebook. I remember that enveloop was tired to suggest me to drop my papers and post-its and start using tools, in particular: Zim Wiki

At that time I was running Windows on every machine and all my notes and TODOs were related with professional stuff. My usual entry looked like:

How's FIFA's Perforce organized

Or the very helpful:

Why are we using MS Access in this project?¹

Slowly Zim became part of my jobby-job arsenal. It was possible to enable a bunch of plugins for journals and tags. And digging in the options it was relatively easy to make it behave as a simple but functional task manager. It worked. I liked it at the time. It was enough.

The moment you start using a tool for notes and tasking chances are that you'll discover org-mode. According to its fans is comparable to the second coming of Jesus. And I pinky promise I tried. It looked sick. Super-duper features all over. Also, dunno, it was almost as trying to learn a new programming language and I had a job already. It was too much.

Meanwhile around me Confluence and JIRA were becoming somewhat of a standard in every shop around. And I noticed that it was easy to go back and forth between tickets and documentation.

Back to Zim Wiki, it's important to mention that it stores its data in essentially plain text files on your disk. So even if everything went down in flames it was still theoretically possible to ripgrep the storage and find whatever you were looking for. It also made it quite friendly to Version Control.

On the go: Keep, RTM and Trello

My main issue with Zim was the computer itself. It needed a "real machine": screen, keyboard, mouse, windows, ethernet, ... the whole shebang. So what to do when I was away from a desk, when the only thing at hand was an early mobile phone?

Perhaps inspired by some of the JIRA fluff or maybe because I saw some productivity article referenced in Hacker News. I started exploring the world of tasking and note taking on mobile. I grafted a hideous franken-system:

• Notes: Google Keep
• Simple tasks: Remember The Milk
• Projects: Trello

That should be enough, right? For a personal system it sounds sufficient. Every base covered. Well ...

Any reader at this point will see that "that's too much stuff for a single dude", sadly I wasn't smart enough to see that for a while. And let's remember that Zim was still around. So I had to invest sizeable chunks of time copying and pasting notes and details between systems. The synchronization became a constant source of friction.

As usually happens in these scenarios the whole structure went down. I progressively abandoned everything, Zim included. The only survivor was Google Keep and some minimal RTM and Trello "for particular details".

Apple, Cortex, ATP

In late 2020 I joined the house of blockies². As part of the "new joiner package" I had the chance of getting a company phone. That's how I got my first iPhone. To be honest I knew very little about iOS. I was following that side of the industry through the spectacular ATP podcast, without any hands-on experience. My principal driver was: I'd like to have a slightly faster camera and iPhones seemed quicker at the time.

Soon I understood that the iOS ecosystem was slightly larger than "faster cameras" and tried to expand my understanding of it. That's how I landed in Cortex Podcast. The state of the apps program is usually a good look into what's happening in the iOS and Mac World from the perspective of a user.

In particular this Cortex 105 episode was the first time I heard about Obsidian and more importantly the Zettelkasten method.

Zettelkasten and "Personal Knowledge Management"

Thanks to Cortex I reached the Personal Knowledge Management (PKM) world. In case you're interested in knowing more about this Zettel-thingy, a common starting point are the books of Sönke Ahrens. Ahrens goes in extreme detail over the approach used by Nicklas Luhmann and how to implement it. His web site is also quite interesting.

But it seems like this concept of "how to organize what I've learn" is anything but new. Perhaps the Feynman Technique rings a bell?

The point here is not Zettelkasten itself but the idea that there are better ways of storing and more importantly retrieve and connect information than just: "jotting it down" somewhere and then hope for the best.

What was I after?

A good system for me should look something like this, in no particular order:

With these requirements at hand I ventured again on the search for "the tool".

Logseq

With those requisites in mind I narrowed my options to 2: Logseq and Obsidian.

I'm sure Obsidian is a phenomenal software. But logseq is Open Source and I've been burnt enough times to be very cautious about successful closed source projects. It's as if they tend to get bought down the line by Atlassian or Microsoft or even worse, Google⁴, and then they collapse and disappear.

So, timidly, I took my first steps in logseq, checked the manuals, watched some community videos.

And then I continued.

And then a bit more.

After a couple years of continual use the "show me the graph of my database" looks like this:

Every single dot on that image is "a note" linked to something else. Some of the "central dots" in the image correspond to rust, Family and Programming for example.

Getting started with logseq

Logseq has grown big enough as to have some community generated material. Intro videos, small courses, specific articles about queries and other advanced features.

In this one, for example, Ramses Oudt, tells us about the principles behind logseq and showcases how they work:

If you're interested on testing it yourself, just go to the logseq website and grab the appropriate build⁵.

What's fantastic

I've been following the evolution of logseq for more than two years at this point. I'm quite impressed. Features keep coming fast. It's constantly improving. The introduction of white boards took me totally by surprise:

Seems as if I'm one of those that like to do small drawings and move cards around. This has been tremendously useful for me.

But even the classic features of LS had been a boon: to name just a few:

• Flashcards: when combined with queries this can be truly powerful. I have full books chopped in cards. Useful to learn languages, remember concepts or just randomize a reading.
• Templates: Predefined blocks that can be reached from anywhere. I used them quite frequently to "create new tasks" but I have a fantastic template with a full list of monthly groceries that has saved our online shopping more than once.
• Queries: Come in two flavours, simple and not-so-simple really. I use this feature quite a lot when sorting my tasks in groups. For example this is what I'm using for "things that are scheduled after 3 days from today"

   {
      :title [:h3 "📅 Scheduled > 3 days"]
      :query [:find (pull ?b [*])
      :in $ ?day
      :where
        [?b :block/marker ?marker]
        (not [(contains? #{"DONE" "CANCELED"} ?marker)])
        (or 
           [?b :block/scheduled ?d]
           [?b :block/deadline ?d]
        )
        [(< ?day ?d)]
      ]
      :result-transform (fn [result] (sort-by (fn [r] (get-in r [:block/scheduled])) result)) ; sort the result by the scheduled date
      :table-view? false
      :inputs [:3d-after]
      :breadcrumb-show? false  ; don't show the parent blocks in the result !important, due to result-transform the grouping is lost, and so you will be left with a simple list of TODO items. having those parents blocks mixed in may make the list more confusing. (setting this to true won't show the page btw!)
      :collapsed? true
   }

And, obviously:

• Tasks: Precede your block with a LATER and you're ready to go. That's a task, waiting for you. Or, if you feel fancier you could add some attributes to it, something like:

- LATER `Take out the garbage`
  who:: #@Me
  where:: #@Home

If you want to add a context and a place to your tasking.

And I have to mention the plugins. The whole ecosystem is quite exciting⁶. There seem to be a plugin for almost anything. Perhaps a note of caution here would be that, to my knowledge, plugins are unsupported on mobile.

What's not so good

To my knowledge, as of today, late 2023, there's no build for Android. Or, better phrased, when I look for it in Google Play I can't find it. There are official .apk but I just, ... I can't even. They have a version for iOS in the store and since the iPhone has slowly become my main phone I didn't looked further into it. If Android is essential for you, perhaps take a second look into Obsidian.

It's built on Electron. We all know what that means. It's the sign of the times. It can be slow sometimes. It seems to love to squat on your RAM. It's always "a little bit weird". Perhaps connected with this choice, when reaching thousands of notes the performance can degrade. Opening and re-indexing can be slow. The developing team is working on a migration onto "databases" that's supposed to come soon and alleviate this particular issue.

Even though is perfectly possible to use logseq to write big spans of text you might find yourself fighting against it unless you interiorize the concept of "everything is a block".

On privacy

I used github for months to keep my notes safe and shared between devices. A private repo, that was it. Then GPT happened followed, very closely, by CoPilot. And suddenly I had this eerie intuition that perhaps having every single repository on the hands of Microsoft or Github or whoever is not the best plan.

Lately I'm trying to self host as much as possible. I took a look at gitea and that's what I'm using at home for the bunch of projects I'm working on my own. If you need to collaborate with others there are, IIRC, economical options in Digital Ocean. And probably on many other providers.

Do yourself a favor and consider moving some of your stuff away from Github. They have enough shit already.

This has the added benefit that you can truly let loose and populate your notes with extremely personal details with more confidence. On top of it, if you're using logseq to take notes on PDF documentation there's a big chance of your repository growing big enough as to annoy cloud based services⁷.

In summary

If you're working with a ton of information it's useful to pay attention to the technicalities of storing and retrieving it. For me, the discovery of the PKM field has been an interesting way of reflecting on my approach and hopefully improve it somewhat. This article tries to document a journey that started quite innocently with Zim-Wiki and ended with me hosting git servers at home and taking noties for pretty much everything.

Hope you enjoyed as much as me.