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

Introducing markdown-indent-mode

whhone@gmail.com (Wai Hon Law) — Sun, 08 Mar 2026 16:30:00 -0700

The Itch

One thing I particularly love about org-mode is org-indent-mode, which visually indents content under each heading based on its level. It makes long org files much easier to read and navigate.

Occasionally, I need to edit Markdown files — and every time I do, I miss that clean visual hierarchy. So I vibe-coded a first version over a weekend.

Vibe-Coding

The idea translates naturally from org-indent.el, which ships with Emacs. Headings marked with # instead of *, same concept.

The first version worked partially, but was full of edge cases: code fences confusing the heading parser, list items indenting wrong, wrapped lines losing alignment. I kept using it day-to-day, tweaking it when something looked off, and simplifying whenever I found a cleaner approach. Eventually it reached a state I was genuinely happy with.

At that point I thought it might be useful to others too, so I decided to share it.

First Attempt: Merging into markdown-mode

My first instinct was to contribute this directly to markdown-mode, the de-facto Markdown package for Emacs, so all users could get it without installing anything extra. It turns out this is a long-anticipated feature — there have been open issues requesting it for years:

Issue #330 (opened in 2018)
Issue #679 (opened in 2021)

I opened a pull request to add the feature directly into markdown-mode.

Going Standalone Package

The markdown-mode maintainer reviewed the PR and suggested that this would be better as a standalone package since it would be a burden for them to maintain the new feature.

I took the suggestion, refactored the code into its own package: markdown-indent-mode, and submitted it to MELPA.

The MELPA Journey

Submitting to MELPA was a learning experience in itself. I picked up a few tools along the way for checking Elisp package quality:

checkdoc — checks that docstrings follow Emacs conventions
package-lint — catches common packaging issues
melpazoid — an automated checker specifically designed for MELPA submissions

The MELPA maintainers are volunteers who typically review PRs on weekends, so the process took a few days.

What markdown-indent-mode Does

Here’s what it does — nothing fancy, just the basics done cleanly:

Uses line-prefix and wrap-prefix text properties for visual indentation
Content under a heading is indented according to the heading level
Leading # symbols are hidden
List items are indented to align with their content
Everything is purely visual: no buffer content is ever modified

Installation

This package is available on MELPA. You can use use-package to install it and add hook to enable it for markdown-mode.

(use-package markdown-indent-mode
 :hook (markdown-mode . markdown-indent-mode))

Or toggle it on demand with M-x markdown-indent-mode.

Before	After

The source is available at https://github.com/whhone/markdown-indent-mode.

If you ever find yourself editing Markdown in Emacs, give it a try and let me know what you think!

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.

Using Emacs in a Terminal

whhone@gmail.com (Wai Hon Law) — Fri, 23 Aug 2024 20:00:00 -0700

Fun fact: a coworker thought I was using a GUI application when they saw my terminal Emacs.

Introduction

At my workplace, most coding tasks must be performed on a remote workstation (or a browser-based IDE) due to policies prohibiting local storage of source code and the limited development tools available on company laptops.

Coding with Emacs on a remote workstation requires access via SSH or a remote desktop connection. I have experimented with various solutions, including Tramp, Chrome Remote Desktop, GTK Broadway, xpra, and wprs. However, these proved buggy, resource-intensive, or slow. Consequently, I settled on the reliable terminal-based approach using SSH and Tmux.

Issues

Initially, I encountered several issues using Emacs in the terminal, as things were not working out-of-the-box:

Emacs was no longer colorful.
Some keybindings did not work.
I could not copy text to the native clipboard.
Version control diff highlighting was not visible.
Opening links in a local browser was not easy.

Over time, I discovered solutions and workarounds for these issues and began to enjoy some extra benefits I had not expected:

Using the same Emacs instance across multiple computers.
Eliminating Crostini on my Chromebook.
Reducing the need to synchronize files and resolve conflicts.
Remote file editing is faster than Tramp.
Providing a more native terminal experience via Tmux multiplexing (compared to vterm, shell, etc.).
No font size scaling issue.

