As described in My experience with a Zettelkasten, I tried Logseq and Obsidian for a while, but changed from one to the other all the time. This wasted my time and I was NOT getting things done. Eventually I added Emacs to the list because its clear advantages

• In Emacs you can adjust the workflow as you want, you can even easily write your own functionalities (this of course requires knowing Elisp).
• Emacs integrates everything you could ever need (except browsing) in one environment:
  • Take notes,
  • Relate notes with code and files in the disk,
  • Use Magit for Version Control,
  • Work on Markdown files (to maintain this blog),
  • Edit the blog’s configuration files (to maintain this blog),
  • Manage projects, track the time in each task, export the notes to whatever format I want… and Org-mode features in general,
  • RSS Feed managing,
  • And of course can be extended to soo much more (these are just my use cases).
• Emacs is a solid piece of free software with a huge community and the Free Software Foundation behind it.
• It is keyboard centered so you can work faster than using the mouse.

But still I felt the need for something more visual in front of me, like an easily accessible Graph View, formatted text, and Journal pages to record things I was doing and seeing without a place to write them down. All of that can be done in Emacs, but I would have to learn Elisp. For these reasons I choose to use Logseq for note taking as it comes with most of that functions out of the box.

Managing the notes with Denote

Denote is an Emacs package maintained by Prot. It is based in simple functions, which makes it quite powerful and easily extensible. Besides, the notes are named following a scheme which makes possible to quickly find them even with a file explorer (see more in the corresponding section of its documentation).

With use-package my current Denote’s configuration is the following (see complete Emacs configuration at my git repository).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

