Lately I spend most of my time in a Linux terminal. One of Linux’s strong points is that you will always have a way of writing at hand no matter what. Just open up a terminal and type “vim” (or your own editor of choice) and you can type anything, save it and quit. The text you save can be a script, some code, a to-do list, a phone order for Chinese food–whatever you decide.

Late last year I decided to store a day-to-day account of what’s going on in my life and how I feel. It’s given me a lot of insight already and it’s a great way to remember when stuff happened. I originally started this in Google docs, however after a certain length Google docs can become extremely slow. Hell, Google docs is slow all the time. I realized that splitting the files up would be necessary. I wasn’t ready to do that with Google docs because it would make them impossible to search and sort through. I opened up a terminal and made a series of nested folders.

I started with a journal folder in my home directory. Then I added 4-digit year, then 2-digit month. Days were then simple text files stored under each month folder. It looks like this:

~/journal/2012/08/30
~/journal/2013/05/21
…

Note that nothing would really stop you from putting these text files all in a single folder or grouping them all by year, etc. It’s up to you to organize them how you like. I recommend that you keep the date format, though (YYYY-MM-DD) because alphabetical sorting of the files would then be the same as chronological sorting.

The flexibility of this system means that you can create a new entry just by opening up a text editor to the day:

vim ~/journal/2013/04/25

You just write what you need in there and save.

Some Tricks

You can do this for more than just a personal journal. You can use it to chronicle a project you’re working on, keeping a dieting journal, or using it as an hour tracking or work log.

Want to read all of your entries from a particular month?

cat ~/journal/2013/04/* | less

My advice is to use short, succinct sentences, and limit to one sentence per line. Use your words to describe a situation, your feelings, your progress, and your hopes. Don’t limit yourself and be honest because this is for you. Using this brief method will help you describe something quick and easily without turning something into a piece of prose. It will also make it more searchable using grep.

Keep writing quickly for as long as you want, and in the order that it comes to you. You may also group segments of thoughts by inserting an extra new line between paragraphs.

Example

I spent $56 on groceries today
It made me go over budget
Upsetting, but hopefully I have enough of a buffer to make it work

This project at work is carrying on way too long
The reason why is because the project manager missed a detail in the quote
I’m usually the one who gets blamed for it
Not today

While keeping track of details like this is good, a better example would involve a little more depth, introspection, and feeling. Something beyond what you would share on a blog. You will be amazed at how many things you lose track of on a daily basis.

Here’s an added bonus. I wrote a Python script that will compile all your journal entries from every year, month, and day into a single HTML file. It assumes you’re using the same folder and file structure that I do (~/journal/YYYY/MM/DD). Just drop it into your journal directory and run it to create a fully searchable, no-frills HTML file. Load it up in Lynx to search or scan through your entries by typing:

lynx index.html

Also note that it has FTP support in case this is being used to generate project logs. It’s commented out by default, but I use it to keep track of the VTL flight computer software that I’m working on. I even created a simple cron job that compiles and uploads my progress every night.

Here’s the script:

#!/usr/bin/python
 
import glob
 
# uncomment for FTP support -- requires ftplib
#from ftplib import FTP
 
output = open("index.html", "w")
 
html_escape_table = {
	"&": "&",
	'"': """,
	"'": "'",
	">": ">",
	"<": "&lt;",
}
 
# Credit: http://stackoverflow.com/questions/2077283/
def htmlEscape(text):
	return "".join(html_escape_table.get(c,c) for c in text)
 
def startBody():
	output.write("<!DOCTYPE HTML>\r\n<html><head><title>My Journal</title></head><body>")
	output.write("<h1>My Journal<h1>")
 
def endBody():
	output.write("</body></html>");
		
def startEntry(date):
	output.write("<h2>" + date + "</h2><!--startentry-->");
 
def endEntry():
	output.write("<!--endentry-->");
 
def insertParagraph(paragraph):
	p = paragraph.strip()
	if p != "" and p != "\n":
		p = htmlEscape(p)
		output.write("<ul><li>")
		output.write(p.replace("\n", "</li><li>"))
		output.write("</li></ul>")
		output.write("<br>")
 
#BEGIN
startBody();
 
#list all journal files and sort them in reverse chrono order (newest first)
#directory structure should be in ./YYYY/MM/DD format like so:
#./2013/04/31
files = glob.glob("./*/*/*")
files.sort(reverse=True)
 
# loop through journal files
for fileitem in files:
	# read the journal file
	f = open(fileitem)
	j = f.read()
	j = j.replace("\r", "")
 
	# split into paragraphs 
	j = j.split("\n\n")
 
	startEntry(fileitem)
	# loop through paragraphs
	for p in j:
		insertParagraph(p)
 
	endEntry()
 
endBody()
 
output.close()
 
# additional feature!
# uncomment the code here to upload this file to an FTP site:
 
#ftpuser="FTPUSER"
#ftppass="FTPPASS"
#ftphost="example.com"
 
#ftp = FTP(ftphost, ftpuser, ftppass)
#ftp.storlines("STOR index.html", open("index.html"))