Ask HN: How do you maintain your daily log?

[dr_kiszonka]

A few years ago, I read an excellent article on HN [0], which recommended keeping a daily log in a simple text file. I've been following this advice. Recording many short entries over a day is very useful for me. I can easily find items for my performance review, leave notes for myself, etc.

Questions:

1. What is your workflow?

2. What tools do you use?

3. If you log to a text file, how do you format your entries?

My framework

Daily log vs. daily journal

For me, entries in a daily journal require deeper thought and reflection on what you have done, your goals, etc. Usually, journaling is done 1-2 times/day. Conversely, entries in a daily log concern immediate actions and are done many times a day. However, your daily log could inform entries in your daily journal.

Daily log vs. a to-do list

For me, entries in a to-do list are only the things you need to do. Also, most to-do lists I've seen don't store the timestamp of when a to-do item was created. Conversely, entries in a daily log are more diverse and are all timestamped. They may include to-do items but don't have to. My entries are updates, notes, questions, and to-dos.

My log is a markdown file, which I edit in Sublime Text. I created Espanso [1] shortcuts to add timestamped entries. E.g., "zzq" expands to "[2022-10-26 10:45:24]: Question []:" and "zzn" expands to "[2022-10-26 10:45:56]: Note:". For proper task/to-do management, I use Amazing Marvin [2], which is decent.

   [2022-10-23 09:18:44]: Update: prepared slides for meeting with @Laura   #1on1 #projectLion

   [2022-10-23 10:54:36]: Note: I created a new keystore key using these instructions https://xxx.xxx, stored in keys dir #projectGamma

   [2022-10-23 11:16:54]: TODO [x]: deploy a new build, which fixes the bug with incorrectly parsed dates (id:1332); [2022-10-24 10:12:12]: rolled out, v17 (2.0-17) #projectGamma

   [2022-10-23 12:27:56]: TODO []: ask about daily log software on HN @me

   [2022-10-23 13:38:00]: Note: password for W in stored in LP #projectGamma

   [2022-10-23 13:43:25]: Question [x]: should the style guide be in the repo or YouTrack? @Alex #weeklymeet #projectGamma; [2022-10-25 15:17:13]: @alex said in YT because we'll use it in other projects

   [2022-10-23 14:11:15]: Question []: should we use Red Frames (https://github.com/maxhumber/redframes) in addition to Pandas? Criteria for decision? @me #projectLion

What do you want to improve and why?

   - I need an easier way to find, e.g., all questions from this week for @Alex about #projectGamma. I'd like to easily filter entries by date, project (#projectGamma), person (@Alex), and type (Update, Question). 

   - Nice to have but not required:
    - sort entries by status (not done: [], done: [x])
    - auto-timestamp when a to-do item was created and completed
    - surround selected text with [], {}, "" and auto-close them like a programming text editor, e.g., ST, VSCode
    - duplicate & move entries via shortcuts

What have you looked into?

   - People enjoy Obsidian [3] and Logseq [4]. I find them alluring too, but I don't yet know how to make them support my daily log. I'd need to spend at least a full day to figure out each of them, the time I don't have at the moment. (I use Obsidian for code snippets; it is excellent.)

   - Org-mode is very popular, but emacs and vim are way too much of a time investment (I tried many times before). Do share your evil and holy workflows, though. There are org-mode extensions for other text editors and EasyOrg [5]. I still need to try them.

   - I like the todo.txt format [6] and I am considering forking pter [7], but making it fit my needs would take quite a bit of work. 

Dealbreakers:

   - No Windows version

   - No desktop app

   - Subscription-based software, including charging for syncing between computers

   - No export option

Links posted in a comment.

[allanrbo]

Totally agree. A daily log in a simple text file is super useful for perf review etc., but even just to remind myself that my day wasn't wasted.

I use a little script I wrote that, once per hour, opens a full screen always-on-top window that forces me to write one sentence on what I have been doing this past hour, and saves it in a plain text file. The input field is a combobox, so I can just press arrow up if I'm doing the same thing as the previous hour. This way, by the end of the day, I have a journal for the day that went.

Linux: https://gist.github.com/allanrbo/4f2ae1968afe9cb8b3ce6e9580d...

Windows (includes screenshot to get a visual on this idea): https://allanrbo.blogspot.com/2017/05/utility-to-remind-you-...

[kabdib]

Brutal simplicity is the key for me.

I use a single flat text file, and use it for years. I have an editor macro that adds a new, timestamped entry at the end of the file, which looks something like this:

    ----------------
    27-Oct-2022 9:38:48 am
    
        |

The bar is where my cursor lands, all ready to start typing. A simple alias ("note") brings up the file. I can make a note in a second or two, then get back to what I was doing.

I dump everything into this file. At my last job, my notes file was maybe 20-30MB and nearly a decade old. I record hard-won knowledge, TODO items, pieces of debug sessions that are interesting, little notes about what's going on, jokes and random thoughts, contact info, whatever. Editors load big files fast, and incremental search works great. The idea is to make this practice fast, nearly frictionless, and not adopt complications that are tough to maintain over time.

I've found that the less formal and structured I make things, the more notes I take; if I had to conform to a schema it would be a burden. No Emacs modes. No email or contact or TODO-system integration. Just notes.

It's saved my butt more times that I can remember. It's great to have at review time, too.

[afefers]

This is so cool! Care to share it? I'm a non-programmer-who-wants-to-be-a-programmer and I loved this approach.

[karanmg]

Graph paper notepad and pen.

* Write down today what you want to accomplish tomorrow. Each item on a line.

* Check them off the next day.

* You could add meetings, but if your day is full of meetings rely on your calendar for that.

* If you did something meaningful, not on the list, add it. Cross it out.

* There will be enough space on the paper to capture some meeting notes or thoughts.

* At end of day, throw (recycle) or retain that page.

I use the Amazon Basics graph paper notepad and a simple gel pen.

Writing works better than most things if you need a list.

For long projects, I use Apple notes to capture the plan. When ready to be worked on, I switch to paper.

[kiernanmcgowan]

Pen and paper is criminally overlooked when it comes to note taking. I personally use a little hard cover blank book, date the upper corner, and list what I work on as I move through the day.

The "friction" of having to write things down means that you only write down the things that matter vs having a perfect log of the day, which makes reviewing easier.

Finally, if theres any end of date notes or things to highlight for the next day just star or underline them.

No push notifications, no alerts, no pings, no monthly fee, secure, and helps to improve your spelling and penmanship.

[ZeroCool2u]

I really prefer the act of physically writing notes, but not being able to search them is kind of a deal breaker. Physically writing them helps me remember, but I'm always going to want to look back and reference things on occasion, that's basically half the purpose of writing them in the first place.

It's the only reason I'd consider getting an iPad, but it just seems so wasteful for that express purpose.

[vidyesh]

Very nice system.

I too prefer a graph paper hard bound notebook and I follow the Ryder Carroll's bullet journaling format. Currently its just a daily log of tasks but I am planning to expand to be a dev log too.

> For long projects, I use Apple notes to capture the plan. When ready to be worked on, I switch to paper.

Interesting, I generally write everything in a notebook transfer it in Trello and generally transfer daily tasks back to daily log as and if needed.

[mattpallissard]

I have a different system, but paper and pen are king. I'm a prolific note taker so I use pen and paper as a landing pad, then periodically I look back and copy the useful information into tickets, documents, wikis, my long term orgmode notes in vcs.

[dr_kiszonka]

Links:

0. Unfortunately, I cannot find the link anymore. I think it was one of those "what I learned during my 50 years as a senior software engineer". The author possibly mentioned using Kate-editor. It was a really good article.

1. Espanso (free): https://espanso.org

2. Amazing Marvin (paid): https://amazingmarvin.com

3. Obsidian (free/subscription for sync): https://obsidian.md

4. Logseq (free): https://logseq.com

5. EasyOrg (paid): https://easyorgmode.com/

6. todo.txt format: https://github.com/todotxt/todo.txt

7. pter: https://github.com/vonshednob/pter

[taurusnoises]

This may not be the link yre looking for, but it's one of the articles that spurred a recent interest in single-file daily logs...

https://jeffhuang.com/productivity_text_file/

[ElevenLathe]

I use index cards. On my desk, I have a stack of blank ones and a "discard" pile of used ones next to it. If I start a new activity, I grab a blank one, date it, and write a title (something like "Meeting with Alice about API standards" or "debugging XXXXXX" where XXXXX is some ticket number or whatever). I use this for notes and "working memory". At the end of the day I transfer anything I need to continue working on to my datebook, our JIRA analogue, or possibly just leave the card "active" at my desk. When I'm done with a card, I put it on the discard pile.

Every so often I empty the discard pile into shoebox for storage. I produce about 3/4 of a shoebox per year so storage isn't really a problem (yet). Since they're all dated and more or less chronological, it's easy to go back and reconstruct what I was doing on a given day, and I can also thumb through them for ammunition come review time.

I currently use 3x5 cards but am thinking about upsizing to 4x6 (postcard size).

[matanrubin]

Obsidian, with a few community plugins, is amazing and is exactly what you're looking for. It's true that there's a learning curve, but spending a few hours to learn a tool that you will use for years is a pretty sweet deal.

Take a look at obsidian-tasks, templater, and the dataview plugins to understand how powerful (yet simple) this is.

[immrammc]

I couldn’t agree more; Obsidian is just a fantastic tool for this. I’d like to add that the calendar plugin has been really helpful to quickly navigate between and create notes for each day or week. Keeping notes both on a daily basis and weekly basis has helped me to better plan and evaluate what I’ve been doing.

[meheleventyone]

I’ve kept a daily log for the past six years just in a Google Doc. All I do is a bullet list of what I’ve done in the day and collect a bullet list of TODOs. Then comb the TODOs at the start of the day.

Works great, makes sure I don’t forget what I’ve been doing or should be doing and means the entire team can see what I’m working on and what I’m thinking about.

I don’t really get all the obsession with structure, style and having a specific application for notes. For me this is mostly a way to keep organised with a brain that’s prone to lose things without regular reprompting.

[mmplxx]

You can use check lists instead of bullet lists for TODOs now. I'm in the same boat except that I pin a few post-its in Google Keep, since it's easier to use from my phone and I'm also able to set reminders in case I need them.

[147]

I use org-mode with org-journal https://github.com/bastibe/org-journal

What's nice about this workflow is when I create TODO items and don't finish them for a day it transfers over to the next day.

[stevekemp]

Over time I've discovered there are some things that happen every day:

* The review of pull-requests.

* Meetings.

* Some "tickets" I work on.

* etc

So with that in mind I have an emacs org-file, which has a standard set of headers which are inserted in a single file, beneath today's date.

I use the following emacs package to make that easy to manage:

* https://github.com/skx/org-diary

With that in place I get something like this automatically:

      * 31/08/2022                                                   
      ** Desktop Setup
      Updated my =brew= environment once again, this time it was =git= that required the update.
      ** Merge Requests Reviewed
      None.
      ** Meetings
      - 11:15-11:45 - Example Meeting
        - Notes here
      ** Tickets / Stories / Projects
      - JIRA-1 IN-PROGRESSS example-project
        - Stuff I did.
      - JIRA-2 DONE example-project
        - Stuff I did.
      ** Problems
      None.

On export to HTML/PDF any section that is empty, or contains only "None." is removed.

[LinuxBender]

I use a shell function I found somewhere. It might have been linked here, I can't remember. This is probably only useful for people that spend a lot of time in a shell. One could adjust the text formatting and date format to their preference.

    # cat /etc/profile.d/notes.sh

    function notes()
    {
    if [ ! -z "$1" ]; then
     mkdir --mode=00750 -p ~/.notes
     Now=$(date '+%Y%m%d.%H%M.%S')
     echo -en "\n$Now\t$@\n\n" >> ~/.notes/notes.txt
    else
     echo "${Now}"
     cat ~/.notes/notes.txt 2>/dev/null
     fi
    }

For syncing I suppose this could be pushed to a cifs/nfs/sshfs share, or into a git repo or emailed.

Usage: notes some text -or- notes "some text that needs to be quoted in a shell;/;-)" then "notes" by itself to read all the notes. I suppose a function to null out the notes.txt file would be handy and maybe a function to commit the notes to a repo.

[belkarx]

I have something extremely similar (https://gist.github.com/belkarx/f3af7c1176ade27107330fa09c84...)

[dr_kiszonka]

And I guess you could have a grep/regex function for filtering :)

[jamisonbryant]

This methodology was taught to me by my employer and requires a Slack channel. I like it.

Step 1: send yourself a message and mark it as Saved. It will now show up in your Saved items. The message should contain a section for what you did yesterday and what you're going to do today. Other than that it can be any content or formatting you like.

Step 2: set up a channel for posting your daily logs, e.g. #yesterdayandtoday

Step 3: update your daily log (saved message) as you go through your day. Add things you did TODAY in the Yesterday section, add things you know you have to do TOMORROW in the Tomorrow section.

Step 4: At the start of each day, copy-paste your saved message into the daily logs channel. Do this every day, this will form the longevity of your logs.

Finally, to review all your logs, just search for your name in the channel. Or tags, or whatever. I like to divide my log entries between tasks, accomplishments, blockers, and goals.

[em-bee]

you don't need slack for that, any messenger that allows editing messages for at least a day will work. you can even just use a folder and files for each day if you just need it for yourself.

but i like to pick up on the messenger idea. instead of doing something structured like above i would just keep sending messages to a private group or channel as i go through my day. an instant timestamped log that can be accessed from any platform supported by my chosen messenger.

[amflare]

I used Obsidian's Daily Note Core Plugin in conjunction with the Templater Community Plugin. It creates a new markdown file in .../DailyLog/YYYY/MM/DD.md using a template that automatically adds some assorted frontmatter (like current company name or project) and a full date (Thursday, October 27th, 2022) as the H1 header. Then I just use the file to keep random notes or as a scratch pad. I don't enforce any organization, so sometimes it's just a SQL query that I had to run 35 times that day, sometimes it's a todo list, and other times is a full narrative log of my day and the issues I was running into.

I used to do this in Sublime, which was fine, but Obsidian let me automate the date and frontmatter stuff, which made my life marginally easier. The point though, is that Obsidian is not something I'm locked into, which is nice.

[dr_kiszonka]

Thanks for responding! I am curious about splitting your log into per day files. How would you go about finding a specific SQL query that you used last month, but don't remember the exact day? Is there a way in Obsidian to combine all days into a single view? Or would you search for files with SQL queries (e.g., notes with both "select" and "from")?

[acemarke]

I wrote a post a couple years ago about how I do daily work journals:

- https://blog.isquaredsoftware.com/2020/09/coding-career-advi...

Since then, I've switched tools. I now use VS Code to write a Markdown file per-day. I also use the Foam extension, although the only feature I actually use from that is the "Create Daily Note" command, specifically tweaked to auto-create the right folders and filenames like "2022-10-24 (Monday).md" and similar main file header. I keep those in a Git repo.

[antoineMoPa]

Workflow: I store tiny bits of code, shell lines, reminders, tiny text drafts, links, random notes. I frequently search backwards to find some specific lines of code or shell script.

Tools: I use a single org-mode file and I have a shortcut command in Emacs to launch it (M-x wl). When I run this command, it generates a new entry with the date and time and places my cursor so I can type right away.

  (defun wl ()
    "Open work log"
    (interactive)
    (find-file "~/dailylog/wl.org")
    (newentry)
    )
  
  (defun newentry ()
    "New log entry"
    (interactive)
    (search-forward "#now#")
    (beginning-of-line)
    (insert "\n\n* ")
    (insert (shell-command-to-string "date"))
    (dotimes (i 50) (insert "="))
    (insert "\n\n\n")
    (forward-line -2)
    )
  
  ;; bonus function
  (defun codeblock ()
    (interactive)
    (insert "#+NAME\n")
    (insert "#+BEGIN_SRC javascript\n")
    (insert "#+END_SRC\n")
    (forward-line -1)
    )

Format: No particular format except the auto-generated date above. There needs to be the string '#now#' in ~/dailylog/wl.org, this is where new entries are generated.

[nilslindemann]

You can do useful things with Code Browser, it has folding and links. Aka, it is the simplest possible form of a hypertext. As it is just text, things can easily be scripted.

https://tibleiz.net/code-browser/download.html

I have kept an older, personally preferred version of that Editor on my GitHub Repo, unfortunately it does not perform stable on Linux and I have not been able to compile it on that system, in order to fix the bugs.

https://github.com/nilslindemann/Code_Browser_49/blob/master...

Here is a video showing how it works (my older version + scripts):

https://www.youtube.com/watch?v=sU4ThIJ6eKc

I also use this editor for code, it gives me the expressiveness I need, but its comments make the code look terrible in other editors.

I wish these features were available in other text editors. For someone used to Code Browsers folding capabilities, other editors are just awkward. But I guess other Coders will think the same when they see that they don't even get completion in Code Browser. Also, it is quite a niche editor.

[dbieber]

I keep a Go Note Go by my desk. If I have something to write down, I simply type it in and hit enter.

Go Note Go is a note-taking system for when you're on the go, with a focus on driving and camping. It's just a headless keyboard (Raspberry Pi 400) -- no monitor, no display at all -- that you can type on (or speak to; it has a microphone). Anything you type will get uploaded to your notes, and if you speak it will get transcribed automatically and uploaded to your notes, all as soon as the device gets an internet connection (so you can use it offline, e.g. when camping).

Being single-purpose is really nice -- no time lost switching apps or waiting for something to load before you can type. And being screenless is nice too: it feels really freeing to not think about typos or wording etc, and to just keep moving forward.

For me, the notes are uploaded to Roam Research, but it supports other note-taking systems too (e.g. email, Notion, RemNote, Ideaflow, Mem, ...).

Links: https://davidbieber.com/projects/go-note-go/ https://github.com/dbieber/GoNoteGo

[nokya]

I use notepad++, simple text file, with one macro recorded:

- Ctrl+End (goes to end of file)

- New line

- New line

- Left bracket

- Edit > Insert > Date time (custom)

- Right bracket

- New line

The macro is assigned to my F5 key, everytime I press it, the sequence is triggered.

In my file, it will more or less look like this:

[...previous log entry...]

[2022-10-28 12:48:31]

- wrote comment about my time macro in notepad++ on HN

- https://news.ycombinator.com/item?id=33359329

[masukomi]

big orgmode doc with headings for each day. Timestamp inserted via quick key combo. then i execute a snippet which preps a list of line items created/merged/closed that i then fill in as the day progresses.

todos exist in other org-mode docs.

> - Org-mode is very popular, but emacs and vim are way too much of a time investment (I tried many times before). Do share your evil and holy workflows, though. There are org-mode extensions for other text editors and EasyOrg [5]. I still need to try them.

I would argue that vim and emacs being "too much of a time investment" is a common misconception based on the incorrect implication / belief that you need to learn "all the things" or "most of the things". there's far too much. no-one can. Last time i checked there were 2956 8 1/2 x 11 pages worth of help docs for vim. No-one knows it all.

I came from vim, was a huge fan and teacher, and moved to emacs largely because of the lure of org-mode.

In both i have learned that you need to learn essentially nothing to get work done. For example: here's my vim quick start. You can learn it in < 30 seconds. the only other thing you need to know is `vim path/to/file` to open the file.

that's enough to have you productive, because once you enter insert mode it's just a normal text editor. Do it in a GUI version and you've got mouse interaction too.

You don't _need_ to learn anything else. You'll _want_ to learn more, but the thing is that all the "more" you _want_ to learn can be done at whatever relaxed pace you want.

now, there are caveats and asterisks in that emacs and vim are both incredibly bare bones in their default configuration with no plugins or tweaks. Like...reeeeeeealy bare bones. So, there's a good argument to be made to start with a common distribution that bundles plugins. I use Doom emacs which is great if you're a vim geek.

But, even then my point remains. There is very little you actually _need_ to know in emacs or vim in order to get work done, and you can learn the other things you want to learn as you have time and inclination.

https://vim.works/2019/03/03/emergency-vim-quickstart/

[guynamedloren]

I maintain a Notion database with calendar view. Each day, I create a new note/entry for the given day using a "standup" template, which simply prompts for: what I worked on yesterday, what I'll work on today, and then below, all of my notes for the day. The page itself is freeform, so I can include things like todo lists, code snippets, etc. It's worth clarifying that "todos" here are micro-tasks related to my work that day, not longer running tasks that I'll address over days or weeks (those are logged elsewhere).

This system works really well for me. I've stuck with it for years, longer than any other "daily log" system I've tried.

Why it works for me:

- The separation of notes between days mitigates the visual clutter that comes with a "one giant document" system. Each day I start with a blank slate.

- I can quickly reference notes from any day in the past by scanning the calendar and finding the day I worked on a particular thing.

- Everything is still searchable via Notion's global search.