I do the same-ish thing. Main highlights on mine: 1) I start off the day with things I should be working on (samesies) 2) I use ### to demarcate different "working sessions" ... one for each meeting, etc. 3) I struggle with finding something that lets me: encrypt, search, big notes, and use multi platform easily :( Closest I've found was google keep so far .. but i hate relying on it like that. I'm pretty sure "something" plus encrypted sqlite will work once i find it. 4) I name it Today.YYYYMMDD ... I'm trying to get into the habit of retroing once a month, creating a Month.YYYYMMDD to try to be more reflective and understand high level impact I had and systemic issues I'm running into.

The number of times this has saved me time figuring out "Oh .. i saw that error before .. how did I fix it?" and "who did i talk to about X and what did they say" months to years later has proven to be super helpful and I will be continuing indefinitely.

I started using Joplin https://joplinapp.org/ some time ago.

Open-source. Encrypted if you want. Synchronized using WebDAV (also Dropbox, NextCloud and OneDrive). Uses markdown. Has tags. And apps for everything (Windows/macOS/Linux/Android/iOS/terminal).

The monthly retro is a great idea. I think I'll be stealing that one, thanks!

I use Zettlr as a markdown editor, with the underlying directory being in git. It's not encrypted, though doing that should be pretty easy with something like EncFS.

Standard Notes is my Google Keep replacement. Fully encrypted, straightforward business model, works great, apps available on iOS and Android.

Thank you for this suggestion. I hadn't heard of Standard Notes before and had stopped using Evernote in 2016 to switch to just Markdown files on disk w/ Git. I've migrated everything into it and this looks pretty much perfect for what I need (better tag management would be my only ask).

Thank you for the recommendation. Looks like it has all the security features I’m desperately missing from all Google products and would make their products an easy default go-to.

Thanks. That was next on my list :)

Vimwiki works great for this! Hyperlinks and diary management, all plain text and able to be opened in anything.

I can second using Vimwiki! I have mine set up to automatically sync with Gitlab every so often too, so it’s automatically backed up.

I use https://github.com/gitwatch/gitwatch to do this.

I'm curious if there is something you are using on mobile for vimwiki? I've been using termux on Android, which works well enough.

Sadly I don’t have a solution for mobile. The truth is that I mostly use it on the computer though so it really hasn’t been a problem.

My backup method is pretty simple but it’s been silently chugging along for months now without a single hiccup. It’s just a git commit via cron job: https://thelinell.com/using-vimwiki/

I've done similar. I used to use Quiver[1] for years. It's MacOS only. Then in October, I was forced onto a Windows machine for work. I tried Joplin as it was the closest in features, and it has built in encryption.

What I eventually ended up doing was moving to vscode. I use it my main IDE for the last couple years. I have a linux vm running for all my development, with vscode remote ssh.

- I keep a folder for each month - I have a file in each month called YYYYMM-dailies.md, level 2 headings for each day - Notes that grow too complex for the "dailies" get their own file in the folder. A number of these might get polished and copied into a document site somewhere. - Sometimes I'll make a subdirectory of "snips" with small scripts or pseudo-scripts (stuff to copy/paste) - The integrated shell lets me paste commands into my dev vm and copy the results back into my notes.

A feature of this is that while it's not really "synchronized", I can vscode-remote-ssh from multiple machines, or just ssh into the vm to get my notes. You can use rclone or keybase+rsync to backup the notes directory (or keybase's git if you want to check notes in).

Another

[1]: https://happenapps.com/

There are many markdown based journal programs, some with encryption. Do these not work for you?

My bits were on MacOS, Linux, Win, iOS, and required usage w/o internet (so I could work on airplanes, etc.).. so _something_ was always missing (between those + encrypted + searching).

Can you suggest any in particular?

My personal choice for markdown notes is https://github.com/glushchenko/fsnotes

If you’re a Vim user, Vimwiki is awesome:

- https://github.com/vimwiki/vimwiki

- https://thelinell.com/using-vimwiki/

I don't have much experiences with them (flat text files aren't my style), but a friend seems happy with Joplin.