Solutions

Here’s how I configured Emacs for comfortable terminal use.

Pick a Good Terminal Emulator

First, pick a terminal emulator that supports at least:

true color, and
OSC 52 (for system clipboard integration).

Ideally, it should have fewer default keybindings or allow customization to avoid conflicts with Emacs.

The default Chrome OS terminal (hterm) is what I currently use, as it meets all three requirements. I do not use Linux, macOS, or Windows frequently enough nowadays to offer recommendations for those platforms.

Some terminals can even display images! E.g., the terminal graphics protocol by Kitty, the inline image protocol by iTerm2, and the Sixel protocol. It would be nice if there were Emacs integration with them!

Use Emacs in a Tmux Session

I use Emacs inside Tmux because it provides a persistent session that can be reattached from any computer or after losing an SSH connection. I also automatically reattach to the Tmux session upon SSH connection with this SSH config:

Host myhost
RemoteCommand tmux -u new -A -D -s main
RequestTTY yes

Alternative ssh command:

ssh -t myhost tmux -u new -A -D -s main

Alternative shell script approach:

# .bashrc
# Attach to the main Tmux session if it is
# - in SSH session
# - not inside Tmux
# - not inside Emacs
if [[ -n "$SSH_CLIENT" && -z "$TMUX" && -z "$INSIDE_EMACS" ]]; then
 # "-A" : reattach if session-name already exists
 # "-D" : detach other clients (ensure $SSH_TTY is always correct)
 tmux new -A -D -s main
fi

Tmux also allows me to have multiple workspaces using Tmux windows (or sessions).

If I need extra terminals, I split new panes or new windows. I find the Tmux terminal better than Emacs’s term, shell, vterm, or eat, because it is more native, faster, and easily distinguishable from an Emacs buffer.

Also, I can add information like the system status (CPU, RAM, Disk, etc.) and the current time to the Tmux status bar.

Optionally, change the default Tmux leader to reserve C-b for moving the cursor.

set-option -g prefix M-\

Make Emacs Colorful

The screenshots below show the difference with and without true color (24-bit color) enabled.

Without true color, low contrast	With true color, high contrast

There are a few ways to get true color in a terminal Emacs session:

Use a TERM that supports true color, e.g., xterm-direct. (This won’t work inside Tmux, which changes the term to tmux-256color.)
Set the COLORTERM environment variable to truecolor. (preferred)

# .bashrc
export COLORTERM=truecolor

There are a few ways to get true color support in Tmux:

Use a TERM that supports true color, e.g., xterm-direct, or
Start tmux with the RGB feature, e.g., tmux -T RGB, or
Override the features of your terminal in .tmux.conf, e.g.:

# .tmux.conf
# See https://github.com/tmux/tmux/wiki/FAQ#how-do-i-use-rgb-colour.
set -as terminal-overrides ",xterm-256color:RGB"

Tip: Use this script to test for true color support.

Copy Text to Native Clipboard (OSC 52)

OSC 52 works by printing an unreadable sequence, \033]52;c;[base64 data]\a, which instructs the terminal to alter the system clipboard with the base64-encoded data. To verify that OSC 52 is working for your terminal setup, run printf "\033]52;c;$(printf \"Hello, world\" | base64)\a" from the terminal. It should put “Hello, world” into the system clipboard.

In the Emacs config, install the Clipetty package, which sends text that you kill in Emacs to the native clipboard.

;; init.el
(use-package clipetty
 :hook (after-init . global-clipetty-mode))

To enable clipboard support in Tmux, add these lines to .tmux.conf:

# .tmux.conf
set -g set-clipboard on

# Required to make Clipetty work better on re-attach by appending
# "SSH_TTY" to "update-environment". See
# https://github.com/spudlyo/clipetty?tab=readme-ov-file#dealing-with-a-stale-ssh_tty-environment-variable
set -ag update-environment "SSH_TTY"

If it still does not work, try running the printf verification command above and check the Tmux clipboard wiki.

Open Link in Local Browser

