- nonobvious terminal commands or small scripts I had to write
- fixes for enviromental/configuration problems
- fragments of stacktraces
- fragments of log files
- packages that needed to be installed
- short todo lists I created while doing sth
- links to webpages I found that had a solution to my problem
- profiling results for solutions I compared
- parts of emails I copied to focus on the important fragments with stuff to check/fix
- names of temporary branches created when working on the problem
- xml fragments from some requests I copypasted to kate to prettify it
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.
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.
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.
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.
I use ClipX at work (Windows), fairly sure it has a logging feature, and I think it can be told not to record from password fields; and Flycut at home (Mac) but Flycut doesn't seem to have logging.
I have a script that copies them up to my backup drive and Windows full-text indexing is enabled on the folder, so it is easy to search all the content from the start menu. It helps me because my memory is not the best...your point on the deja vu is right on.
The stuff that ends up being really helpful, such as some long bash command, PS for querying AD, complex DB queries, etc. get promoted to helpful_notes.txt.
That way I end up with 100+ unnamed files in notepad++. At least it is searchable.
I looked at Google’s scripting and didn’t see an easy way to open and append text like timestamp.
I used something similar and just appended a file in Dropbox, but I have a few locations that don’t allow Dropbox mounted.
I've started to number these myself in my own ticket system where I keep scripts, screenshots and logs etc. but I'm using OneNote, because it's so unrestrictive.
https://snap.philsnow.io/2018-07-16T11-15-11.9p5nrv1j2ohavi6...
I once was really good about keeping notes like this, but I stopped when I couldn't integrate it very well with the flavor-of-the-day bug tracker my team used.
https://github.com/alphapapa/helm-org-rifle
You can give mulitple search terms to search for them in any order with instant results when typing.
(Religious org-mode user for approximately four years.)
I mean, you can tortuously gin up some plaintext format by hand, or you can use Org mode; you can tortuously gin up a skin over git by hand, or you can use Magit; you can tortuously gin up a skin over wget/curl by hand, or you can just use eww.
The idea was to document all the worst places in the codebase(150k LOC) that frequently caused weird behaviours.
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.
Of course the main purpose it served was to relieve stress, nevertheless it helped me with my work a few times.
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.
TODO, REDO, DONE with the corresponding JIRA ticket ID for extended mental notes (Pull Request fits here too). IDEs can grok all that together so you can quantify the bad stuff in the code, which can help management make better decisions.
rails notes
That seems more preferable to becoming what essentially amounts to becoming a mouth piece for potential areas of preference (error?) in software design.
Date:
Symptom:
Cause:
How found:
Fix:
Fixed in file(s):
Caused by me:
Time taken to resolve bug:
Lessons:
I've used this system for 15 years now (210 entries), and it's been very helpful, especially for lessons learned.
More here: https://henrikwarne.com/2016/04/28/learning-from-your-bugs/
https://henrikwarne.com/2016/06/16/18-lessons-from-13-years-...
I like this a lot, I've been using my blog as an extension of my brain and the act of formulating a single post about a text file forced me to clarify my thoughts. Ill try this the next time I find bugs. Also +1 for split keyboards!
> 6. Changing assumptions
My solution for this is to litter my code with "assert" which acts to both document the assumptions and prevent them sneaking past the point where the assumption was made.
Oh, and the file is called entomology.txt because it's more about studying them then logging them.
It will create a time-stamp (similar to F5) each time you open the document.
So nothing for us that never closes applications ;)
vim +'$r!date' did.txtI use the same approach for a super simple "pomodoro" timer:
alias pomo='echo "Starting timer for 25 minutes"; sleep 1500 && zenity --info --text "Pomodoro break; 5 minutes"; sleep 300 && zenity --info --text "Pomodoro: back to work"'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.
You can see a sample at https://imgur.com/a/jNa5Qp3
This helps me
* plan how much I can accomplish in a day
* limit the number of things I'm doing at once
* remember context when i do have to multitask
* explain to others (e.g. my manager) what i've been working on
edit: I was curious so pulled up the man page: changing -o to -O opens the windows horizontally stacked.
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.
The computer is a gateway to a billion distractions, my most productive days are the ones where I manage to write down the most on paper. The physical act of writing helps memory, and it works everywhere.
Physically checking checkboxes is also fun, as is crossing out plans that become irrelevant during the day.
Having to switch to a terminal and using an alias is too much friction.
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.
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.
Given that the examples are all for 'vim', this appears to have been written from the viewpoint that one is already in a terminal, so there is no switching friction when one's focus is a terminal at the start.
Also, you can have ideas or want to make notes when reading a PDF or browsing some documentation, so your editor or terminal are not the only apps from where you want to initiate creating a new note.
Agreed on the global hot key. I use iTerm and it has a global hot key so you can bring it up with a shortcut and then hide it with the same shortcut.
My hotkey software can also send keypresses to running apps, so beside bringing the note app to the foreground it also starts creating a new note automatically.
No reason you couldn't have a text file with setup notes on a system and have commit any updates so you have a trackable log.
In fact for any employee it’s useful to keep track of stuff like this, come PR time.
I started using the did file while learning a new language, don’t remember which. I’d have 15 tabs open with different docs and tutorials but very very little actual code written or way to mark where I was. I settled on a single text file and It was super helpful to just look back a week and notice there was some measurable progress.
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)
todo() {vi '+$' ~/todo/$(date +Y/%m)}
+() {echo + $* >> ~/todo/$(date +Y/%m)}
-() {echo - - $* >> ~/todo/$(date +Y/%m)}
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.
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).
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.
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.
A todo list is more effective if you do regular reviews (daily/weekly/month/yearly). Similarly mindfulness at the time of deleting a someday task may provide useful feedback.
The apparent lack of info about this (short of reading the source myself), and it still being in "beta" makes me very reluctant to trust it with my important data.
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.
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.
You don't even need grep, as vimwiki has built-in search:
":VWS /pattern/
Search for /pattern/ in all files of current wiki.
To display all matches use |:lopen| command.
To display next match use |:lnext| command.
To display previous match use |:lprevious| command."TodoTxtMac creates this for me: https://mjdescy.github.io/TodoTxtMac/
I've been using it together with Dropbox (for access from my phone) for 3 years now.
There used to be an Android app for todotxt, but it does not seem to exist / work anymore after the Dropbox API changed.
As a manager I suggested to my reports that this in addition to proving your work, it also helps as a way to understand whether you are stagnating at work, or continuing to learn and evolve.
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:
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"
vim +'normal Go' +'r!date' ~/did.txt
#######################################
# Normalizes date arguments
# Globals:
# None
# Arguments:
# date (defaults to today)
# Returns:
# string of format 'YYYY-MM-DD'
#######################################
function getDate {
local DATE=${1:-$(date -I)};
if [[ "${DATE}" =~ [+]+ ]]; then
DATE=$(date -I -d" ${DATE} days");
elif [[ "${DATE}" =~ ^- ]]; then
DATE=$(date -I -d" ${DATE} days");
elif [[ "${DATE}" == "tomorrow" ]]; then
DATE=$(date -I -d" +1 days");
elif [[ "${DATE}" == "yesterday" ]]; then
DATE=$(date -I -d" -1 days");
fi
echo "${DATE}";
}
#######################################
# Load a journal file
# Globals:
# None
# Arguments:
# date (defaults to today)
# Returns:
# None
#######################################
function journal {
local DATE=$(getDate "$1");
emacs ~/notes/journal/${DATE}.md;
} case "$DATE" in
+*|-*)
DATE=$(date -I -d" $DATE days") ;;
tomorrow)
DATE=$(date -I -d" +1 days") ;;
yesterday)
DATE=$(date -I -d" -1 days") ;;
esacPS: I also started Awesome .TXT - A collection of awesome .TXT tools, formats, services, tips & tricks and more. See https://github.com/officetxt/awesome-txt
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') import datetime
user_input = raw_input("Log entry: ")
with open("did.log", "a") as timelog:
timelog.write('\n')
timelog.write(datetime.datetime.now().strftime("%Y-%m-%d %H:%M (%a)"))
timelog.write(': ')
timelog.write(user_input)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.
1) I find it easier to browse written pages. It also seems to tweak some sort of memorization when I need to recall things from long long ago. I doodle a lot, especially during meetings so I can recall when I needed to remember a note that it was written somewhere around the page with a dinosaur wearing a baseball cap in the margin
2) Taking my eyes away from the screen to jot my tasks, is almost like a mental reset. It causes me to slow down and think more about what I've done or will be doing tomorrow
3) It almost becomes an "additional monitor" to have up. No tabbing to a file, no spacing things on desktops to keep the work list above other forms; its just there, off to my left to view.
4) (EDIT) Can't believe I almost forgot what I consider the strongest point... is connecting thoughts. Trying to draw a line between comments I made earlier and something I've done just now is nearly impossible to do cleanly in text IMO. Notes like "See July 4th, 10:35PM" is worthless and requires a new level of focus that a squiggly arrow just accomplishes so much easier. Colouring in a black box above an important note I want to immediately catch my attention when i'm flipping backwards is so much more important to me than any text file organization.
Org mode (a plain text format ljke Markdown, but much more than that) files export easily to Markdown, HTML, tex/PDF, and multitude of other formats using Emacs itself or even Pandoc.
My site (in my HN profile), for example contains text, images, etc. The content source is in Org mode.
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'm thinking of a bash script that takes a title starts a text file in the folder ~/.plan with filename generated from the title but prepended by date in yyddmmhhmm format. Might get me recording more things.
Like others, I use paper for the doodles and diagrams.
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?
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: http://augmentingcognition.com/ltm.html
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...
But what I found inspiring is to maintain a list of accomplished tasks, not only a daunting one of todos. My PhD co-advisor run one, maybe I should have copied this approach.
[0] https://github.com/vimwiki/vimwiki [1] https://github.com/vimwiki/vimwiki/blob/master/doc/vimwiki.t...
---
If you want syntax highlighting and better dates, you can use a Markdown file with the following command:
``` vim +'normal Go' +'r!date +"\# \%B \%d, \%Y (\%A)"' ~/did.md ```
Make sure to turn `syntax: on` in your `.vimrc`.
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.
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.
For an example, see https://raw.githubusercontent.com/allenu/YokosukaJS/master/T...
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.
[0] https://github.com/darekkay/config-files/tree/master/notepad...
It has a few subcommands, which are date-aware.
# 16/07/2018
- read about did.txt on HN
- [ ] write about log.txt on HN
- cost: 2.9€ coffee at 93
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.
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.
https://www.codeproject.com/articles/5371/todolist
Looking now at the revision history, it looks as if something may have happened to Dan after last summer.
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.
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.
I never tried this:
It's served me well. I have records from as far back as 2009.
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.
> 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.
having said that I do appreciate that plaintext is lower friction/inertia for sure
Short and sweet. Nice.