I used to keep a so-called shitlist for a long term project I was involved in.<p>The idea was to document all the worst places in the codebase(150k LOC) that frequently caused weird behaviours.<p>Each record contained a short description, the reason why this piece is bad, hash of the commit that introduced it and of course the perpetrator.<p>Of course the main purpose it served was to relieve stress, nevertheless it helped me with my work a few times.<p>One could ask why didn't I just refactor these pieces right away? Two things often stopped me from doing this: first, some of those lines were over eight years old and a huge part of the system depended on their sometimes buggy behaviour. Second, the company review policy was "stability, stability, stability", so any change beyond the scope of the thing I was working on was automatically rejected.
I keep a bugs.txt text file (complete with alias for opening it), in which I record particularly difficult or tricky bugs. It's a really good way to learn from hard bugs. At the top of the file I have a template that I copy each time I add an entry. It has the following fields:<p>Date:<p>Symptom:<p>Cause:<p>How found:<p>Fix:<p>Fixed in file(s):<p>Caused by me:<p>Time taken to resolve bug:<p>Lessons:<p>I've used this system for 15 years now (210 entries), and it's been very helpful, especially for lessons learned.<p>More here:
<a href="https://henrikwarne.com/2016/04/28/learning-from-your-bugs/" rel="nofollow">https://henrikwarne.com/2016/04/28/learning-from-your-bugs/</a><p><a href="https://henrikwarne.com/2016/06/16/18-lessons-from-13-years-of-tricky-bugs/" rel="nofollow">https://henrikwarne.com/2016/06/16/18-lessons-from-13-years-...</a>
Similar but not the same: most days day at work I create one or more txt files in notepad (kate to be exact) where I paste every temporary info while I work on some task. Basically everything that doesn't go to git, and you have to keep somewhere while you're working on it:<p>- nonobvious terminal commands or small scripts I had to write<p>- fixes for enviromental/configuration problems<p>- fragments of stacktraces<p>- fragments of log files<p>- packages that needed to be installed<p>- short todo lists I created while doing sth<p>- links to webpages I found that had a solution to my problem<p>- profiling results for solutions I compared<p>- parts of emails I copied to focus on the important fragments with stuff to check/fix<p>- names of temporary branches created when working on the problem<p>- xml fragments from some requests I copypasted to kate to prettify it<p>There's no structure and no plain English descriptions in these files, just bunch of copypasted stuff separated by a few empty lines in a text file.<p>I have to keep these things somewhere anyway while I work on them, and pasting them in one file that I later save in one directory preserves them for future. I call the file yyyymmdd_some_keywords.txt.<p>I don't bother to describe the task in plain English, the stuff that's copypasted there is enough for context, I can also check git from same date if something's not clear. The most important thing is - there's no overhead, just open the file when starting a new task, keep it opened while you work on sth and save it when you finish. So I have hundreds of these files after a while, and when I encounter some problem I can quickly grep to check if I seen similar stacktrace before and what it was about.<p>Before I started doing this I had several instances of déjà vu - I could swear I've seen this problem before but can't remember what it was about and how it was solved.
Back in the late 1990s and early 2000s I experimented with a number of complex rich text, database, and proprietary formats for my notes files. It was a disaster in terms of long term accessibility. Since ~2004 or so I've used exclusively a single plain text file with embedded filepaths if media references were required.<p>This has worked far better and now offers a remarkable resource for both nostalgia and getting stuff done. It's huge and search is pretty much the only way through it but I still add every day.<p>Plain text is best. I feel that even using vim to automate time stamps is too complex. I just write it once by hand. It's easy and literally takes half a second.
Great idea. Welcome to the .txt family. A while ago I published Journal.TXT - a single-text file format for journals and the human multi-document format for writers. See <a href="https://journaltxt.github.io" rel="nofollow">https://journaltxt.github.io</a><p>PS: I also started Awesome .TXT -
A collection of awesome .TXT tools, formats, services, tips & tricks and more. See <a href="https://github.com/officetxt/awesome-txt" rel="nofollow">https://github.com/officetxt/awesome-txt</a>
For a decade or so, I've been using `vim -o ~/{todo,progress,done}`<p>That gives me vim with three splits. Every day I add a new heading with the current date in the bottom split, then in the top one I list the things I plan to do that day. As new urgent work comes in throughout the day, I add it to the top split too. When I start working on something, I move it to the middle split. If I have to shift between tasks, I'll keep their entries in the middle split up to data with what i've done, next steps, etc. When I finish something, I move it from the middle split to the bottom split.<p>You can see a sample at <a href="https://imgur.com/a/jNa5Qp3" rel="nofollow">https://imgur.com/a/jNa5Qp3</a><p>This helps me<p>* plan how much I can accomplish in a day<p>* limit the number of things I'm doing at once<p>* remember context when i do have to multitask<p>* explain to others (e.g. my manager) what i've been working on
For those who use Emacs, org-capture is probably the way to go: <a href="https://orgmode.org/manual/Capture.html#Capture" rel="nofollow">https://orgmode.org/manual/Capture.html#Capture</a>
This reminds me of the `plan` files used by John Carmack and and ID software. It's a good way to look back at things and remember how far you've gone and give some perspective on how some big problems at the time were not so big today...
I've got a small A6 notebook for this, computers are great, but there's still work to be done in translating the abstract diagram/flowchart/sketch amalgamation that's in my brain to a digital representation.<p>A picture tells a a thousand words, there's pages where I tried redesigning a scene graph implementation, it'd take hours to transcribe the knowledge that I gleaned from those (roughly drawn) images into words.
> Its super important to take a second every once in a while to simple write down what you did during the past mental sprint. Writing down what you learned solidifies the knowledge.<p>Sorry, I didn't get why it's super important.
Isn't it a context switch?
How does it really help to solidify the knowledge?
How often do you review those did files?
How exactly reviewing what you did helps? (I'm thinking of myself reading some "did" from the past and fail to see any benefit).
How this solution is better than using Notes or Google Keep or whatever online tool?
How to manage it across multiple machines and backup it?<p>If the goal is to solidify knowledge, I can't help but suggest using Anki: there was an article about in HN not so long ago: <a href="http://augmentingcognition.com/ltm.html" rel="nofollow">http://augmentingcognition.com/ltm.html</a>
Sharing my utility Jot: <a href="https://github.com/mkaz/jot" rel="nofollow">https://github.com/mkaz/jot</a><p>Jot stores notes in text files organized by date, includes simple searching, templates, and a few other niceties; plus you can add notes via command-line, pipe, or open in your EDITOR (vim)
I like it. Of course I created my own note/task-taking app years ago, which I can't even find anymore. It was in Perl. The purpose was to have a user-friendly command-line interface. If I was going to grep for something, I wanted to display the results in a nice way. To list notes or tasks done, priorities, etc I wanted to sort and display in a nice way. And eventually I added a merge function if I forgot I had more than one editor open at a time. I think I abandoned it for the same reason I abandon every note-taking app I try: it's just not easy enough to use everywhere.<p>The note-taking app I use most often now is e-mail drafts. I write an e-mail to no one and save it as a draft. It's synced everywhere, sorted by date, has a subject (which can be edited to include tags such as "(!) ", "(plan)", "(done)"), can contain any text format (even attachments), and it works on every e-mail client and server. Maybe I should write an interface to it...
For quick notes the most important for me is as little friction as possible.<p>Having to switch to a terminal and using an alias is too much friction.<p>So I have a global hotkey which I can press anywhere on my desktop, regardless of the current application and if I press it it opens an editor window with the current timestamp already added, so all I have to do is type and press a key to finish the entry.<p>This way I don't have to switch apps to make a note, I stay in the current context and it's so quick and convenient to make notes that I don't even have to think about doing it.
In case it's useful to anyone (or they want to pick at my code), here's a quick and dirty python thing I use to automate timestamps on journal entries. It just accepts strings of text and saves them in a file named with today's date and a time above each entry.<p><pre><code> import time
user_input = ""
date_string = '-'.join([str(n).zfill(2) for n in time.localtime(time.time())[0:3]])
while user_input != "q":
user_input = raw_input("Log entry (q to quit): ")
with open("time_log_"+date_string+".txt","a") as timelog:
#timelog.write(time.asctime(time.localtime(time.time()))+'\n')
timelog.write(
'-'.join([str(n).zfill(2) for n in time.localtime(time.time())[0:3]])
+ ' '
+ ':'.join([str(n).zfill(2) for n in time.localtime(time.time())[3:5]])
+ ' | '
+ user_input
+ '\n')</code></pre>
<a href="http://todotxt.org" rel="nofollow">http://todotxt.org</a> has a format for a done.txt list, too. Useful before project meetings to get an overview over what you did in the last days.<p>TodoTxtMac creates this for me:
<a href="https://mjdescy.github.io/TodoTxtMac/" rel="nofollow">https://mjdescy.github.io/TodoTxtMac/</a><p>I've been using it together with Dropbox (for access from my phone) for 3 years now.
Tool as a tool (I work daily with a "nth-priority-ideas.md", and appreciate that plaintext files clutter-free, portable, customizable, etc).<p>But what I found inspiring is to maintain a list of <i>accomplished</i> tasks, not only a daunting one of todos. My PhD co-advisor run one, maybe I should have copied this approach.
For the same reason, I use vimwiki[0] with its diary features, which is much better regards syntax highlighting linking.<p>[0] <a href="https://github.com/vimwiki/vimwiki" rel="nofollow">https://github.com/vimwiki/vimwiki</a>
[1] <a href="https://github.com/vimwiki/vimwiki/blob/master/doc/vimwiki.txt#L1735" rel="nofollow">https://github.com/vimwiki/vimwiki/blob/master/doc/vimwiki.t...</a>
EDIT: I made a [Github project](<a href="https://github.com/stevenschmatz/did" rel="nofollow">https://github.com/stevenschmatz/did</a>) which adds a few niceties to this blog post, like better dates, no date duplication, and syntax highlighting in Markdown.<p>---<p>If you want syntax highlighting and better dates, you can use a Markdown file with the following command:<p>```
vim +'normal Go' +'r!date +"\# \%B \%d, \%Y (\%A)"' ~/did.md
```<p>Make sure to turn `syntax: on` in your `.vimrc`.
What I do for all of my side projects now is keep a TODOs.md file in the project root. I no longer keep track of to-dos for programming projects external to the project. I find it makes it much easier to pick up a project I've left for a while.<p>What I do is every time I think of a new work item or discover a bug, I add an item to the list. Once I finish an item, I check it off. Since it's checked in with everything else, it's a good history of what work was "discovered" along the way and what work has been done.<p>For the last few years, I've worked on a bunch of little side projects projects here and there and this system has kept me sane.<p>For an example, see <a href="https://raw.githubusercontent.com/allenu/YokosukaJS/master/TODOs.md" rel="nofollow">https://raw.githubusercontent.com/allenu/YokosukaJS/master/T...</a>
Keeping a "did" file is also immensely valuable to demonstrating your performance and achievements to your employer. Think about all the positive things you've done for work over the past year. It's hard to account for them all mentally, and even harder for your boss to remember.
I keep an info.txt file about useful commands and information. Years ago I remember an HN comment on someone that stored everything as Prolog facts that could be consulted.<p>I still like paper and can remember this post on this slick way to index a paper based notepad. I will have to dig it up.
I was using Vimwiki for this stuff for long, but this idea seems promising for a daily journal.<p>I mostly divide my tasks by day so I don't want timestamp to be added everytime I add an entry. Here's my aliases if it helps:<p><pre><code> alias ndid="nvim +'normal Go' +'r!date' +'normal o' +':exe \"normal i=============================\<Esc>\"' ~/Dropbox/did.txt"
alias did="nvim +'normal G' +startinsert ~/Dropbox/did.txt"
</code></pre>
So use `n(ew)did` at the start of the day and for every subsequent entries, use `did`. Also using Dropbox as storage for portability.
In my .zshrc I have<p><pre><code> todo() {vi '+$' ~/todo/$(date +Y/%m)}
+() {echo + $* >> ~/todo/$(date +Y/%m)}
-() {echo - - $* >> ~/todo/$(date +Y/%m)}
</code></pre>
Each month's entries are in a separate ~/todo/YYYY/MM file. The + command is to record something done. The - command is to enter a new task. The todo command is for editing this month's file -- add month-days, update entries, cleanup etc.<p>Separately I have current and last 2 month files open in the leftmost column of acme (about half as wide as other columns). This is for moving entries between months etc. I have to remember to do a Get before editing and Put when done editing to sync with any updates done from command line.<p>In the same column I have a per year "projects" file (multiple indented lines per project) and a per year "future" file (things I may want to do someday).<p>This is far from perfect but has endured. A simple grep can tell me what was done or what needs to be done in a given month or year.<p>For taking notes in a meeting I have now switched over to using an ipad + apple pencil as I can scribble notes, draw pictures, doodle etc. without having a laptop screen between me and others or clicking keys annoying people.
For Notepad++, I'm using a custom "TODO" syntax highlighting [0]. I like this for "temporary" TODOs (mostly work-related stuff to be done today) and as an overview for my scrum dailies.<p>[0] <a href="https://github.com/darekkay/config-files/tree/master/notepad%2B%2B#todo" rel="nofollow">https://github.com/darekkay/config-files/tree/master/notepad...</a>
Not sure I understand the reason for needing to keep track of things like the examples shown...<p>On the other hand, if I am in the middle of some large changes I will make notes at the end of the day before I leave the office. I usually write down what I accomplished and what remains to be done as well as anything I need to come back to. I don't get too fancy with it, usually just use Sticky Notes on my Windows PC at work.
Here's what I use for this same purpose: my fork of someone else's old and unmaintained pet project. I think it's pretty good. It creates a new entry each day, or appends to this day's diary entry.<p>It has a few subcommands, which are date-aware.<p><a href="https://github.com/alexthehurst/Diary.py" rel="nofollow">https://github.com/alexthehurst/Diary.py</a>
I sort of had a did.txt for 3 years, updated quite often during my working hours (at least once a day, if I were super busy, to dump all my daily activities and notes). It was quite useful for standup meetings and such. It is a pretty gigantic did.txt now, and in 3 years can you guess how many times I needed the info sitting there? Zero... go figure :-(
I love how many ways there are to do this. My version uses empty Git commits: <a href="https://github.com/ellotheth/dotfiles/blob/master/bash_funcs#L1-L8" rel="nofollow">https://github.com/ellotheth/dotfiles/blob/master/bash_funcs...</a>
I log everything worth remembering and some. Whether it is something I did, a link I want to read, or something I bought. I use a file called log.txt. It is synced across all my devices. I have a very minimal format that goes like this:<p><pre><code> # 16/07/2018
- read about did.txt on HN
- [ ] write about log.txt on HN
- cost: 2.9€ coffee at 93
</code></pre>
I grep for - [ ] to see my incomplete tasks, and add an x like - [x] when the task is complete. When the file grows large I move months to separate files.<p>I tried Evernote, onenote, physical notebooks and a hundred other tools. This is one that I settled on. All I need is a text editor on any platform.<p>Back to the log, there are several times I have visited it to find out what happened during the day. I use it at times as a review of how well the week went and what I could improve on.
Back (some time ago) when work, etc., had me spending a lot of time on Windows, I found and used this generous free and open-source project.<p><a href="https://www.codeproject.com/articles/5371/todolist" rel="nofollow">https://www.codeproject.com/articles/5371/todolist</a><p>Looking now at the revision history, it looks as if something may have happened to Dan after last summer.<p>It wasn't plaintext, but it and its format are open. And I found it a pretty good combination of features in a compact presentation.<p>There've been a couple of recent "to do" threads, that made me think of this. This thread finally got me to look it up.<p>I never tried this:<p><a href="http://abstractspoon.com/wiki/doku.php?id=linux" rel="nofollow">http://abstractspoon.com/wiki/doku.php?id=linux</a>
Self plug: I wrote <a href="https://github.com/dbalan/idid" rel="nofollow">https://github.com/dbalan/idid</a> to do more or less the same thing when my did file needed a bit more structure (also an excuse to write some haskell).
I made one of these, too. Here's a gist: <a href="https://gist.github.com/chadlavi/15fd674162ccbd2f4765bd76f3321f13" rel="nofollow">https://gist.github.com/chadlavi/15fd674162ccbd2f4765bd76f33...</a>
I wrote about something similar in a comment <a href="https://news.ycombinator.com/item?id=16322942" rel="nofollow">https://news.ycombinator.com/item?id=16322942</a><p>It's served me well. I have records from as far back as 2009.
I have done something similar some years ago. Reminds me it's probably time to update. <a href="https://fimdomeio.com/thingsIhaveDone.txt" rel="nofollow">https://fimdomeio.com/thingsIhaveDone.txt</a>
I would recommend, <a href="http://jrnl.sh" rel="nofollow">http://jrnl.sh</a> it's made for the purpose described but in a much better and simpler way (also allows tagging and searching in a simple way).
These small log files really help to keep things in perspective. However for longer plans I use Trello. It works as an issue tracker / planner for me so I can put the bits I find on the issue to the cards, or to my dropbox and link them.<p>When I finish a task, I put all relevant information to a folder in my "Old documents" folder, and put the card to the "Done" column. If the task is a project, everything is already become documented and archived on git at the end.
Does anyone know of a good open source text-based journaling system that lets you easily inline images/audio/video/etc, with render-to-html functionality? My goal is to document what's going on in my life, and that's not really possible with only text. This is where Evernote really shines in my opinion. I've been missing that functionality ever since I got off Evernote. Been wanting to create a basic system for myself for a while now.
Since the start of this year I've been keeping a similar journal. Instead of opening an editor to write a single line to a text file, I just print the arguments of a command to the end of a file and prefixed with a timestamp. Since there's no need to review or save the file, there's no interruption in what I'm doing. Logging things to the file feels like shooting things into the ether and I end up doing it constantly throughout the day.
This is the one that I use<p>> doing is a basic CLI for adding and listing “what was I doing” reminders in a TaskPaper-formatted text file. It allows for multiple sections/categories and flexible output formatting.<p><a href="http://brettterpstra.com/projects/doing/" rel="nofollow">http://brettterpstra.com/projects/doing/</a>
I just store all of my shell command-lines in a big file, including the date and current working directory. That way, I can always grep and see what I did. For stuff that doesn't happen on the commandline, I just type "echo" followed by a description of what I did, and it ends up in the history file just the same.
If you're using vim already for journaling, you should try Vimwiki. Out of the box, it has a diary, and typing Leader-W-Leader-W opens a buffer with today's diary file, ready to record things you've done or serve as a scratchpad for the day that you can search and refer to later.
I found that using this snippet leaves the cursor at the start of the date string, so I have to shift+A then enter to get to the next line to start typing. Adding +'put _' to the command inserts a newline so that you can immediately switch to insert mode and start typing.
I wish all linux servers had something like this, out of the box, for all users.<p>the first thing I do after sshing into a box is spend an hour trying to figure out the basics. Where are the web folders? what daemons is running? what hacks does have in place?
I'll throw mine into the pile of other solutions posted here. I hope someone finds it useful:<p><a href="https://github.com/chrisallenlane/node-did" rel="nofollow">https://github.com/chrisallenlane/node-did</a>
I put the author's terminal command into an Alfred Workflow: <a href="https://github.com/geberl/alfred-did-txt" rel="nofollow">https://github.com/geberl/alfred-did-txt</a>
If the file does not exist, then<p><pre><code> vim +'normal Go' +'r!date' ~/did.txt
</code></pre>
creates a file with the first two lines being blank.