I have two workarounds for opening a web link from a remote Emacs session in a local browser:

Use a mouse click if the terminal emulator can recognize links and open them locally.
Copy the link to the local clipboard and paste it into the browser.

For (2), I added an advice to browse-url to place the URL into the native clipboard via OSC 52. I then paste it into a local browser. I also added key and mouse bindings for the function to make copying more seamless.

(define-advice browse-url
 (:around (orig-fun &rest args) copy-url-if-terminal)
 (if (display-graphic-p)
 (apply orig-fun args)
 (let ((url (nth 0 args)))
 (message "Clipetty link: %s" url)
 (clipetty--emit (clipetty--osc url t)))))

See my Emacs configuration for the full and updated version.

Tweak for xterm-paste

When pasting from the native clipboard, I would like to delete the region if one is active.

This is like (delete-selection-mode) for xterm-paste.

(define-advice xterm-paste
 (:before (&args) delete-active-region)
 "Delete the selected text first before pasting from xterm."
 (when (use-region-p) (delete-active-region)))

Update Key Maps that Works in Terminal

The idea is to have a set of keybindings that the terminal can respond to.

This part varies from person to person. For example, I have remapped:

C-x C-; to C-x ; for comment-line (C-; is unsupported).
C-c C-, to C-c , for org-insert-structure-template (C-, is unsupported).

We can use key-translation-map for the mapping.

;; e.g., comment-line
(define-key key-translation-map (kbd "C-x ;") (kbd "C-x C-;"))

;; e.g., org-insert-structure-template
(define-key key-translation-map (kbd "C-c ,") (kbd "C-c C-,"))

Alternatively, if your terminal supports the Kitty Keyboard Protocol (KKP), you can use kkp.el to make terminal Emacs handle those “impossible” keybindings (thanks to sned@ for the tip).

Show Diff Highlighting with Margin

diff-hl does not work in the terminal by default, and this issue had annoyed me for a while until I searched for a solution. It turns out that diff-hl already has a solution: using the “margin” to show the diff.

I added this Elisp config to turn on diff-hl-margin-mode whenever I am inside a terminal.

;; init.el
(add-hook 'diff-hl-mode-on-hook
 (lambda ()
 (unless (display-graphic-p)
 (diff-hl-margin-local-mode))))

Enable Mouse Support

Don’t forget to enable mouse support.

Note that there was a conflict where any mouse movement over Emacs would deactivate the Tmux prefix key (this is fixed in Tmux 3.5!). See https://github.com/tmux/tmux/issues/4111.

;; init.el
(xterm-mouse-mode +1)

# .tmux.conf
# Enables mouse support in Tmux (switching windows and panes,
# resizing panes, etc.). Setting mouse on or off does not disable
# Emacs's xterm-mouse-mode.
set -g mouse on

Conclusion

For most Emacsers, GUI Emacs is still a better choice because it:

Has no network latency.
Has better multimedia support (images, PDFs, etc.).
Can handle all keybindings.
Can interact with the clipboard natively.
Can open links in a local browser easily.
Is more customizable (font size per buffer, tooltips, etc.).

However, if you, like me, need to work remotely or want to use the same Emacs instance across multiple computers via SSH and Tmux, I hope the tricks above can improve your setup, even at the expense of the aforementioned GUI features.

Update on 2025-09: also check out this YouTube video nobody knows that using Emacs in the terminal is so great by Jake B!

Text Replacement Tools for Large Codebases

whhone@gmail.com (Wai Hon Law) — Wed, 25 Oct 2023 00:00:00 -0700

10 years ago, when I became a software engineer, my mentor showed me how to replace all occurrences of a string (or a regex) under a large codebase effectively with a tool called codemod. It turned out to be one of the most useful text-editing techniques in my next 10 years, saving me many hours of “find and replace” manually.

Over time, I discovered additional options for different use cases. Here they are.

For Simple Replacement - `sed`

sed is my favorite for simple cases because it comes pre-installed in most operating systems.

# replace all instances of `foo` (regex) with `bar` (regex) in a file
sed -i.bak "s/foo/bar/g" path/to/file

