Comment by asterisk_ | Hacker News Reader

Comment by asterisk_ | Hacker News Reader

Note-taking seems to have gained popularity on HackerNews over the past few weeks (or my attention has been biased towards these submissions, at least).

I've long been interested in the domain of "personal knowledge engineering" and this clearly seems a common thread within our community. As a brief overview of the "SOTA:"

* Emacs and Vim users skew towards Org-mode or Vim wiki.

* Roam Research is sort of a recent web-based alternative.

* There's a lot of competition in the domain of fully-fledged note taking apps. Evernote has long been viewed as a king of note-taking but lost its edge over time (bad editor, bugs, lack of attention to their users). Memex seems to be gaining popularity even though their software looks somewhat buggy at the moment.

* Otherwise, people naturally develop their own (similar) systems. I myself have independently developed a custom-made Vim wiki before starting research into this topic. It basically consists of a few grepping/Vim aliases to search/create Markdown in a `~/.notes` folder, backed up to GitHub. `mod+-` is bound to an i3 sratchpad where Vim is constantly open to `~/.notes/index.md`. This drastically reduces friction when making new notes.

In any case, seems interesting that a lot of the personal note-taking systems have separately adopted similar principles to what Zettelkasten proposes:

1. Heavy reliance on tagging

2. Some sort of deep linking

3. Preference to making small, independent "knowledge chunks"

There's also the category of "infinite outliner apps". The OG of these is Workflowy[1] which is a minimalist's take on the idea. Personally, I use Dynalist[2] which is Workflowy with more features.

My current problem with these tools is that I tend to treat them as mostly a "write-only" medium. i.e., I don't really refer back to them that often. What I'm really looking for is a tool that will let me _serendipitously_ encounter ideas from the past. For that, I think that Roam[3] with its Mediawiki style "backlinks" might be the next thing that I spend some serious time with.

Either that or a tool that somehow encourages me to refactor thoughts from the past into more (currently) useful content.

[1] https://workflowy.com/

[2] https://dynalist.io/

[3] https://roamresearch.com/

Interesting, I haven't heard of (1) and (2) but as I've mentioned Roam Research also seems a good take on this idea. From my (recent) experience it appears their app is not yet stable enough to use as a daily driver, though. Notion [0] seems like a more mature version based around similar principles.

As for idea rediscovery I'm personally happy with the setup I devised for myself so I can only suggest trying to emulate something similar. If you're interested, some guiding principles I follow:

1. My note-taking app (Vim, but could also be the browser or anything else) is constantly open in the background, and I have a keyboard shortcut to show/hide.

2. I maintain an index document of sorts (with TODOs, recent thoughts, outward links). This is frequently updated and I don't think too much about categorization.

3. Either Markdown `#` headers or `*` are mapped to Vim folds, which allows me to use `zm` and `zr` to quickly expand and collapse document outlines.

4. Treat tags as a "brain-dump". Just quickly come up with some keywords before starting to write the note. If you do that, I find even simple tools such as ctags and grep immensely help with future rediscovery.

5. Backups are on GitHub so I have the double convenience of both tracking document history, as well as being able to access all notes from mobile.

It's served me well thus far; most commercial note-taking apps will handle (4) and (5), while (1) is easy to resolve (e.g. AutoHotkey on Windows) so there's probably no need to make drastic changes to your setup if you wish to try it out.

[0] https://www.notion.so/

I use a small subset of Org Mode myself. But I think people focus too much on tools vs method. Plain text plus ripgrep can work great. Lühmann used pen and paper, and he built some hugely successful Zettelkastens. Many users at Zettelkasten.de write super simple notes in Markdown.

Actually, I'd never move away from plain text or a plain text format like Org, Markdown or similar as it is really future proof. Will Roam or Evernote be around and well maintained in 20 years? Probably not. I'd recommend you to use your favorite text editor plus Markdown. If your favorite text editor is Emacs, then consider Org.

I think people focus too much on tools vs method

I've been guilty of this too. A note is a way to get something out of your head. I always return to plain text files on my computer because that's the fastest/least resistance and there just aren't any additional benefits for me to using other approaches. Linux command line tools are a simple yet effective way to work with text.