A HN search illustrates the amount of markdown note apps available: https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que...

Joplin would be perfect if it allowed quick inter-note linking. Obsidian and Zettlr seem to do this much better. But for journaling I love Joplin.

> I'm a software engineer, and I've been keeping a "lab journal" on and off for the past decade or so.

I studied (a mix of EE/CS) in the EE dept., and we were actually taught to do keep such notebooks/journals, as in electronics labs were assessed on what the contents of your lab book, not on what you'd produced or measured (or at least not 'hey lab assistant look at my 'scope, see, done it' - obviously measurements would be recorded, but then the assessment's more 'why' and 'was that expected' than just a copied value from a neighbour).

I hated it at the time and wasn't particularly good at it ('writing what I'm doing just slows me down and distracts me from doing') but I've worked in software engineering since and wished I'd stuck at it. I've briefly tried in fits and bursts but never maintained it as 'this is how I work', despite having a former colleague who did.

Probably time I tried again, I agree it's worth it.

You can use git to do it in a way that's fairly natural for software development.

Absolutely. I did something slightly simpler: a single file with a per-day section. This helped immensely with quarterly reviews (I'd forget a lot of things I'd accomplished), and REALLY helped when I hit an obscure bug (typically a configuration thing) that I'd seen several months previously.

I'm glad to see I'm not alone! I also had ~/Work.MD stored for the past few years. Each day I add the date as a new top-level heading, and write notes of what I did.

I've recently started contracting (and billing hourly) so I've switched to using an org-mode file, which contains commands, links to internal stories, and other things.

As I'm contracting I figured I might be asked to justify the hours-billed, etc. So for the first time I'm explicitly writing the daily-log with the expectation that I'll share it, and the employer will see what I write.

That (perceived) level of scrutiny has really improved the detail and coverage of what I document.

only share if you have to. and better negotiate on outcomes instead of hours. just a tip :-) took me a while to understand why

I'd mostly share the specific details of what I'd done with my peers, rather than the "higher up" who hired me. It's like documentation, or knowledge-sharing, which is an important part of team-work.

But good comment, thank you!

Yup this is exactly what I do as well. In physics you are required to keep a detailed lab log. I kept doing it when I started my coop and slowly it evolved to the single file with day entries. I also keep a separate file for ongoing personal todos.

Same here. After a year or so i got tired of actually 'vi ~/worklog.txt' and made an alias. The alias opens up that txt file in VI, goes to end of the file, and starts a newline in insert mode haha. LOVE IT

As I started to get more experienced (also software development) I noticed that more and more people were seeking out my help - which was frustrating, because I had goals I was supposed to be working toward myself. I found that keeping a log of each interruption and how long I spent on it eased my anxiety quite a bit: although I've never actually been asked to justify why it took "so long" to complete a task, having that documentation handy just in case made me a lot more pleasant to work with.

That's quite interesting, turning the work tracking on its head and tracking interruptions instead.

Some days I wonder where the day goes, with interruptions and getting back in the zone, it's a miracle anything gets done.

I've been doing something very similar to this for the past year and a half. I was inspired by one of my coworkers who has a long running list of notes in a google doc.

I run "vim `date -I`", which opens a file for the current day in the form `YYYY-MM-DD`. I keep it in a git repo that I commit and push to every time I add a note.

I separate topics using `===` surrounded by blank lines. When I go back to update a topic I already wrote something about, I separate it with `--` surrounded by blank lines.

The main thing this ends up being useful to me for is that I put off filing my timesheets until the end of the month, and then when our accounting lady gets after me, I can go back and actually write down semi-accurate notes on what I did each day.

Thanks for the tip! For anyone else who misread the `date` command and used a lowercase L, here's the command in monospace. It's an uppercase I.

    vim $(date -I)

Try this alias.

  alias jim=' \
    journaldir="/home/myusername/journal/" ; \
    jfile="log_`date -I`.txt" ;       \
    jfilepath="$journaldir$jfile" ;   \
    echo "Creating log: $jfilepath" ; \ 
    vi $jfilepath ; '

