How do you maintain your daily log?

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

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.

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.

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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/

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.

I've used the same system for about 8 years. I have a folder of Markdown files labeled "diary"; in that folder are files named YYYY-MM-DD.md. I use these files as a daily scratchpad, recording what needs to be done, what I accomplished, and notes from meetings, conversations, etc.

I originally created this system when I was using vimwiki, but it is compatible with Obsidian's Daily Notes feature too (a big advantage to using A Folder of Markdown Files as a knowledge base). In fact, the two can share a diary without undue effort.

Obsidian does charge for sync, but you don't have to use their sync service. You can sync yourself using syncthing, dropbox, or whatever you like. I use git to sync, with the obsidian-git plugin[1].

[1] https://github.com/denolehov/obsidian-git

I know you said no Windows — and I haven't used Windows in over a decade.

But back when I did use it, it had a nifty feature where if you create a new empty text file in notepad and save it as .LOG, then each time you open that file it'll append the timestamp. Something like that (my memory about it is a little hazy).

Taskwarrior has a `log' subcommand, originally used to note down tasks that you have already done. In combination with the tool's search & filter capabilities this results in a quite decent log tool.

You can use a specialized tag to separate your log from your finished tasks. I was using "+memo".

So

    task +memo +yak "Tuned up my Emacs config a bit now it boots -0.02s faster"

You can use Taskwarrior's other features such as projects, contexts etc. with this. And of course you can use as many tags as you like.

Also you can customize report formats for your log, and create shell aliases to make logging and looking up easier.

Edit: typo

I use Obsidian. I have a template that lets me pick an existing project (also just a note) and then it creates a log file for that project. Then I just keep adding time stamped entries to it. It’s not so fancy yet that it automatically adds a link from the project to the log file but the other way around is added.

That way I can easily find all log files through the back links.

It works really well because it gives me a space where I can add stream of conscious stuff which is incredibly useful for later on writing blog posts or documentation where I still remember the various pain points.

But it also separates these logs from the actual project note so I can keep that space tidier.

I used to use Evernote, since moved to OneNote. Just a page per day with a table (I have a template). One column is some amount of time (usually valued in pomodoros, sometimes minutes for meetings). The other column is just what I was doing during that time. The full-text search and sync is really the big advantage of using those note taking platforms. It’s weirdly wonderful to be able to grab a note from like 6 years ago and know exactly what I was working on that day.

I’m FTE now, but I’ve actually billed hours by totaling these logs in the past and it worked well.

I built my own To Do website, custom domain, hosted on pi (but I have since moved it to digital ocean hosting).

It's basically a toy website that I used to try out web frameworks. In my case I tried out Python's Django and Flask. Other people have done the same in a variety of languages and frameworks - check out https://todomvc.com/

It has the colors, font, work-flow, features that I want.

It's a log, not a daily one. I use pieces of paper. Started with various wikis, org, markdown, text file, email. Refined and refined it to the bare minimum. Came a point where all I needed was some random piece of paper and something to write with.

My end goal is to not even need these. But I haven't met anyone that at that level and I don't see a way to get there.

One key insight - its not about writing things. Its about reading them and re-reading them.

Logseq with https://github.com/QWxleA/logseq-interstitial-heading-plugin

So its the Date and Bulletpoints for each New Activity with Timestamp. Often I jump from task to task and have to add what I have done later. Sometimes it does not work at all (if I am away from my PC). Guess I am at a 80% rate and its fine.

Apple notes.

It gives a hierarchy, so todos, meeting notes, etc., can be organized. Search is reasonable.

Not perfect, but better than one large word doc, which I had been Using before.

I use Tiddlywiki, though in the past year or so, I've started using text editors as buffers (though I sometimes edit my Tiddlywiki from my text editors as well). I've found a surprising number of things I write are logs (often logs within logs). Here's one window: https://philosopher.life/#New

I built https://github.com/spy16/connote with similar problems in mind when it comes to note-taking. It does not have all the features you are talking about though.

It's more of a command-line note-organizer tool that makes it slightly easier to index and manage bunch of markdown files.

I use Workflowy for this. I use my daily log as both a todo list and as a retroactive recording of what I did (without timestamps though).

I use mdsilo: https://mdsilo.com/ there is a github-like daily activities heatmap

I actually don't keep a daily log. But I'd do it with Joplin, since I'm already using it for note taking.

I’ve tried many things. The thing that (at least so far) seems to be sticking is a note per day in Apple Notes. It contains what I planned to achieve, what I did achieve, and bullet points on thoughts from the day.

At least for me anything more complex than that turns into a quagmire of optimising the process at the expense of not actually using it.

Vimwiki's list and checkbox format, with daily headers set up by !!date. It's portable, can be fairly easily migrated, and it's all text.

It's also perfectly portable with pretty much any text editor, vimwiki just makes indentation and nested checkmark management easy.

Use a draft email in gmail.

Better than notepad in terms of formatting etc and very reliably available across devices.

I use Roam, which is like obsidian, but the default view is a daily page that automatically get's created every day, vs having to manually do it in Obsidian. Happy to message about it if it seems interesting. Downside is it is not free.

If you’re on a Mac, I recommend NotePlan. It’s perfect for daily logs and supports markdown. It also syncs with iPhone via your iCloud account.

https://noteplan.co/

For work I use what's on my machine eg. Apple Notes

Personally I use my own CRUD app be it cross-platform desktop apps or Chrome extension since I spend most of my time in Chrome. Both write to the same DB.

xit + syncthing

https://xit.jotaen.net/

https://syncthing.net/

I understand the need for a task list. But a daily log? What is for? If I need to find something I have done in the past, I have git.

Obsidian– a markdown file with the date in ISO 8601 format.

First are notes I take before the standup, then general notes of what I did that day.

I keep searchable daily notes in a OneNote doc. It's useful for finding old information and performance reviews.

I work on everything randomly and don’t maintain any log.

I use a single text file for daily log and interstitial journaling:

# date

---

## End of day

- (what to look at tomorrow)

---

time

- note

time

- note

- note

TaskTXT. a new page once a day, and reviewing previous pages as needed

I use a mac app called Epiphany Workflow.

My what?

my what?