> I'd recommend you to use your favorite text editor plus Markdown. If your favorite text editor is Emacs, then consider Org.

My favorite editor is Vim, but a big part of why I learned to use Emacs was to try org-mode. Now, org-mode is pretty much the only thing I use Emacs for (email too, but not as often).

> Lühmann used pen and paper

Luhmann.

And he collected and refinend his knowledgebase for nearly 40 decades, because this was actually his job and he had nothing better at hand. Most people today use knoweldebases just a tool on the side and they have computers now. Naturally they strive for faster workload and higher quality. Something you can't get with pen&paper.

> Will Roam or Evernote be around and well maintained in 20 years?

Probably not, maybe they are. But they are not good competition there. Evernote is mostly tooling and servers, just a bit interface and mostly just fancy richtext. The advantage over markdown is quite thin these days. Roam might be a bit better, bit I think it's just a fancy wiki with autolinking, so not really good either.

The actual competition are apps like notion and airtable and Office Suits. Interfaces and tooling which goes above and beyond simple test with fancy colors. Markdown is not there, probably never will be. Orgmode to some parts goes there, but has other problems.

As a long time emacs org mode user, I would say that both vim/emacs users (and others) should check out asciidoc/asciidoctor. I have been doing more and more things in them and find myself really enjoying the simplicity (and shareability with those who don't emacs/vim) mainly when targetting html or pdf exporting. I find myself wishing there was an org mode to asciidoc exporter lately.

Wow, I'm late to this party, but what the heck:

I've been obsessing about this for a long time and concluded, as you have, that AsciiDoc is the One True markup format for me.

I don't have anything to offer an Emacs user, but I have created my own Vim wiki plugin[1] which is heavily inspired by VimWiki and uses AsciiDoc as the native syntax. The plugin is pretty much brand spanking new, but I use it all day every day.

I've already converted some of my note extraction tools to pull from this wiki format and the dream is, ultimately, to have everything including my website pull from this one source.

[1] https://github.com/ratfactor/vviki/

Yeah, note taking posts have been ramping up in the last few days/weeks. I’ve noticed that as well. I’m enjoying it, to be honest. I’m always looking to make my process (which, currently, is rather hodgepodge) more streamlined.

I wish I had the link, but last week someone linked to something called `bash_log` which was someone’s bash function that created time stamped md files for simple journaling. Nothing groundbreaking, but for me it was a step up.

Currently, I’m using StandardNotes, the forementioned bash utility with GitHub pushing, and god-help-me random moleskins. I’ve also tried Dynalist which was nice but I didn’t like that I couldn’t lock it down and link it to GitHub.

If anyone has any suggestions in the context of what I’ve posted, I’m all ears. The article gives me some ideas, as does your response. I’d be interested in more concrete examples of what you’re doing if you wouldn’t mind.

In case you still haven't found it, bashlog is here: https://github.com/jodavaho/bashlog

Oh perfect. Thank you. I’m on my phone otherwise I could have done the author justice, thanks!

> If anyone has any suggestions in the context of what I’ve posted, I’m all ears.

I wrote this tool for accessing Standard Notes on the command line:

https://github.com/tannercollin/standardnotes-fs

I imagine it would integrate with bash_log quite well.

Back your data up first, and I'm guessing you could just `cd` into your notes folder then use bash_log straight from there. You could also set LOG_DIRECTORY in your .bashrc to be where ever you mount Standard Notes.

Small independent knowledge chunks.

My personal goal with this idea is to make everything quickly searchable, preferably by voice at some point in the future. “How do I ... in Swift|Scala|Rust”

I built a small Swift Cookbook on my website a few years ago. I recently moved it to Github to update to Swift 5.x and to move towards my goal.

https://github.com/melling/SwiftCookBook

Another example is Chris Albon’s recipes that I’ve found useful:

https://chrisalbon.com/

> 1. Heavy reliance on tagging

> 2. Some sort of deep linking

This makes me think of Ted Nelson’s Docuverse [0]. Thanks for the note-taking review.

[0]: https://en.wikipedia.org/wiki/Docuverse

Any comparisons between Roam and DynaList?

Reply on news.ycombinator.com