Instructions:

(1) Copy to your .bash_aliases file.

(2) Edit the journaldir, and replace myusername with your name.

(3) Create a journal directory somewhere for #2.

(4) Source it. source ~/.bash_aliases

(5) jim will open up today's note in Vi.

Try it out, and let me know.

Or, here's an even better alias.

  alias jim=' \
    journaldir="$HOME/journal" ;   \
    year="`date +%Y`" ;            \
    yearpath="$journaldir/$year" ; \
    [[ -d "$yearpath" ]] || mkdir -p $yearpath ; \
    jfile="log_`date -I`.md" ;                \
    jfilepath="$journaldir/$year/$jfile" ;    \
    header="# log_`date -I`\n\n# Highlights:\n\n" ; \
    [[ -f "$jfilepath" ]] && echo "Opening log: $jfilepath" || { echo "Creating new log: $jfilepath" ; echo -e "$header" >  $jfilepath ; } ; \
    vi $jfilepath ; '

Copy this to your .bash_aliases file. It's fully automatic. It'll create the directories automatically.

This will now create a /home/user/journal/YEAR/journalfile.md. It's now separated by year, so that you can run this forever, and have a maximum of 365 files per year directory.

This is a markdown file. And in the header variable, I had it fill in the new file with some basic headers. You can edit this yourself to add more.

Try it out, and let me know.

jim date: illegal option -- I

on macos

It seems Bash on Mac doesn't work quite the same as Linux.

Try this instead. It works for me. Let me know.

Copy it to your ~/.bash_aliases. And source it.

  alias jim='
    function _jim() {
        journaldir="$HOME/journal"
        year=`date "+%Y"`
        today=`date "+%Y-%m-%d"`
        yearpath="$journaldir/$year"
        [[ -d "$yearpath" ]] || mkdir -p $yearpath         
        jfile="log_$today.md"
        jfilepath="$journaldir/$year/$jfile"
        header="# Log: $today\n\n# Highlights:\n\n" 
        [[ -f "$jfilepath" ]] && echo "Opening log: $jfilepath" || { echo "Creating new log: $jfilepath" ; echo -e "$header" >  $jfilepath ; } 
        vi "$jfilepath"
    }; _jim'

I have something similar, with the folder syncing to google drive, you could encrypt if you want to before hand but I never got to it, I separate one file per month.

  alias journal="vim ~/workspace/google-drive/journal/$(date "+%Y-%m")"

Then in vim I have this mapping, by pressing F2 it opens a new line at the end of the file so you can just start typing. I add goals to the beggining of the week with the F3 map.

  nnoremap <F2> Go<NL><Esc>i<Esc>"=strftime("\%A, \%Y-\%m-\%d \%H:\%M:\%S")<CR>po    - 
  nnoremap <F3> Go<NL><NL><Esc>iWeek <Esc>"=strftime("\%V ")<CR>p<Esc>i goals:<CR>    - 

Monday -> Press F3 -> like a bujo, review what is still relevant and move to next week or drop it.

  Week 10 goals:
      - [ ] check connectivity with service x, splunk and service Y, from new environment
      - [ ] xxxx

Then whenever I will change context in my mind I just go back to the open buffer and press F2. I normally start my day looking at what happened over the other remote branches, and update my weekly goals task list

  Thursday, 2020-07-09 08:25:52
      - emails / slack

  Thursday, 2020-07-09 08:36:13
      - support x person

  Thursday, 2020-07-09 10:00:00
      - dog break

  Thursday, 2020-07-09 10:00:00
      - HN

Then at then end of the year I create a folder `archive/201X/` and move all the files under it.

I had a calendar event reminding me to review what happened over the week on Friday afternoon, but that is just lying to myself. I got to do once or twice over the last couple of years, that is something I need to improve on which is the whole point of article, review it while it is fresh and learn from it.

edit: code format

Neat. I'll try this out. I had never remapped a key in Vi before.

Check out my other alias, in the sibling comment. I improved on it.