# replace all instances of `foo` (regex) with `bar` (regex) found by `find`
find . -name '*.cpp' | xargs sed -i.bak "s/foo/bar/g"

# replace all instances of `foo` (regex) with `bar` (regex) in modified files under git
git diff --name-only | xargs sed -i.bak "s/foo/bar/g"

# replace all instances of `foo` (regex) with `bar` (regex) in modified files under hg
hg status --rev .^ -n | xargs sed -i.bak "s/foo/bar/g"

If I encounter a performance issue, I will switch to fastmod.

For Very Large Code Base - `fastmod`

fastmod is a fast partial replacement for codemod. It is written in Rust and is designed for large-scale codebase refactoring.

# replace a regex pattern in specific files or directories:
fastmod 'foo' 'bar' -- {{path/to/file path/to/directory ...}}

To install, run cargo install fastmod, assume you have Rust’s Cargo installed.

For more use cases, see tldr:fastmod.

For Simple Replacement in Emacs - `dired`

As an Emacser, I must also provide a way to achieve this in Emacs.

M-x dired
Mark the required files and directories (m to select, t to toggle all)
Press Q (dired-do-find-regexp-and-replace) to replace string by regex
1. Press y to accept.
2. Press ! to accept all.

For Interactive Replacement in Emacs - `wgrep`

wgrep stands for “Writable Grep Buffer”. It is a very flexible interactive replacement in Emacs. It gathers all occurrences in a buffer and then you can use whatever you want edit them.

Search with counsel, e.g., counsel-rg
C-c C-o (ivy-occur)
C-x C-q (ivy-wgrep-change-to-wgrep-mode)
Edit (e.g., replace-regex)
C-c C-c (commit the changes)

For more details on this method, see:

For Interactive Replacement in Emacs Project - `project-query-replace-regex`

project.el provides a command called project-query-replace-regex (default keybinding: C-x p r) that allows you to interactively replace a regex pattern within a project.

Epilogue

In most cases, I prefer sed and fastmod since they allow me to do it in a single command, which makes it easier to iterate the desired command (execute and revert for the right “foo” and “bar”).

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

Ignore "save-buffer" Unless Visiting a File

whhone@gmail.com (Wai Hon Law) — Sat, 09 Apr 2022 00:00:00 -0700

I have a habit of hitting the save shortcut (C-x C-s) occasionally. However, if the buffer does not have a visited file (like treemacs, vterm, scratch, help, etc), Emacs asks me where to save the file and I need to cancel with triple ESC.

For example, hitting C-x C-s within the *scratch* buffer.

This is annoying. To fix it, I remap save-buffer to the function below¹ which does nothing for non-file-visiting buffer.

(defun my/save-buffer (&optional arg)
 "Like `save-buffer', but does nothing if buffer is not visiting a file."
 (interactive "p")
 (unless (or (buffer-file-name) ; regular buffer
 (buffer-file-name (buffer-base-buffer))) ; indirect buffer
 (user-error "Use 'M-x save-buffer' explicitly to save this buffer with no visited file"))
 (save-buffer arg))