(use-package denote
	:ensure t
    :config
    ;;
    ;; General key bindings
    (setq denote-directory (expand-file-name "/media/Datos/notes"))
    (setq denote-known-keywords '("emacs" "project"))
    (setq denote-infer-keywords t)
    (setq denote-sort-keywords t)
    ;;
    ;; Tweaking the frontmatter
    (setq denote-org-front-matter
          "#+title: %s\n#+date: %s\n#+filetags: %s\n#+identifier: %s\n#+author:\n#+startup: content\n")
    :bind
    ("C-c n n" . denote-open-or-create)
    ("C-c n l" . denote-link-or-create)
    ("C-c n b" . denote-link-find-file)
    ("C-c n B" . denote-link-backlinks)
)

This allows me to see existing notes and create new ones C-c n n, link them C-c n l, and see the connections C-c n b with minimum distraction.

A tip: if you write the name of a note with C-c n n and it does not exists, you normally will hit enter to create it. But this will ask you again for the name you want to give to the note. By typing M-p Denote will autocomplete the name of the new note with the one you introduced in the first moment.

Searching for words in the body of the notes

It is quite important to be able to search all your notes for some terms. For global search inside the content of the notes there are many possibilities.

• Use grep from an external terminal
• Use M-x grep or M-x grep-find from inside Emacs
• From Dired, use M-x find-grep-dired

But what I really like to use, and works perfectly, is M-x consult-grep. This of course requires the consult package being installed. The following is the configuration I currently have for Consult, but one more time you can check the complete configuration in my git repository, and also check the corresponding section of the consult package here.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

(use-package consult
	:ensure t
    :hook (completion-list-mode . consult-preview-at-point-mode)
    :init
    (setq register-preview-delay 0.5
          register-preview-function #'consult-register-format)

    (advice-add #'register-preview :override #'consult-register-window)

    (setq xref-show-xrefs-function #'consult-xref
          xref-show-definitions-function #'consult-xref)
)

Capturing information

It is important to be able to capture information, and of course this is an area where Org-mode excels. In my configuration I have org-capture bound to C-c c, and it directly opens the capture template, which is quite frictionless to capture information. Of course this can be combined with email and many other stuffs, but things can get messy very quickly in that direction, so I prefer to keep it simple.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

;;
;; Capture
;;
(setq org-directory "/media/Datos/notes/")
(setq org-default-notes-file (concat org-directory organizer-file))
(global-set-key (kbd "C-c c") 'org-capture)      ;; use C-c c to start capture mode

;; capture templates for: TODO tasks, Notes, appointments, meetings
(setq org-templates-location-var (concat org-directory organizer-file))
(setq org-capture-templates
   '(("t" "Todo" entry (file+headline org-templates-location-var "Inbox")
   "* TODO [#C] %? ")))

;; Refile
;; Targets include this file and any file contributing to the agenda - up to 9 levels deep
;; C-c C-w for refile
(setq org-refile-targets (quote ((nil :maxlevel . 3)
   (org-agenda-files :maxlevel . 3))))

organizer-file is a variable set to the name of the note where the captured headlines will go.

Logseq

Although Emacs has everything one could wish and one needs for carrying out almost any activity on a computer, it kind of lacks that visual and modern design which sometimes attracts me so much. Nor photos neither equations are displayed, and although efficient for editing, when thinking and searching for something it helps me better to be mouse dependent, it’s more sensorial to me. Also, if used for everything, with time thing can get messed up very quickly in the configuration files.

Nowadays I use Logseq for taking the notes and writing into the Journal page all the interesting info I found online, marked with tags that will probably make me find them again in the future. It has been working great for retrieving information. Some capture I do it here, and some other in Emacs, it all depends on which I am at the time.

On the other hand, Emacs is reserved for maintaining projects which need too much headlines and details. Wen I launch 100 computations in a cluster as part of research job, all of them get tracked in the corresponding project page, and can efficiently hide and show heading levels, track time, take notes, relate to others, and appear in the custom agenda views to get up to date with their status. This is extremely useful, and if done in Logseq would end up in extremely large pages with lots of information at the same time.

Capturing information in journals

I found that spending time “working” in the PKM system tends to be counterproductive. Just capturing a few things during the day, and then reorganizing them at some point in the future is better. In this regard Emacs can be extremely helpful with capture and refile, since all captured entries will be in the specified file of your choice. With Logseq the alternative is to tag as #inbox (for example) captures that need to be reviewed in the future.

I also keep a minimalist Bullet Journal for written thoughts, which I enjoy more than typing on the keyboard. Something very similar to a bullet journal can be set up seamlessly with Denote, but for me there was some friction. Every time I needed to capture something, I had to turn on the PC if it was turned off, and digital stuffs just don’t hit you as hard as they do when they are written on paper.

However, if this doesn’t affect you and keeping a digital-only journal suits your needs and tastes, Prot has provided me with an improved function that he will integrate into the next update of the Denote manual, which allows you to create a daily note, exactly the same as Logseq Journals or a Bullet Journal. The function I refer to is my-denote-journal, and can be found in this section of the Denote manual. The modified version here below, which add the ability to check if today’s note already exists and if so not to create a new one, but open the existing one is:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

(defun my-denote-journal ()
    "Create an entry tagged 'journal' with the date as its title.
    If a journal for the current day exists, visit it.  If multiple
    entries exist, prompt with completion for a choice between them.
    Else create a new file."
    (interactive)
    (let* ((today (format-time-string "%A %e %B %Y")))
           (string (denote-sluggify today)))
           (files (denote-directory-files-matching-regexp string))))))
      (cond
       ((> (length files) 1))
        (find-file (completing-read "Select file: " files nil :require-match)))))))
       (files
        (find-file (car files))))))
       (t
        (denote
         today
         '("journal"))))))

In my case, because I use use-package for handling installed packages, denote had to be called before the use of this function for it to correctly work, because use-package does not loaded Denote until it is required. To fix this it is necessary to include :demand t when using use-package to configure Denote.

Regarding the constant change of apps

Over time I’ve come to understand that the app we use doesn’t really matter, and that switching from one to another can be very counterproductive. This video on YouTube or Invidious contains an analysis of this issue, and you may find it interesting in case you have found yourself, like me, switching from one to the other.