I do something like this too. I keep markdown files related to projects I'm working on. I never really made the connection between what I do and lab journals, although I'm familiar with the concept. This makes me think that I could be more organized with my own markdown files. I never thought to create a new one each day and copy the useful stuff from the day before, but that would probably help me be more organized. It can be overwhelming to sort through days worth of missteps just to figure out where you left off on a project.

I'm pretty disorganized by nature, so I need something to help me stay on track. The simple act of reading through that todo list first thing in the morning helps a lot. "Oh yeah, I finished that, that needs a bit more work, that's half way done". Depending on what it is I'm working on, it can be as simple as 5 bullet points, or it can be headings and paragraphs.

I try not to be strict about the format, and it's certainly evolved over the years.

For instance, we have a weekly department meeting. There's now a section "Dept Meeting" in today's file with a few points I want to bring up. Maybe they'll get resolved by then, or maybe I'll add more points. The simple act of copying that file each day and removing what's no longer relevant means I have refreshed my memory, don't have to worry about stuff that's no longer relevant, and have a track record of what I thought was relevant.

I do the same, but using paper notebooks. I was able to accurately fill out a financial report because of the notes I took over a year ago on a large processing job. It's very helpful to do and organizes my thoughts. Using paper also lets you draw when needed and sketch out how an algorithm should work.

Spot on. The evidential value of a consistently written log can be huge and important for a wide variety of reasons. I have had two situations in my life where my having kept dated notes spared me a whole lot of grief.

I'm curious as to how to implement this ?

I mean, i currently put everything that needs doing into org-mode, clock in on the task when i'm working on it, and clock out when i'm done. Mark the task completed, and archive done tasks daily to an archive file.

I guess that's the limit of my daily "todo" activities. It's mostly in point form "x needs doing", "request confirmation from x", "send status on project x to y".

If i'd have to do it in a "daily file" i have no idea how to structure it. Todo'ish lists probably wouldn't work. They're either done or they're not. I guess it would have to be more like "short stories".

I went the opposite direction as you may be going: from daily markdown files, to 1 giant org mode file where the date is the top header, to 1 giant org mode file where my TODOs etc. are the top header.

I think what works best depends upon how you plan to use them and what your workflow looks like. But I have tended to find the "1 giant file" is a better fit for me.

Might I suggest checking out org-journal? It's a natural extension of the org-mode way of things, and integrates quite well with the agenda too.

Because of my lousy memory I've been doing several versions of the same for a long time. It's the most impactful thing I've done in my various jobs. Early in my career, a reputation for good records put me in charge of projects, with remarkable levels of autonomy. Early career $manager tends to appreciate junior reports who invest in their own accountability.

Smart. And you use grep to search through your archives. Simple, elegant, effective. I like it.

We use that and then post it in slack at the end of day as a kind of async status/standup update.

I'm thinking I probably need more organization than simple note-taking. I tried daily journals but it's hard to find stuff later unless you happen to land on the perfect cross-linking or search system, or somehow integrate with a reminders app, and have the system support every type of document or diagram you need from your markdown...

I get caught up trying to design the best system, and end up with something that only half works -- I just post notes to myself in Slack, particularly in the @you channel, the one it sets up for you at your username. Downside: every time I switch jobs, I lose a TON of context. Upside: everything's in Slack and I don't have to worry immediately. :) Plus, it's always possible that I'd lose the computer I was taking notes on, or not allowed to sync notes to my own private repo, or whatnot.

If I need to write longer-form notes than Slack allows, though, I often turn to Notes app or OneNote (if on Windows). But ... it's constrained because I end up not being able to stick with one cross-platform note taking tool -- the tools I use are too different. Still waiting for the perfect tool that has yet to arrive... I suspect the answer lies in the operating system -- to track what I work on in any app and helping me surface and record metadata better. To move from tracking files and folders to helping me track activities and outputs/decisions. Integrating git commit logs with macOS-like app-based revision history with operating system file browsing (for other kinds of cloud storage) seems like the right level of abstraction to work at, but I'm not sure what the right UI would be. :)