Org-Mode on Wai Hon's Blog

One-Line-Per-Day Diary in Org-mode

whhone@gmail.com (Wai Hon Law) — Fri, 03 Jul 2026 20:00:00 -0700

Recently, I came across these plain text systems and concepts:

The One-Line-Per-Day, One-Page Plain Text Daily Journal: A single, reverse-chronological plain text file to record only the most significant event of each day in a single line.
OBTF (One Big Text File): Putting everything in a big text file.

They resonated me because they match very closely with how I keep my daily diary in Org-mode!

The One-Line-Per-Day Format

I keep my diary in a one-line-per-day format. Under this system, each day is represented by a single line using Org-mode’s description list syntax:

Level-1 heading: The Year (e.g., * 2026)
Level-2 heading: The Week, containing the week number, date range, and a brief weekly highlight (e.g., ** W25 (06-15 - 06-21) - Weekly highlight)
List items: One line per day, starting with an inactive timestamp and a description separator (::) followed by the day’s events.

Here is an example illustrating a complete recent week:

* 2026

** W26 (06-22 - 06-28) - Run 3 times. Mele X1! CPU PL1/PL2/Multpilers. TPM: LUKS + SSH.

- [2026-06-22 Mon] :: Team dinner.
- [2026-06-23 Tue] :: Running. Daycare fire false alarm. Primes day Mini PC research.
- [2026-06-24 Wed] :: Buy Mele X1.
- [2026-06-25 Thu] :: Running. Benchmark Mele X1. Good single core performance. Emacs startup time ~0.4s.
- [2026-06-26 Fri] :: Bike to pick up. Dinner: YAYOI.
- [2026-06-27 Sat] :: TIL: Performance Copilot (pcp). Arch: migrate to systemd + sd-encrypt. TPM: LUKS unlock + SSH Agent.
- [2026-06-28 Sun] :: Running. Order Square Paper. Termux workaround with non-local network.

Daily Entries

At the end of every day, I go to the top of diary.org, add a line for today with the things that worth remembering.

To make writing daily entries frictionless, I use a simple Emacs Lisp helper. I use the following function to insert today’s date formatted as an inactive timestamp:

(defun my/insert-current-date ()
 "Insert today's date in Org inactive format."
 (interactive)
 (insert (format-time-string "[%Y-%m-%d %a]")))

I bind this command to a key combination for quick access:

(keymap-global-set "C-c s d" #'my/insert-current-date)

With this helper, starting a daily log is as simple as typing - (or using M-RET to start a list item), calling the function, typing ::, and entering the daily highlight.

Weekly Highlight

At the end of each week (Sunday), I pick the things worth highlighting from my daily entries and put them in the weekly heading. This allows me to look back at my past weeks, know what happened, and feel like my days count.

Why This Works Well

This format has greatly improved both writing and searching:

Self-Contained Search Results: Since the date and the content of the entry reside on the same line, searching with consult-line or ripgrep returns the full context directly. A search for a keyword like “sourdough” immediately displays the date it happened without needing to check parent headings.
Compact File Structure: The outline remains clean and fast to fold and navigate, with only weeks and years as headings.
Lower Friction: Writing a single line per day lowers the cognitive barrier to journaling. Even on busy days, it is easy to jot down a quick summary.

I am also using a diary-work.org to track my daily work similarly.

Conclusion

This layout is a lightweight and sustainable way to keep a daily log. By using Org-mode’s description lists and automating timestamp insertions, the diary remains clean, highly readable, and easily searchable for years to come.

Appendix: Screenshot

This is how the diary.org looks like:

Refining Org-mode Deadlines

whhone@gmail.com (Wai Hon Law) — Sun, 24 May 2026 22:00:00 -0700

For a long time, I didn’t use deadlines in Org-mode at all. However, over the past year (or perhaps even longer, though I forget exactly when), I have found myself relying on them more and more. Deadlines have quietly become the backbone of my day-to-day productivity.

A New Prioritization Hierarchy

In my earlier post on task management workflow, my day-to-day focus was heavily centered around scheduled dates and TODO states. Today, my prioritization hierarchy has fundamentally evolved to:

Deadline + Priority > Schedule > TODO States

Deadlines + Priorities represent my primary focus. Deadlines show what must be delivered and when, while priorities help determine which deadline to tackle first. Together, they serve as the main driver for my planning.
Scheduled dates are reserved for habits, recurring chores, or temporary “snoozing” (hiding tasks until they need to be revisited).
TODO States (like NEXT or PROG) act as a backlog of next actions. If my deadline and prioritized items are blocked or completed, I look here to see what to pick up next.

Default Org Agenda View

However, the default deadline behavior in Org-mode didn’t really work for me. Out of the box, deadlines look identical to scheduled tasks, and the short warning window makes them hard to plan around.

Here is the default Org agenda view:

Customized Org Agenda View

To support this deadline-first workflow, here are two tricks I used to turn Org-mode deadlines into a powerful planning tool.

Here is the customized Org agenda view:

Trick 1: Visual Deadlines with Custom Leaders and Sorting

In the Org agenda view, distinguishing scheduled tasks from deadlines at a glance is surprisingly difficult. Because they share a similar layout and color palette, a looming deadline can easily get lost in a sea of routine scheduled chores.

To solve this, I customized the “leaders” (the prefix text shown in the agenda) by prepending a bright red circle emoji (🔴) to all deadline items. This makes them immediately pop out.

Also, sort deadeline at the very top lines by customizing the org-agenda-sorting-strategy to clearly separate “deadline” and “scheduled” items.

Here is the Elisp configuration I use:

;; Shorten the leaders to reserve spaces for the repeater.
(setq org-agenda-scheduled-leaders '("Sched" "S.%2dx"))
(setq org-agenda-deadline-leaders '("🔴 0d" "🔴%2dd" "🔴-%1dd"))

(defun my/org-agenda-repeater ()
 "The repeater shown in org-agenda-prefix for agenda."
 (let ((pom (org-get-at-bol 'org-marker)))
 (if (or (org-get-scheduled-time pom) (org-get-deadline-time pom))
 (format "%5s: " (or (org-get-repeat) ""))
 "------------")))

;; Add repeater and effort to the agenda prefixes.
(setq org-agenda-prefix-format
 '((agenda . " %i %-12:c%?-12t%s%(my/org-agenda-repeater)")))

;; Add deadline-up to agenda to separate schedule and deadline.
(setq org-agenda-sorting-strategy
 '((agenda deadline-up habit-down time-up priority-down category-keep)))

This is an extension of my previous post on distinguishing repeated tasks. By shortening the scheduled leaders, we free up horizontal space for the repeater interval. The addition of the 🔴 emoji ensures that any item with an active deadline immediately commands attention.

Trick 2: Expanding the Warning Window to a Month

By default, Org-mode starts warning you about a deadline 7 days in advance. While a week sounds reasonable, in practice, it is often too short.

When a deadline suddenly appears on your agenda with only 7 days to go, it can easily disrupt your cadence. Since 7 days technically translates to only 5 working days, you might already be fully committed to other urgent tasks. Instead of helping you plan, a short warning window simply induces stress.

To fix this, I increased the default warning period from a week to a month (35 days, or 5 weeks):

(setq org-deadline-warning-days 35)

With a 35-day warning window, upcoming major deadlines are visible on the agenda far in advance. This gives me ample time to adjust my weekly plan and budget resources before the deadline becomes urgent.

Of course, not every task warrants a month-long warning. For minor tasks, you can override the default warning period on a per-item basis. For instance, you can use the -3d syntax to only trigger a warning 3 days prior:

DEADLINE: <2026-06-19 Fri ++28d -3d>

Conclusion

I used to find schedules and deadlines somewhat overlapping in Org-mode. However, separating them into distinct roles, by using custom leaders for urgency and a longer warning window for planning, has made my agenda a lot easier to parse. It is a simple config tweak, but it has made my planning a bit smoother.

Distinguish Repeated Tasks in Org Agenda

whhone@gmail.com (Wai Hon Law) — Fri, 03 Jan 2025 18:00:00 -0800

Problem: Repeated or Not?

In the Org agenda view, repeated and non-repeated tasks look identical. This similarity makes me hesitant to mark a task as DONE; if a task that should be recurring is missing its repeater (e.g., ++1w), it will disappear permanently from the agenda instead of being rescheduled.

It would be helpful if repeated tasks were visually distinct in the Org agenda, for example, by displaying the repeater interval (++1w) as part of the entry.

Solution: Setting the Prefix Format

Thanks to a tip from yantar92 (the current Org maintainer), I was able to add the repeater to the Org agenda using org-agenda-prefix-format. The process involves three steps:

Shorten the scheduled leaders to make space for the repeater.
Add a function to retrieve the formatted repeater.
Include the new function in org-agenda-prefix-format.

This requires only a few lines of Elisp:

;; Shorten leaders to reserve space for the repeater.
(setq org-agenda-scheduled-leaders '("Sched." "S.%2dx"))
(setq org-agenda-deadline-leaders '("Deadl." "In%2dd" "D.%2dx"))

(defun my/org-agenda-repeater ()
 "Return the repeater string for the current agenda entry."
 (if (org-before-first-heading-p)
 "-------" ; Align with the time grid
 (format "%5s: " (or (org-get-repeat) ""))))

;; Add `my/org-agenda-repeater' to the agenda prefix format.
(setcdr (assoc 'agenda org-agenda-prefix-format)
 " %i %-12:c%?-12t%s%(my/org-agenda-repeater)")

Alternatives

Using the Agenda Finalize Hook (Hacky)

Before learning about yantar92’s tip, I used a hackier solution (gist):

Fetch the repeater using text properties associated with the agenda entry.
Use org-agenda-finalize-hook, which runs after the agenda view is built but before it is displayed, to insert the repeater string.

Using Column View (Cluttered)

Prior to that, I tried another solution using column view (M-x org-agenda-columns). This method involves setting the :COLUMNS: property to display the SCHEDULED date as a separate column.

(setq org-columns-default-format-for-agenda
 "%TODO %PRIORITY(Pri) %60ITEM(Task) %SCHEDULED")

While this approach works and is built-in, the resulting display is verbose and difficult to parse visually. This led me to seek a better solution with custom Elisp.

Implementing the PARA Method in Org-mode

whhone@gmail.com (Wai Hon Law) — Sat, 31 Dec 2022 00:00:00 -0800

This post first talks about the PARA method and then my Org-mode implementation for organizing tasks and notes.

The PARA Method

The PARA Method is a modern system for organizing digital information. It stands for Projects-Areas-Resources-Archives, the four categories of all digital information.

Project: a series of tasks linked to a goal, with a deadline.

Area: a sphere of activity with a standard to be maintained over time.

Resource: a topic or theme of ongoing interest.

Archive: inactive items from the other 3 categories.

Project vs Area vs Resource

“Projects” and “Areas” are inherited from GTD. “Distinguish Project and Area” is a common challenge for GTD and PARA adopters, including me. I once had many unimportant projects without deadlines that cluttered my agenda. There are many discussions and articles on it¹ and the model answer is to check (1) the nature of the task and (2) if there is a deadline.

A project has (1) a specific outcome/goal and (2) a deadline.

An area has (1) a standard to be maintained that (2) is continuous over time.

In addition to the model answer, I have my interpretation,

Projects contain the tasks I should focus on (because of the importance, urgency and desirability). They have higher priority over the other categories. I work on them first, especially when there is a chunk of uninterrupted time or my energy level is high. If a “project” does not come with a deadline, I set one for it.
Areas contain the tasks I have to do. I reserve some time for these tasks every day to keep areas maintained. I can also skip them for a while when the current projects are too demanding.
Resources contain the tasks I am interested to do. When there is no pressure from projects or areas, I can choose to work on these tasks or simply take a rest.

	Project	Area	Resource
Need my focus	Yes	No	No
Have to do	Maybe	Yes	No
Want to do	Maybe	Maybe	Yes
Priority	High	Medium	Low

These three questions help decide which PARA categories a task should go to:

Does it require my focus within a timeframe? If yes, make it a project.
Is it something I have to do? If yes, move it to an area
Is it something I want to do? If yes, move it to a resource.

PARA is Pragmatic

On one hand, I organize my tasks. On the other hand, I know it is not necessary to get it perfect.

Firstly, it takes a lot of effort. I move forward and do the actual work when the tasks are by-and-large in the right places that help to prioritize. The end goal should be the actual outcomes instead of organizing.

Secondly, it is impossible. PARA is a system of single classification. Everything is either a project, an area, or a resource. In practice, a task or note can fall into multiple projects, areas, or interests. For example, “planning a trip for the 10-th anniversary” could arguably belong to either area “spouse” or area “travel”.

Organizing should be forgiving. It is okay to organize wrongly as long as it works. PARA is not a system for perfectionism but for pragmatism.

Let’s talk about my implementation!

Org-mode Implementation

I organize my tasks with PARA using a single todo.org file.

Tags and Categories

I use tags for the actual areas and resources. I assign each of them a specific tag to the corresponding subheadings. This gives me a set of controlled vocabularies for tagging projects and notes. For example, I know I should use writing instead of write or blogging for area “writing”. I don’t create tags for projects (which are short-term and grow over time) to keep my tag set small and useful².

I use categories for the PARA top categories, Project-Area-Resource. When looking at my org agenda view, I immediately know which tasks are my top focuses (Project), which are things I need to do (Area) or interested to do (Resource). I also know which exact area or resource they belong to with the tags on the right.

Tip: I can filter tasks by category and tag by pressing / (M-x org-agenda-filter) and clear filters with | (M-x org-agenda-filter-remove-all).

Organizing my Notes

For project notes, I add or link them directly under the corresponding org subtree in todo.org as I avoid adding project tags. When a project is completed or canceled, I convert the reusable part into the area or resource notes, and archive the project subtree to todo.org_archive.

I place the areas and resources notes under ~/note. I tag them with the tags defined in todo.org and reserve the directory hierarchy³ for the note types. This gives me the flexibility to have multiple tags for a note.

Here is a simplified version of my org directory:

org
├─ todo.org
└─ note
 ├─ 20221125T211904--org-attach__emacs.org
 ├─ ...
 ├─ meta
 │ ├─ ...
 │ └─ 20200202T222222--using-org-mode__emacs.org
 └─ reference
 ├─ article
 │ ├─ ...
 │ └─ 20221226T150449--creating-family-rules__parenting.org
 └─ book
 ├─ ...
 └─ 20220907T134123--building-a-second-brain-tiago-forte__pkm.org

note/20221125T211904--org-attach__emacs.org is a regular note.
note/meta/20200202T222222--using-org-mode__emacs.org is a meta note that connects other notes, like the org-attach__eamcs.org above.
note/reference/article/20221226T150449--creating-family-rules__parenting.org is a reference note for the article “Creating Family Rules”, tagged with my resource “parenting”.
note/reference/book/20220907T134123--building-a-second-brain-tiago-forte__pkm.org is a new book note for the book “Building a Second Brain” by Tiago Forte.

So far, I don’t archive notes under ~/note. If I need to, I might use the tag ARCHIVED and write some elisp to filter them.

Conclusion

Defining how I am going to organize my digital information reduces the cognitive load when working with tasks and notes. I can add or retrieve the information without thinking too much.

I love to learn how other people works and I hope this post could be interesting and helpful to you, too. If you like it, you probably also check out these:

Tassin’s implementation which combines Org-mode and Evernote for tasks and notes respectively.
Emacs CODE implementation which focuses on its note taking workflow with lots of details.

Search them yourself or read this great article: Project People vs. Area People - Forte Lab. ↩︎
It is suggested to use a self-defined set of tags and keep them as few as possible. ↩︎
That is why using denote with subdirectories is important for me. ↩︎

Using Denote with Subdirectories

whhone@gmail.com (Wai Hon Law) — Thu, 08 Dec 2022 00:00:00 -0800

My last post mentioned the out-of-the-box experience of Denote is not so great, especially when having notes across many subdirectories. By default, Denote searches and creates notes from the root denote-directory. I need to know the exact file location before searching for a note. I need to move note from the root directory to subdirectories after creating the note.

The good news is that, these issues are now fixed and this post talks about how.

#1 Search by Filename in Subdirectories

By default, Denote searches only in the denote-directory. To find a note hidden inside a subdirectory, the user needs to know the path to that file and navigate there. Needing to know the exact directory to be able to search for a file is counter-intuitive.

However, thanks to a recent (2022-11-18) refactoring by nobiot@, it is no longer the case! The commit makes notes inside subdirectories searchable with common Denote commands like denote-open-or-create and denote-link-*. This greatly improves the out-of-the-box experience of Denote. Update Denote to a newer version including this new change!

#2 Full-Text Search in Subdirectories

By default, Denote does not come with any command for full-text search.

However, it could be done easily with consult-ripgrep.

(defun consult-denote-ripgrep ()
 "Search with ‘rg’ for files in denote-directory where the content matches a regexp."
 (interactive)
 (consult-ripgrep denote-directory ""))

#3 Create Notes in Subdirectories

By default, Denote creates notes in the root denote-directory. Every time after creating a note, I need to move them manually to the right subdirectory. This is cumbersome.

However, it turned out to be my fault of not reading the official documentation, which has already suggested two ways to select a specific directory when creating a new note:

includes subdirectory to denote-prompts, or
uses M-x denote-subdirectory.

I go with (1) because it works with all Denote commands that could create a note, like denote-open-or-create and denote-link-or-create. It also allows other customizations to denote-prompts. For example, I prefer setting “subdirectory” before “title” (reorder title and subdirectory) and updating keyword later with denote-keyword-* (remove keyword from denote-prompts).

(setq denote-prompts '(subdirectory title))

If you have too much subdirectories, use denote-excluded-directories-regexp to exclude some of them.

Comparing with Org-roam Again

With these tweaks, I can now use Denote as my primary note-taking package.

I mentioned a concern with the link type denote: in my last post. It turns out to be not concerning because it is easy to migrate to or away from this link type with some elisp. I don’t use other features like org-roam-daily, org-roam-bibtex, or org-roam-ui at all. The last step before removing Org-roam is probably migrating the existing links.

Denote vs Org-roam

whhone@gmail.com (Wai Hon Law) — Sun, 27 Nov 2022 00:00:00 -0800

Updates

2022-12-08: Check out the followup post Using Denote with Subdirectories to improve the out-of-the-box experience of Denote.

Denote is getting popular in the Emacs community recently. I decided to give it a shot, learn how it works and see if I should migrate from Org-roam to it. I am writing this blog post to compares Denote with Org-roam.

In essence, Denote is a note-taking package for Emacs based on its file-naming scheme, which works for all kinds of files. Org-roam is a note-taking package for Org-mode, utilizing a database indexing org files.

Key Differences

Identifier and Linking

Denote uses the timestamp in its file-naming scheme as the identifier and uses its link type denote: for linking. This approach allows notes to be taken in other formats (.md and .txt).

Org-roam uses the ID properties as the identifier and the built-in link type id: for linking. It sticks with the Org-mode ecosystem. It utilizes an external database to indexes note metadata, like titles, tags, and locations and searching notes efficiently without parsing any org files. When working on multiple computers, the user might need to re-index the org files.

This is the biggest architectural difference between Denote and Org-roam. If all notes are written in Org-mode, I find Org-roam provides cleaner org files because it does not introduce a new link type.

Supported Formats

Denote works for all files. Not only can the user take notes in Org-mode, Markdown, or Txt, but also name a PDF file so that it could be identified, linked, searched and tagged.

Org-roam works for only Org-mode files. It leverages the mature Org-mode ecosystem. For example, the user can use org-attach to associate a PDF file with a note.

Frankly speaking, Denote is designed for Emacs users. Org-roam is designed for Org-mode users.

File-naming Scheme

In a file-based note system, it is inevitable to have coupling between the filename and the content (e.g., keeping #+TITLE: and file name in Org-mode).

Denote answers with its file-naming scheme and need to keep filename consistent and update-to-date so that search results remain valid after changing title or tags. Maintaining the naming scheme could become a burden without any automation. Denote provides denote-rename-* and denote-dired-rename-* for the job.

Org-roam does not enforce any file-naming scheme. The default org-roam-capture-templates uses the creation timestamp and title slug as the filename, and that is all.

Note that the Denote file-naming scheme has a limitation: cannot define a tag with multiple words. For example, the tag “note-taking” becomes two tags “note” and “taking” unless combining them to “notetaking”.

Searching Mechanism

Utilizing its file-naming scheme, Denote can efficiently search for a note by filename without parsing the content of the file. Users can search notes with titles and tags by prefix - and _ respectively. The out-of-the-box experience does not fit my need. Users need to write some emacs lisp or learn Dired to search efficiently.

Org-roam provides better out-of-the-box searching experience. With a little customization, I can search notes by folder name, title, and tags, recursively across sub-folders, sorted by the last modification time. This suits most of my needs.

It is nice to eradicate the dependency on a database with Denote. However, I found it hard to replicate the Org-roam searching experience with Denote, especially sorting notes by last modification time within subdirectories. Note that full-text search could be achieved by counsel-rg for both.

Denote Comparison to Org-roam

Pros

No database is needed. Seamless across multiple machines.
A simple but powerful file-naming scheme that works for all files.
Allow notes in other formats (txt, md). (Not for me. All my notes are in org.)

Cons

Uses non-standard link type denote:.
Worse out-of-the-box searching experience. (I believe it is hackable)
Tag with multiple words like “note-taking” becomes “note” and “taking”

My Choice

It is tempting to eradicate the dependency on a database with a simple file-naming scheme. However, I am hesitant to introduce denote: to my org files and want to develop a searching experience that on is par with Org-roam first.

I decided to stick with Org-roam but keep exploring Denote in the next couple of weeks. Stay tune :-)

Appendix

My Denote configuration

Use Syncthing with WebDAV to Sync Everywhere

whhone@gmail.com (Wai Hon Law) — Fri, 04 Nov 2022 00:00:00 -0700

I have been using Syncthing with Caddy’s WebDAV to synchronize my Org Mode files across computers and mobiles for few weeks. I am satisfied with it and writing this post about the setup.

Why not just Syncthing?

My previous setup use solely Syncthing to synchronize them across computers and mobiles. While Syncthing works great on computers, it is problematic on mobiles because mobile can switch networks, have a limited battery, and have limited background sync capability (especially on iOS). Out-dated files or conflicts happen more often to me when I use a mobile device.

I noticed some Org Mode mobile apps (like “beorg” and “Orgzly”) support WebDAV sync. Hence, I tried to add a WebDAV entry point for my org files and see how it goes.

Overview

I run Syncthing and WebDAV both watching the same org directory on a tiny server, Raspberry Pi 3B. Computers and mobiles are connected with Syncthing and WebDAV respectively.

WebDAV Setup

I first tried Nextcloud but chose Caddy eventually to set up WebDAV.

Attempt #1: Nextcloud

My first attempt was using Nextcloud’s WebDAV, after searching “Syncthing WebDAV” and found this story.

I added the Syncthing’s local folder to Nextcloud via external storage so it could be accessed from WebDAV. It worked. It proved that Syncthing with WebDAV is a viable solution.

However, Nextcloud is too heavy for my Raspberry Pi 3. The latency is high enough to degrade the mobile experience. This could be a good solution for existing Nextcloud users with a faster hosting machine.

Attempt #2: Caddy WebDAV

Since my Raspberry Pi is already using Caddy as the web server, why not give Caddy’s WebDAV a shot? Caddy is written in Go and should have better performance.

The WebDAV module was not built-in and I need to built a new Caddy binary with xcaddy.

To get the file permission right, I previously ran the Caddy web server as a non-caddy user (the same user as syncthing). My new approach is to use bindfs to bind the syncthing directory to a directory readable and writable by the caddy user. This way, I can securely run the Caddy process as the caddy user.

Here is the bindfs command I use:

sudo bindfs --mirror=caddy /path/to/my/syncthing/dir /path/to/webdav

To persist this over system restarts, I added the following line to /etc/fstab:

# /etc/fstab
/path/to/my/syncthing/dir /path/to/webdav fuse.bindfs mirror=caddy,allow_other,x-systemd.automount 0 0

It worked and indeed ran so much faster than Nextcloud. I am satisfied!

Here is the snippet from my Caddyfile WebDAV config.

my.webdav.host {

 basicauth * {
 <user> <hash>
 }

 root * /path/to/webdav

 @get method GET
 route {
 file_server @get {
 hide .git .gitignore .stfolder .stversions
 browse
 }

 webdav
 }
}

Android and iOS Setup

I use beorg on iOS and Orgzly on Android. Both of them support “WebDAV” with “Auto-sync”. “Auto-sync” performs a sync when a note is changed or when the app is resumed. This greatly reduces the chance of conflict, when compared with Syncthing.

In addition, I found beorg also comes with a LISP runtime (BiwaScheme) and allows users to customize the app in a way similar to Emacs. The customization is limited at the moment but it has the potential!

Syncthing Setup

I use most of the default configuration with two tweaks.

Tweak #1: Reduce File Watch Delay

I reduce the fsWatcherDelayS from 10s to 1s in all instances. This makes the synchronization happens more instantly and seamlessly between devices. For example, when I make a change on the phone, it updates the Raspberry Pi and synchronizes across other computers in a second.

Tweak #2: Restart Syncthing on Wakeup

When waking up from sleep, Syncthing can take quite a while to recover the connection.

Syncthing used to provide an option called restartOnWakeup to restart Syncthing on wakeup and avoid this long delay. However, this option has been removed in 2022. I replicated this behavior myself, by writing a script to restart Syncthing, and running it on wake up.

A Script to Restart Syncthing

Creates a script to hit the REST endpoint (/rest/system/restart) on the local Syncthing instance.

LOCAL_ENDPOINT=http://localhost:8384
LOCAL_API_KEY=<API_KEY>

echo "Restarting Local Syncthing"

curl --silent -H "X-API-Key: ${LOCAL_API_KEY}" \
 --connect-timeout 1 \
 -X POST \
 ${LOCAL_ENDPOINT}/rest/system/restart

Run the Script on Wakeup (MacOS)

For MacOS, uses sleepwatcher to detect wakeup event and execute the above script.

First, install and start sleepwatcher service.

# To install sleepwatcher
brew install sleepwatcher

# To start sleepwatcher now and restart at login
brew services start sleepwatcher

Second, creates another script ~/.wakeup, which will be executed by sleepwatcher on system wakeup.

/path/to/syncthing-restart.sh

Run the Script on Wakeup (Linux)

For Linux, creates a script under /usr/lib/systemd/system-sleep/, which will be executed both “pre” and “post” system sleep.

#!/bin/sh

case $1 in
 post)
 /path/to/syncthing-restart.sh
 ;;
esac

Credit to this blog post.

Run the Script on Wakeup (ChromeOS)

Unfortunately, the Linux systemd method does not work for ChromeOS via Crostini. My solution is to use a script to check the system timestamp every second. If the current timestamp and the last timestamp differ more than 3 seconds, then I consider it as a system wakeup.

#!/bin/bash

last=$(date +%s)

while true; do
 current=$(date +%s)

 if [[ $(($current - $last)) -ge 3 ]]; then
 echo "Detected wake up. Restarting Syncthing."
 /path/to/syncthing-restart.sh
 fi

 last=${current}
 sleep 1
done

Then, I create a systemd service (~/.config/systemd/user/sleep-watcher.service) to run this script in the background.

[Unit]
Description=Sleep Watcher Service

[Service]
Type=simple
StandardOutput=journal
ExecStart=/path/to/the/above/sleep-watcher.sh

[Install]
WantedBy=default.target

Once it is ready, reload systemd, start and enable the service.

systemctl --user daemon-reload
systemctl --user enable --now sleep-watcher

Conclusion

Syncthing works brilliant on computers and laptops with the tweaks mentioned above. WebDAV is simple and cheap to host. It is secure to use over the Internet when pairing with BasicAuth and HTTPS (both supported by Caddy). It is not a perfect synchronization tool but good enough to fill the mobile gap.

An Org-mode Workflow for Task Management

whhone@gmail.com (Wai Hon Law) — Sat, 31 Oct 2020 00:00:00 -0700

As mentioned in the last post, I switched to Org-mode. I kept adjusting my workflow with this new tool and it has been stabilized for a month. I think it is time to talk about the new workflow for task/time management with Org-mode. This blog post consists of four parts: the principles, the definitions, the workflows, and finally the implementations.

1 The Principles

Principles remain valid no matter what the tool is.

1.1 Do Not Add Tasks Indiscriminately

Not every task should go into the system. Avoid filling the system with bullshits and diluting the things that matter. I only add tasks that I really want or need to do.

To clarify¹, the task management system described below is not the “inbox” in GTD. I still capture things into my inbox but not all of them will be converted to a task in the task management system (org agenda files) eventually.

1.2 Not All Tasks Have To Be Done

There are two reasons for this. First, tasks could be deprioritized or even unnecessary. Second, we have limited time and cannot do everything. We should have an opinion on the priority.

1.3 Reduce The Number Of Open Loops

Open loops are tasks that have been started but not finished. They stay in our minds and occupy some of our limited working memory so that we cannot focus on another task we are working on.

Also, open loops reduce agility, according to Little’s Law. The more the open loops, the longer time to finish each of them on average.

1.4 Reduce Decision Making Of What To Do Next

The system should suggest to the user what to do next so that the user can reserve the will power to the real task. This also avoids skipping hard tasks with easy tasks unconsciously.

2 The Definitions

Each task in Org-mode has a TODO keyword, optionally a scheduled date, and a deadline. For example,

* PROG Write a blog post on task management with Org-mode
DEADLINE: <2020-11-07 Sat> SCHEDULED: <2020-10-31 Sat>

Each Org-mode user could define their own set of TODO keywords and use scheduled dates and deadlines differently. For example, some people use only two TODO keywords, “TODO” and “DONE”, while some use more. Some people set “scheduled dates” to all the tasks while some people set it to some of the tasks. These nuances could result in a hugely different workflow, although they are using the same Org-mode. Let’s take a look at how I use them.

2.1 TODO Keywords

I use as few TODO keywords as possible but not too few. For example, it is common to use only two states (“TODO” and “DONE”) but this does not align with the principles I mentioned above. I need a state for “open loops” so that I can keep the number of them small. I also need to distinguish a smaller set of “next actions” from all tasks.

So far, I defined these five keywords:

TODO Keyword	Definition
`TODO`	Tasks that are not started and not planned. They could be the backlogs or the GTD’s someday/maybe. These tasks could be converted to `NEXT` during a review.
`NEXT`	Tasks that are not started but planned to do as soon as I can. When there is no actionable `PROG` (e.g., blocked), I start one of those and convert it to `PROG`.
`PROG`	Tasks that are working in progress (open loops). I work on these tasks before starting another `NEXT` task to avoid too many open loops at any moment.
`INTR`	Tasks that are interruptions. They are urgent things that I should drop everything else and work on it. For example, production issues.
`DONE`	The tasks that are completed.

This diagram illustrates the transition of those states.

 +------+
| INTR |
+------+
|
v
+------+ +------+ +------+ +------+
| TODO |-->| NEXT |-->| PROG |-->| DONE |
+------+ +------+ +------+ +------+

2.2 Scheduled and Deadline

In the past, I tended to set a date for all tasks. If I want to do A, B, and C on Monday, then I schedule them for Monday. This sounds intuitive but, in reality, I ended up rescheduling many incompleted tasks at the end of every day. It was not only wasting time but also depressing.

Later, I changed to rely more on the TODO keywords. For example, if a task is still in progress, I keep the state unchanged as PROG instead of rescheduling it every day until it is done. I am now using the “scheduled date” to hide a task until the date I should look at it again. Similar to the snooze feature in Gmail.

Date	Definition
`SCHEDULED`	Hide the task until the scheduled date.
`DEADLINE`	The deadline of the task.

For example, when a PROG task is being blocked, I set the SCHEDULED date to hide it until the date I want to revisit. On the scheduled date, if the task is unblocked, I will remove the SCHEDULED date. If the task is still blocked, I reschedule it again. It acts as the waiting for list in GTD.

3 The Workflow

I customize my org agenda view to drive my daily workflow. The customized agenda view has four sections. From the top to bottom, they are the tasks scheduled today, the INTR tasks, the PROG tasks, and finally the NEXT tasks.

My daily workflow goes from the top to the bottom.

3.1 Update Tasks Scheduled Today

At the beginning of the day, I review the tasks that are scheduled for today. The goal here is not to finish them, but to update or remove the scheduled date so that there is nothing left.

If the task is still blocked, reschedule it
If the task could be done in a few minutes, then do it and mark it as DONE.
Otherwise, remove the scheduled date and optionally update the TODO keywords.

Removing the scheduled date is the best outcome. It indicates the previous estimation was correct, at least not too early. Rescheduling indicates the previous estimation is inaccurate. I would avoid rescheduling the task to tomorrow indiscriminately and try to make a good estimation to reduce the number of rescheduling.

3.2 Find the Next Task to Work On

After reviewing all tasks scheduled for today, it is time to pick a task and do some real works. This step is straight-forward with the customized agenda view above.

Pick an INTR task if there is any.
If there is no INTR task, then pick a PROG task and work on it. If that task is blocked, set a SCHEDULED date to hide it.
If there is no INTR and PROG task, then start a NEXT task.
If there is no task in the agenda view, then review the TODO tasks and convert some to NEXT.

3.3 Review the System

The secret of having a system that works in the long-term is regular maintenance. I do it at least once a week. For examples,

Promote some tasks from TODO to NEXT. Demote or even delete deprioritized tasks.
Review the journal and add TODO if something needs follow-up.
Archive completed tasks and extract to permanent notes².

4 The Configuration

Finally, here is the configuration for the above workflow.

;; TODO keywords.
(setq org-todo-keywords
 '((sequence "TODO(t)" "NEXT(n)" "PROG(p)" "INTR(i)" "DONE(d)")))

;; Show the daily agenda by default.
(setq org-agenda-span 'day)

;; Hide tasks that are scheduled in the future.
(setq org-agenda-todo-ignore-scheduled 'future)

;; Use "second" instead of "day" for time comparison.
;; It hides tasks with a scheduled time like "<2020-11-15 Sun 11:30>"
(setq org-agenda-todo-ignore-time-comparison-use-seconds t)

;; Hide the deadline prewarning prior to scheduled date.
(setq org-agenda-skip-deadline-prewarning-if-scheduled 'pre-scheduled)

;; Customized view for the daily workflow. (Command: "C-c a n")
(setq org-agenda-custom-commands
 '(("n" "Agenda / INTR / PROG / NEXT"
 ((agenda "" nil)
 (todo "INTR" nil)
 (todo "PROG" nil)
 (todo "NEXT" nil))
 nil)))

Thanks for this comment in Reddit. ↩︎
There will be another post for Org-mode note-taking workflow. ↩︎

From Evernote to Org-mode

whhone@gmail.com (Wai Hon Law) — Thu, 03 Sep 2020 00:00:00 -0700

Since 2017, Evernote has been my productivity system for note-taking and task management. I thought it was my ultimate system to stick with. It has served me so well and I have even became a paid user. However, mentioned in the last post, I am pursuing more privacy in my digital life. I want to take my notes with a peace of mind, without worrying they are being watched or leaked.

This post talks about the privacy concern, my research on the alternatives, and the switch to Org-mode.

1. The Privacy Concern of Evernote

The user data in Evernote is encrypted “during transport” and “at-rest”. This sounds secure to readers but actually not enough because Evernote can still see the content. Technically, it is still server-side encryption instead the client-side encryption (a.k.a. end-to-end encryption). The encryption key of the note content is held by the server instead of the client. If the server is hacked, or there is an evil employee, or Evernote needs to comply with legal obligations (i.e., the government asks for user data, and it does), those notes could be leaked.

2. Researching the Alternatives

I started researching the alternatives which do not compromise privacy. That means end-to-end encryption is required if the data is hosted on a third-party. This requirement actually simplifies my curation because many solutions are ruled out, including the popular Notion and Roam (o:

My final shortlist included Org-mode, Joplin, Standard Note, Taskwarrior, TODO.txt, and TiddlyWiki. I gave each of them a try, reviewed and scored them with my requirements below:

Privacy Can I seclude my data?
Basic Task Management: Can I set a date for a task and then view all tasks for today?
Task Context: Can I add references (instruction, link) to the task?
Linux Usability: How usable is it on Linux?
Android Usability: How usable is it on Android?
Synchronization: How hard is it to synchronize data between Linux and Android?

	Evernote	Org-mode	Joplin	Standard Note	Taskwarrior	TODO.txt	TiddlyWiki
Privacy	1	5	5	5	5	5	5
Task Management	4	5	1	1	5	5	?
Task Context	5	4	4	5	2	1	?
Linux Usability	4	5	4	4	3	3	?
Android Usability	5	3	3	4	2	2	?
Synchronization	5	4	5	5	4	4	?
Total	24	26	22	24	21	20	?

Review: Evernote (24)

Evernote has a reminder feature for simple task management, which is already enough for me. Since it is a note-taking app, I can add rich context like images or even audio seamlessly. Tusk makes it usabe on Linux and the official Android app is simply awesome. Synchronization works out-of-the-box.

However, it fails on the privacy bit.

Review: Org-mode (26)

Org-mode is for keeping notes, maintaining TODO lists, planning projects, and authoring documents with a fast and effective plain-text system. It is absolutely capable.

However, the learning curve of Org-mode is steep and even steeper for non-Emacs users. Users are expected to read documentation and practice. Once familiarized with Emacs, its usability on Linux will jump from 0 to 5 (or even infinity). The Android client Orgzly is usable but could be better. Synchronization works with SyncThing.

Review: Joplin (22) and Standard Note (24)

Joplin and Standard Note are both strong note-taking alternatives to Evernote. However, they suck in task management because they simply cannot show all tasks scheduled for today. They both have a decent desktop app written in Electron. Synchronization works natively and users can turn on end-to-end encryption for privacy/security.

If task management is not a requirement, both Joplin and Standard Note are very good alternatives.

Review: Taskwarrior (21) and TODO.txt (20)

Taskwarrior and TODO.txt are both FOSS for task management. However, they both allow only one line per task, which makes adding extra context to the task very hard. Their clients are barely usable to me (or I have not learned enough). Secure synchronization works with a self-hosted server or with SyncThing for Taskwarrior and TODO.txt respectively.

Review: TiddlyWiki (?)

TiddlyWiki is a “non-linear personal web notebook”. It looks fancy but I haven’t tried it intensively because Org-mode seems working for me already at this point. I will leave it as a question mark.

3. Switching to Org-mode

After all these explorations, Org-mode looks promising to me and I started the Org-mode/Emacs 30-day challenge – keep using Org-mode/Emacs for a month. Note that I was still using Evernote during the transition but gradually reducing the dependency on it.

I have now finished the challenge and can claim myself an Org-mode user. I am happy with Org-mode and the new workflow. Since the org files are in plain text, I manage my notes with Git, review, and polish all the changes before committing it. It helps to improve the quality of my notes!

Beyond Org-mode, I also started seeing the beauty of Emacs and why people use it instead of Vim or other modern editors. Emacs is ostensibly an editor but actually a powerful Lisp platform/runtime, which makes it super extensible and capable. Users can customize Emacs and make it their own systems for their own purposes.

I am now using Emacs even more. For example, I replace Visual Studio Code, my previous editor/git porcelain, with Magit. This blog post is written in Emacs with ox-hugo. I probably will blog on these topics sometime in the future.

All in all, I am very happy with the privacy gain and the learning from this switch!