Plain text journaling in Vim | Hacker News Reader

Plain text journaling in Vim

peppe.rs

254 pointsgigatexal74 comments

I really love this. One nit I must pick, however, is with the "just-so" nature of the journal screenshots. I see something similar in pinterest-style "bullet journal"/habit tracking colourful journal layouts (example[0]). Specifically, these look nice (or work) only if your to-do list is just so, usually fairly short and with really short items on it. So the "demo" versions of these have mocked up content which fits vs. real content, which is frequently less uniform.

In this article, you'll see the demo content is a lot of "buy apples" and "make apple pie," but note that no to-do items exceed 18 characters which is the maximum length to fit nicely in that layout. So if you need to "buy turkey baster" (18c) you're OK, but if you need to "return turkey baster" (21c) you've overflowed the layout. Likewise, you can "call Alexander" (15c) but "send thank you card to alexander and elizabeth" (46c) is way over budget, and you'll need to mutilate it down to "ty card alex&beth" (18c) to fit. This leads, in the example, to shortening items to something like "shopping trip," at which point too much context is lost (what if you have a second shopping trip?).

Likewise, if you want to dump all the todos you can think of for the week and it's 20 or 30 small items, it's not clear that would work well in these layouts.

This is not to malign this system which I think is really cool, but to suggest that it's more useful to see real and more varied content in a system like this to see how it "really looks" rather than exclusively made-to-measure content of 1-6 super-short items per list.

0: https://anjahome.com/summer-bullet-journal-ideas/#What_Is_a_...

I agree. I suspect with some level of curmudgeonness that it's because author calls themself a pixel-artist. I have a brutalist CLI/programmer take on bullet journalling from vim, just for comparison:

https://jodavaho.io/posts/bash-journalling.html

https://jodavaho.io/posts/bullet-journalling.html

It is essentially:

- One hidden folder for journal entries

- Each entry is a file of the form YYYY-MM-DD.md

- A bash alias will open today's file (or "yesterday" or "next thursday" or "2 weeks") using the date cli util

- A few vim formatting steps make the already-well-functioning github markdown work very nicely.

I have the exact same system but step 4 is eMacs org mode

However my script only opens up the current date - love your extension to enable opening up other dates - gonna steal that :)

I do something similar, but switched from bash/vim/markdown to Joplin a while back. I lost the immediacy of bash, but seamless syncing and editing across multiple devices, especially mobile, made it worth it.

The main thing is that Joplin is still markdown, and I can trivially export if I want to switch to something else.

The code at https://jodavaho.io/posts/bash-journalling.html doesn't work for me. It looks like it is passing vim the -d args, which doesn't seem right since -d opens a diff view. I think you misplaced a comma for the date command. I fixed it for me by doing like this:

  function journal() {
    vim $logdir/$(date +%Y-%m-%d -d "$\*")
  }

Not a comma, but a close-paren. It turns out I had almost precisely that code in my bashrc (had below), so I updated the post to reflect this / your suggestion.

  function journal() {
    vim $logdir/$(date +%Y-%m-%d -d "$*").md
  }

Thanks!

Oh right, why did I say comma.

Highly recommend nb[0] for this type of stuff. I've been using it for a few years now and am still getting surprised by all the stuff it can do.

Some others have said it but the only problem with a lot of these systems is that by their very nature they are a better experience on a desktop than on mobile. Joplin is the only one I've used that even attempts to solve that problem. Even when you have one that works on mobile its a second class experience IMO. I used to try really hard to find a note capture system that I loved that worked in both environments. These days I just use apple notes on mobile and nb on desktop.

[0] https://xwmx.github.io/nb/

In terms of “just giving up and taking simple mobile notes” I can also endorse Google Keep iOS - natural affordances match my typical eng/Phil related use cases better than Apple notes.

I used keep for a bit. I liked it and agree it does the same thing apple notes does. I settled on apple notes for no other reason than a weird sense of minimalism if that makes sense. I've installed so many note apps over the years that I was spending more time on that than actually using something. I decided enough was enough. Apple notes has flaws (especially if you use other platforms) but they all do. I got tired of worrying about it and just decided to go all in warts and all.

the one thing I miss in apple notes is being able to drag and drop items of a list with checkboxes to re-order them.

You can do that, just click and hold on the checkboxes.