(global-set-key [remap save-buffer] #'my/save-buffer)

Now, I get the message below and do not need to cancel the save operation.

Update: My friend AhLeung has an alternative using save-all-buffers:

(defun my/save-all-buffers ()
 "Save all motified file-visiting buffers without asking."
 (interactive)
 (save-some-buffers t))

(global-set-key [remap save-buffer] #'my/save-all-buffers)

This elisp is updated with the suggestion from Phil-Hudson. Thanks! ↩︎

Write with Emacs 2: Synonyms

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

The limits of language are the limits of one’s world. ~Ludwig Wittgenstein

My limited vocabulary should be a limit of my writing.

Looking up Synonyms with Power Thesaurus

I find looking up synonyms is a way to extend one’s active vocabulary. For instance, I can replace beautiful (active vocabulary) with something more specific and accurate, like attractive, lovely, gorgeous, charming, splendid, appealing (passive vocabulary).

In Emacs, emacs-powerthesaures is a package to look up synonyms by fetching data from Power Thesaurus.

Here is a mini demo:

Configuration

The package defines three interactive functions:

powerthesaurus-lookup-word: look up synonyms of a provided word
powerthesaurus-lookup-word-at-point: look up synonyms of the word at point
powerthesaurus-lookup-word-dwim: combine the above two,
- if the current point (cursor) has a word, then calls (2)
- otherwise, calls (1)

Here is my configuration:

(use-package powerthesaurus
 :bind
 ("M-`" . powerthesaurus-lookup-word-dwim))

Caveat

Use words that you know. Otherwise, check the meaning and learn that new word first!

Write with Emacs 1: Spell-Checking

whhone@gmail.com (Wai Hon Law) — Fri, 29 Oct 2021 00:00:00 -0700

I am bad at writing, especially in English, which is not my native language. I misspell words, have limited vocabulary, and misuse grammar without being aware of it.

On the other hand, I write and need to write a lot. Emacs is my main writing tool and I use it to take notes, compose commit messages and blog posts, etc. Over the years, I have learned some tricks to write better with this awesome tool. I am going to share them in the next couple of posts,

Let’s start with the basic – spell-checking.

Check and Correct Spelling with Flyspell

I use Flyspell, an Emacs built-in minor mode, for performing on-the-fly spelling checking and correcting.

When enabled, misspelled words will be highlighted. I can use (flyspell-auto-correct-word) to correct the word at the point. Most of the time, the first candidate is the correct one. It is smart enough to me.

I also use the context menu a lot (by middle-clicking the misspelled word). I can choose the right word from all candidates or save the word, so that it does not complain anymore.

If you don’t like touching the mouse, flyspell-correct is a package to correct misspelled words with other interfaces, like helm and ivy, all inside the keyboard.

Here is a demo for (flyspell-correct-wrapper).

Configuration

Flyspell provides two minor modes:

flyspell-mode for writing
flyspell-prog-mode for programming (only text inside comments and strings is checked)ema

Here is how I enable them respectively and set up the packages mentioned above.

(add-hook 'text-mode-hook 'flyspell-mode)
(add-hook 'prog-mode-hook 'flyspell-prog-mode)

(use-package flyspell-correct
 :after flyspell
 :bind (:map flyspell-mode-map ("C-;" . flyspell-correct-wrapper)))

;; Replace with flyspell-correct-helm if you are a helm person.
(use-package flyspell-correct-ivy
 :after flyspell-correct)

Caveat

This trick does not work if the misspelled word is valid. For example, when misspelling “summit” as “submit”. So, you should still check the spelling even with tool like this.

Another Emacs i3 Integration

whhone@gmail.com (Wai Hon Law) — Fri, 15 Oct 2021 00:00:00 -0700

Pavel Korytov wrote an inspiring blog post to get a consistent set of keybindings between i3 and Emacs. It caught my attention because I use exactly these two tools heavily. Before the integration, I have to define a different keybinding for switching window inside Emacs and i3. After the integration, I can use the same keybinding everywhere. Check out the video in the original blog post to see how cool it is!

I followed the blog post and implemented it immediately. It worked and I loved that! However, the proposed (i3 -> Emacs -> i3) solution introduced a coupling between i3 and Emacs. i3 has to know Emacs, and Emacs has to know i3. It does not fit into the Law of Demeter. It makes the solution harder to scale to other tiling window managers or applications.

Hence, I implemented another (i3 -> Emacs) solution with less coupling (only the focus command for now).

1: Add an Elisp function `my/wm-integration`

(require 'windmove)
(defun my/wm-integration (command)
 (pcase command
 ((rx bos "focus")
 (windmove-do-window-select
 (intern (elt (split-string command) 1))))
 (- (error command))))

my/wm-integration handles the command from the window manager.

Emacs does not need to know what the window manager is, and do not need to call i3-msg. It return a non-zero code if the command is not handled, or a zero code if handled.

nit. Emacs still use the protocol defined by i3, like the focus command. Well… we have to use a protocol anyway. Let’s pick the i3 protocol in this post.

2: Create a Script `i3-msg-proxy`

#!/bin/sh
#
# Proxy the `i3-msg` command to the focused window.

# Proxy to Emacs if it is the active window
if [[ "$(xdotool getactivewindow getwindowclassname)" == "Emacs" ]]; then
 command="(my/wm-integration \"$@\")"
 if emacsclient -e "$command"; then
 exit
 fi
fi

# fallback to i3
i3-msg $@

This script proxies the i3-msg command to the focused window. If the focused window has handled it (return zero), then exit. Otherwise (return non-zero), fallback to i3.

This mechanism (using the return code) can work with other applications, like Tmux.

3: Update the i3 config

bindsym $mod+Left exec i3-msg-proxy focus left
bindsym $mod+Down exec i3-msg-proxy focus down
bindsym $mod+Up exec i3-msg-proxy focus up
bindsym $mod+Right exec i3-msg-proxy focus right

Finally, update the i3 config to proxy the command to the focused window. Now, I can move my focus between i3 and Emacs!

Conclusion

The key difference between this and the original solution is how Emacs calls i3 back when it failed to handle the command. The original solution calls i3-msg inside Emacs. This solution returns non-zero from Emacs.

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!

Emacs on Wai Hon's Blog

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

The One-Line-Per-Day Format

Daily Entries

Weekly Highlight

Why This Works Well

Conclusion

Appendix: Screenshot

Refining Org-mode Deadlines

A New Prioritization Hierarchy

Default Org Agenda View

Customized Org Agenda View

Trick 1: Visual Deadlines with Custom Leaders and Sorting

Trick 2: Expanding the Warning Window to a Month

Conclusion

Introducing markdown-indent-mode

The Itch

Vibe-Coding

First Attempt: Merging into markdown-mode

Going Standalone Package

The MELPA Journey

What markdown-indent-mode Does

Installation

Distinguish Repeated Tasks in Org Agenda

Problem: Repeated or Not?

Solution: Setting the Prefix Format

Alternatives

Using the Agenda Finalize Hook (Hacky)

Using Column View (Cluttered)

Using Emacs in a Terminal

Introduction

Issues

Solutions

Pick a Good Terminal Emulator

Use Emacs in a Tmux Session

Make Emacs Colorful

Copy Text to Native Clipboard (OSC 52)

Open Link in Local Browser

Tweak for xterm-paste

Update Key Maps that Works in Terminal

Show Diff Highlighting with Margin

Enable Mouse Support

Conclusion

Text Replacement Tools for Large Codebases

For Simple Replacement - sed

For Very Large Code Base - fastmod

For Simple Replacement in Emacs - dired

For Interactive Replacement in Emacs - wgrep

For Interactive Replacement in Emacs Project - project-query-replace-regex

Epilogue

Implementing the PARA Method in Org-mode

The PARA Method

Project vs Area vs Resource

PARA is Pragmatic

Org-mode Implementation

Tags and Categories

Organizing my Notes

Conclusion

Using Denote with Subdirectories

#1 Search by Filename in Subdirectories

#2 Full-Text Search in Subdirectories

#3 Create Notes in Subdirectories

Comparing with Org-roam Again

Denote vs Org-roam

Key Differences

Identifier and Linking

Supported Formats

File-naming Scheme

Searching Mechanism

Denote Comparison to Org-roam

Pros

Cons

My Choice

Appendix

Ignore "save-buffer" Unless Visiting a File

Write with Emacs 2: Synonyms

Looking up Synonyms with Power Thesaurus

Configuration

Caveat

Write with Emacs 1: Spell-Checking

For Simple Replacement - `sed`

For Very Large Code Base - `fastmod`

For Simple Replacement in Emacs - `dired`

For Interactive Replacement in Emacs - `wgrep`

For Interactive Replacement in Emacs Project - `project-query-replace-regex`

1: Add an Elisp function `my/wm-integration`

2: Create a Script `i3-msg-proxy`