That does look cool. Would this work fine if presented with my Obsidian "vault", eg a folder full of markdown files? Looks like both apps like to operate on the same data.

I've used obsidian with nb before but you can't just open nb inside your vault and have it immediately work. nb uses .index files at the root of each directory to know what to display in the cli (I assume so it doesn't have to do a ton of I/O operations). You'd probably need to spend a bit of time understanding that stuff so you can write up a script or something to coordinate between the two. I ultimately just ditched obsidian and went with my afore mentioned apple notes/nb hybrid approach.

Ha, thanks!

I’ve had nb marked for investigation forever. It looks like it’s been steadily developed since I first saved it for later.

So do you store all your files in DropBox and the use Joplin to access them via mobile? I’m intrigued by how the two interact.

NB syncs via git. It’s automatic once you point it at a remote origin.

I don’t even try to access via mobile. You can but it’s a second class experience. I just use Apple notes and transfer anything I care about over to nb about once a week or so.

You probably can get a mobile thing going w Joplin or obsidian but it would require a little bit of scripting to get nb to pick up any new notes you create as it relies upon .index files at the root of each directory to know it’s contents instead of doing I/O operations. I assume this is for performance reasons.

Plug of basically the same idea except as a pip package:

https://github.com/Aperocky/diarycli

`pip install diarycli`

Alternatively there is a shell version if you are averse to python/pip package manager as well:

https://github.com/Aperocky/diaryman/blob/master/diaryman.sh

I've been using this for years, it doesn't have any fancy features - it only reliably opens up/create today's diary in vim whenever I type `diary` in command line. with some minor utilities.

It is life changing - having `diary` where I can type my thoughts into whenever. I maintain a separate one both for work and life - and both are proving invaluable.

This is an interesting way to do this. I've been using Sublime lately and it's been okay but I need some organization. Does this allow something like "diary [name] [text] where you can add text to any diary with that name and if there is none it creates a new one? I will look at this in more detail next weekend when I am off from work.

this is basically exactly what it does.

It looks through the folder (i.e. year/month/date.md) and try to find whether today's diary exist. If it does exist it just opens it, otherwise it creates it.

The script actually accept other terminal editors if you edit a single line in the package. I imagine it will be easy to change to use sublime as well.

Whenever I see systems like this I am left wondering what people do on mobile? Are you never in the need to write a note or create a task when you're away from the computer?

I use the Android app Orgzly. It edits org mode text files, and syncs them with my WebDAV shared folder.

Works pretty well, except for those times you don't have data.

I have managed to get doom emacs working on termux. I presume the same is possible with vim.

My fingers are too big to write much of anything on a touch keyboard, so I have to make due.

I feel you. If you look at my (brief) HN history, you see a lot of fat-thumbing while I'm on my lunch break.

I use a small notebook and Fisher Space Pen. To be honest, it just feels more comfortable with the way my brain is wired. I tend to remember things better when I write instead of type, and I jotva lot of stuff in the margins as thoughts start to flow, where others might find note-taking apps more suited to their style. It really just depends on how you process information.

I'm the same way but I use a hobonichi journal with a frixion erasable ink pen. It flows much smoother. I used to use a moleskine with fisher pen but I kept having to go over lines again. Maybe it works better in space.

If you're already using the frixion pens, you might like rocket book notebooks as well. They work with the frixion ink so that the pages wipe clean with a damp cloth, and there's also an app that will scan your notes to your cloud storage or email.

(Not an employee, just a big fan)

Hey how well does this work? I'm really interested but I'm wondering if after a few uses there is some residue.

I used to use rocketbooks back in school, and they were quite nice. This was a few years ago so I can't comment on it now, but I really enjoyed it then. You could setup various places for it to save to and there were boxes at the bottom of the page I could check and say the first box was checked it got sent to drive, the second box could be like dropbox etc I had all mine set to different google drive folders for my classes. It was able to scan everything quite well and was honestly pretty seamless to me. I feel like there were more features but I can't remember now, even if there weren't though I still liked the organizational structure of it all.

I haven't had any issues with residue after a lot of use. The only thing to watch out for is writing too hard and leaving a scratch in the paper, but that's easy enough to avoid.

I take a voice memo and transcribe it on my laptop later.

I keep my notes stored in iCloud Drive and use iWriter on my phone when I need to view/edit notes. It works just fine.

I have an Obsidian vault synced using Synthing. At first I thought that Android would kill the Syncthing background process all the time, but it's been fine so far (I do have to launch Synching manually after restarting my phone).

I don't use any of Obsidian's fancy features, apart from tags and the occasional note link (so that I don't have to copy-paste a reference from another note).

I use the "daily note" feature if I want to jot something down quickly. I then formalise it later and when I'm at my computer, I check in the markdown files into git with a script that modifies the timestamps of the commit(s) to match the last-modified date of the files I'm checking in. This is so that I can know exactly when I wrote down a note, so that I can correlate the commit with other records like my browser history.

I switched to Joplin for this reason. I used to use git + text editor, but it's not the best experience on Android, and seemingly near impossible on iOS.

For my phone I have created a simple Apple shortcut to take notes on a single click. The shortcut records audio and transcribes it into a reminder.

As much as I love the idea of them I've found systems like these never quite work for me in the real world. There's always a ticketing system for my employer where that stuff lives, and for personal stuff I absolutely need first class mobile support because that's generally the device I have with me when I remember something I need to do.

After many years I've eventually landed on using [work ticket tracker] for work tracking, Apple Reminders for todo lists which are rarely complex items, and Logseq for journaling. My journal really is just that, I rarely go back to previous entries, but I find it helpful to spend a bit of time each day just noting down what I did and how I felt about it. I sometimes joke that this is my insurance policy in case the Police knock on my door and ask me what I did on the 12th of March this year.

I arrived at exactly the same conclusion, but I use Notes for my todo list (I like mixing checklists and notes in one document) and leaving reminders for… you know, reminders.

I honestly enjoy it less than some of the more complex plain text systems I’ve used/built in the past but it has the advantage of actually being practical for me.

Huge fan of Logseq as well. I told a few folks about it at work and they're also quick believers. Very powerful and perfectly simple.

Looks fantastic of course, but I'm not sure it survives contact with reality. Just 7-8 tasks per week?

> We can clean this up with “abbreviations” (:h abbreviations):

It’s probably almost a decade since I last used an abbreviation; I consistently found I just didn’t quite like them, and migrated to other ways of doing things. It was digraphs at first, still a Vim feature, and then Compose key sequences, which is where I’ve stayed ever since, preferring them mostly because they work everywhere, not just Vim. Now I type apostrophes, quotation marks, dashes, and other interesting things as I go perfectly casually, and would hate to be without a Compose key. (I’ve typed every non-ASCII character in this comment with my Compose key—just as well I still remembered · even though I practically never use it any more.)

> You can use x and o as well, but × (U+00D7, MULTIPLICATION SIGN) and · (U+00B7, MIDDLE DOT) are more … gourmet.

I’d go more gourmet than that: I use • (U+2022 BULLET) and ‹ugh, gobbled by HN› (U+2713 CHECK MARK) for lists. If you really wanted a cross, you could also go with ‹ugh, gobbled by HN› (U+2717 BALLOT X). The ordering holds, either way: 0x2022 < 0x2713, though I cringe at unbridled sorting of these lines.

(I do all my own writing in a lightweight markup language I’ve been developing, one property of which is that it leans on CSS Counter Styles for lists for spectacular matching of source and compiled result, so that you can write “(i) ”, “17. ”, “• ”, “‹CHECK MARK› ”, &c. and get matching appearance in the HTML output—or will, when I finally get round to finishing the parser and implementing HTML conversion. I write lists with mingled •, and bullets and it’s great.)

Anyway: back to the abbreviations matter: you could also enter all these characters with digraphs (CTRL-K …) or Compose key sequences (Compose …, but since your keyboard lacks a Compose key you’ll need to map one—I use RAlt on my current laptop because that’s conveniently positioned, but I really wish my spacebar was just split into at least three keys):

• · is digraph .M or ~. and Compose sequence .- or .^ or ^.

• × is digraph *X or /\ and Compose sequence xx

• • is digraph oo and Compose sequence .=

• ‹CHECK MARK› is digraph OK and a popular Compose sequence is @/ (present in kragen’s list, as included out of the box by WinCompose, but not standard on other platforms)

• ‹BALLOT X› is digraph XX and a popular Compose sequence is @X

You can define your own Vim digraphs too (:digraph), and make your own ~/.XCompose to set your own Compose sequences.

For VSCode users who wandered into a vim thread wondering how to write these, there is a plug-in for that:

https://marketplace.visualstudio.com/items?itemName=GuidoTap...

With the list of Unicode characters supported here:

https://github.com/mvoidex/UnicodeMath/blob/master/table.md

I use vim, git, and a very simple set of bash aliases to do bullet journalling in vim. I have since 2013. No frills, no fuss, no formatting limitations... easy to copy / change.

https://jodavaho.io/posts/bash-journalling.html

https://jodavaho.io/posts/bullet-journalling.html

I like it and believe this is the right and sustainable approach.

For journaling I use the same directory structure but it is also a Hugo site so it can be simply turned into a blog.

I have also other categories in my system (notes which serve as blog articles; people which is my personal CRM where I also maintain my genealogy tree data; songs where I collect my favourite songs with chords and lyrics; music where I maintain my compositions; books I've read with reviews and scores etc.).

Hugo supports YAML preambules so you can add whatever metadata you wish to your files. Everything is in Git. Content is in Markdown.

It's a matter of a one-line command to get my weight stats or the last time I met someone or how many books I've read last year. I don't need to know these but it's easy to get that.

I have some bash scripts/aliases, e.g. to write a journal entry I use command `j` which will open four last days in vertical windows in Vim (and create the missing files if necessary and commit the changes then).

To seach any file inside the system I use fzf. You can simply use grep and other tools to navigate and work with the system. The public part is published by building the site and copying the data to my server. A matter of a few key strokes.

I guess it's time to describe it in more detail on my website.

This reminds me of the plain text bujo I kept for about 1–2 years a few years back, only much prettier. Mine was a single long file that I appended to each day. Like in the post, I used pretty standard Unixy tools. I could search, aggregate, and bulk update. The rest was based on conventions and discipline. And migrating to new conventions was doable with a throwaway script. All in all, it was a liberating experience.

Where it fell apart, and where I expect this approach might fall apart also:

- While it worked really well on desktop, I didn't find a way to make it translate to mobile. Sure, I could just edit the plain text file, but that's not enough when you have hundreds of todos scattered around.

- I had to remember too much about how all the different scripts worked together. I kept forgetting the commands I'd defined, especially when I was tired or stressed.

My middleroad these days is NotePlan. It gives me what I liked about bullet journaling (for me it's the 'rapid logging' part) but presents it in a sleepless night-proof UI that works well on iOS at the same time.

I found NotePlan and discovered an app which was a much better version of what I was already doing: daily Markdown notes. That if I ever decide I don't like the way the developer is taking the app I can just delete the app and keep using the Markdown files as-is is the killer feature.

In my experience with plain text systems like this, it gets hard to navigate and query things for review quickly. Once you add a tool to remove closed items, and another tool to organize into groups, and another tool to view your queries, you no longer have simplicity.

I wanna know what's that tablet on the noisy image.

Are you running a terminal or do you export as PNG or HTML?

Do you leave it running 24/7? Won't that burn the monitor?

Nice project.

I'm surprised there's hardly any mention of org-mode:

https://orgmode.org/

It can be as detailed or simple as you like, with built-in date keeping functionality. This article spends a lot of time getting that part.

I use it on Doom Emacs but it's available on vim too

Cue Emacs Org Mode argument.

Also, shouldn't it be

    cal -m 1

In zsh it complains without the extra argument.

Wouldn't `cal -m 1` show the year 0001 ?

Depends. I have zsh running on Linux and Mac. On Linux, smorrebrod wins. And on Mac slowmovingtarget wins.

I tried it on Mac... so I guess that's the difference. Thanks.

On macOS, `cal -m 1` prints out January 2023. The man page reads "-m month Display the specified month." Googling for man pages gives other usages for the `-m` switch (like https://linux.die.net/man/1/cal) so it probably depends on system.

Bash also doesn't seem to like the missing argument..

I wish I could journal straight into a directory, but I've found that it's crucial to have mobile access to my notes. That's why I mainly now write everything in Google Docs since it's simple and convenient (I tried Notion but was not a fan for various reasons I won't get into it).

The only issue with Docs though is there's no Vim support of course, which has annoyed me for a while. I finally got around to building an extension for it though if anyone is interested: https://chrome.google.com/webstore/detail/vim-for-google-doc...

Am I the only person who finds the idea of journaling into third party cloud to be an incredibly privacy-invading concept?

I always think of a journal as something containing notes that are raw enough that I would be embarrassed if any other person read them. The idea of sending that over a network to be stored in plain text on someone else's server is just horrifying to me.

I'd rather open JuiceSSH and log into my machine and open vim. Or I could use Synology Drive to edit a plain text document stored on my NAS. Is that really -that much- less convenient than opening a Google Doc? How inconvenient does the task need to be for me to allow random Googlers or their algorithms to read my innermost thoughts?

Yeah, I don't disagree. The notes I'm putting in Google Docs usually err on the side of being blog post ideas or things that I'd want to share with people at some point after I refine it. When it comes down to privacy for sensitive thoughts it's kind of hard to beat local files (and the inconvenience of mobile is just the price to pay).

I like this. I use vimwiki for my notes, but I'm struggling to get any sort of todo list working these days.

For a while I had some scripts that converted my vimwiki files to html and saved them to Google drive, and it would also find and extract pending todos.

As people have mentioned it requires a laptop with linux and vim on it, which is not very compatible with my work (windows machines) or my phone.

I wonder if buying something like a GPD pocket will solve this.

This is incredibly close to what I currently do, except I journal by the day and some of the markers are different (I use `-,.=*[` to give meaning to each item) and items are organized hierarchically via indents. I used to use vimwiki, then neorg, until finally realizing rolling my own simpler solution wouldn't be very hard. The syntax highlights help significantly, and linking is done via just vim's `gf`. I added a couple custom commands to auto open / generate diary entries and it became a super smooth note-taking experience for me.

I have a journal.log (textfile)

At the top i have a template command for creating a current timestamp

echo $(date '+%Y/%m/%d %H:%M:%S|%a| ') #run with :!!bash directly within vim. I copy this line and run it with :!!bash to init a new entry.

2023/06/19 20:52:02|Mo| Then I write my entries as oneliners

2023/06/19 20:52:02|Mo| Its grep-able like a normal system log file

2023/06/19 20:52:02|Mo| I also use tags, so i can more easily follow 'threads' #corrupt_storage

2023/06/19 20:52:02|Mo| Bad day today #disaster

This goes a long way for me (in broadstrokes):

vi code.go README ./notes ~/notes/topic reqs design TODO script.sh ~/journal/YYYYMMDD interesting.log scratch # etc

then git, rsynch, grep (etc) to heart's content

main hole is on phone where vi doesnt fit well, but on there either the builtin Notes app or a thirdparty GUI text editor/viewer is fine ("sneaker shared/synched" as needed). though bias to work on laptop where total time efficiency matters

I wonder, why nobody mentioned vimwiki. It has diary functionality (available via <leader>w<leader>w by default) that will create dated files.

I have been plain text journalling in vim for 18 months. I use a single file. Each day, at the bottom of the file, I put the date, then content. I use this system at work.

I do actually use the same concept of putting `TODO` `WIP` or `DONE` at the beginning of each task line, and I am usually using a task list with subheadings on any given day.

Let a simple package organize the folder structure and date for you:

https://github.com/Aperocky/diarycli

Or shell if you prefer that:

https://github.com/Aperocky/diaryman/blob/master/diaryman.sh

Been using this for 5 years+, and hopefully for decades more.

I will take a look -- however, since I only use a single file, it may not be needed.

Sounds like you might be writing markwhen (though it expects a colon after each date or date range)

https://github.com/mark-when/markwhen

Adding a layer on top would defeat the simplicity.

Curious, why go with something like this over obsidian?

You might not want everything in markdown format, and you might not want the extras you get with Obsidian. I put a lot of stuff into Obsidian, but sometimes the extra backticks and closing quotes and all that gets annoying. There are times you just want to open a text editor and type away.

Templates are great for this. I have templates for json/go/sh/etc formatting that i can insert using Ctrl+t, and then I'm off to the races. If you add the Templater plugin you can add custom logic such as where to place the cursor when the template is evaluated and inserted.

Admittedly, getting to this point with Obsidian is a bit of effort, but being on the other side I think it's worth it.

The Git plugin also automatically syncs my vault to a private github repo, so I always have my notes available from anywhere.

>We can now begin writing stuff down:

>λ vim journal/2023/1

I think you mean 01

The end result is pretty.

echo '#!/usr/bin/env nano' > notes && sudo chmod +x notes

This is how I write notes, and it's served me well for years.

Reply on news.ycombinator.com