My method of organizing email

0-Action, 1-Hold, 2-Archive, 3-Feedback, 4-Awesome, 5-Templates

0-Action, 1-Hold, 2-Archive, 3-Feedback, 4-Awesome, 5-Templates

Lately my posts have slowed down tremendously with moving halfway across the country, starting a new job (twice) and getting married.  Rather than continually put off larger posts because I don’t have enough material built up, I’m going to try to post shorter tips and tricks in between to keep up the momentum.

Today I wanted to share a quick email organization tip that I’ve refined over the years.  Ideally, I try to pull every piece of relevant information out of email as often as possible and stick it into Evernote or an org-mode notes file. Getting information out of email and into an information system of some sort gets you 90% of the way, but there will always be that bit of info you missed in the flood of new emails.  To deal with this I follow the process below to increase my ability to find the information I need.

  1. The first order of business is to get information out of email. Email is a great tool for communication but it was never intended to be an information repository. Search will almost always be cumbersome and even if you find the email you were looking for it can take a great deal of cognitive effort to reconstruct what the train of thought was or way that email was important.  Email generally doesn’t allow for meta-data so by capturing and “editorializing” the information in your own note-taking system you can add in the relevant context
  2. Practice Inbox Zero.  There are really only three “states” that email should live in.  By practicing the art of quickly classifying emails in these categories you can quickly “deal with” large volumes of email rather than letting it build up:
    1. “New” – email that you haven’t seen yet
    2. “Actions” – something you need to do
    3. “Archive” – something you need to hang on to
  3. Here is my modified version of “Inbox Zero” with the different folders I have found fit my work-style feel free to improve on this.
    1. 0-Action – Emails that are requests or reminders of things i need to do.  If there is a specific task/deadline I will generally remove this to my “official” todo list in a different application and archive the email.  Generally what is in here are reminders or items I need to do sometime.
    2. 1-Hold – Informational emails that i need close at hand but do not represent a “todo” item.  This should be a temporary holding place for “favorites”.  An example was a code that I needed for access to a system.  I knew I’d only need it for a short amount of time so I moved the email there and then moved it to 2-Archive after a week.
    3. 2-Archive – This is where you put everything that isn’t in another folder.  Storage is cheap.  Save Everything.  Rely on good search abilities in your mail client to retrieve anything that you haven’t deemed important enough to add to your notes.  If you spend more than three minutes searching for something add it to your note-taking system for the future.
    4. 3-Feedback – This is where I keep positive (and negative) feedback to refer back to periodically.
    5. 4-Awesome – Funny emails, pick-me-ups, etc.  It’s good to make time during the day to stop being so serious and enjoying work
    6. 5-Templates – If i write the same email or answer the same question more than once I create a blank email and use it as a template

What organization systems do you use to keep the flood of email/information manageable? Please let me know!


A Dashboard for your Life – a minimal goal tracker using org-mode, go and git

One of the most powerful motivators to keep on track with goals and to keep from getting discouraged is the humble progress bar.  This is a simple and intuitive indicator of progress used in many day to day situations.  Though lack of accuracy can be a downside, the advantage is that it can be intuited at a glace – making it easy to get an overview of a situation by a brief glance.

When I set out to design a dashboard for my personal life I had a few goals from the outset.  First of all I don’t want to reinvent the wheel, I already have a perfectly good todo-list/organizer with Emacs org-mode.  It suits me well to be able to edit a simple text file anywhere I have Emacs installed and sync up with git. The fact that it isn’t 100% ubiquitous on every platform, to me, is a feature.  I normally use scratch paper, emails, etc. as a buffer and then later in the day store and organize these in org-mode.  I find that many of my musings end up being not as critical to actually do as I originally felt.  I like that lag so I can have a bit of perspective when planning my tasks and projects.

The second objective was “no effort”, clearly I didn’t want to reinvent the wheel but also I didn’t want this to feel like a process or something extra I need to do.  If my org-mode notes are the “model”, I want this to just be the “view”.

Getting Started with Org-Mode

Org-Mode is an “add on” to Emacs that is specifically tuned to organizing your life.  I’m not going to go into advanced detail on this since there are already some great tutorials out there.  I’d encourage you to check out the following links first to get yourself familiar with the software

Once your warmed up to org-mode, it’s time to move on…

Tracking your goals

Now that you are comfortable with some of the possibilities of org-mode we are going to extend things a bit and create our own “system” within org-mode to track our goals.  The power of org-mode (and Emacs itself) is the key philosophy that “everything is text”. Building off of this simple idea we can use a few consistent rules of our own to build up a format that we can parse with an external tool further down the road.  This will allow us to “scrape” the notes we are keeping in Emacs/org-mode and create a html dashboard.  Even though I use Emacs constantly every day, I’ve found it very helpful to have a web accessible quick view of where i’m at with all of my goals – keeping an eye on the bigger picture.

Org-Mode formatting “rules”


“* Long Term” – This is one of the ‘categories’ i am using to track multiple goals/projects you can adjust the code and wording as needed

“* Epic Goals” – This is one of the ‘categories’ i am using to track multiple goals/projects you can adjust the code and wording as needed

“* Study Goals” – This is one of the ‘categories’ i am using to track multiple goals/projects you can adjust the code and wording as needed


Regular Todos

** + % = percent complete

** DONE = completed task (note that we are using “**”.  In org-mode this is a sub-heading, this allows us to group multiple “todos” in a single category)

– [X] = completed task

** TODO = unfinished task  (note that we are using “**”.  In org-mode this is a sub-heading, this allows us to group multiple “todos” in a single category)

– [ ] = unfinished task


Sample Organizer

To help put all of these rules in context, here is a sample of what your org file might look like

* Epic Goals [0/2]
** TODO build a 3d printer
** TODO Run in a marathon [12%]
- [X] 1 k
- [ ] 3 k
- [ ] 5 k
- [ ] 10 k
- [ ] 15 k
- [ ] 20 k
- [ ] 30 k
- [ ] 42 k
* Long Term Goals [1/2]
** DONE Wedding [100%]
  - State "DONE" from "IN PROGRESS" [2014-04-02 Wed 09:42]
- [X] date 26th
- [X] proposal
- [X] rings
- [X] decide where to do ceremony
- [X] invites
** TODO Hobbies - Reading - one book per month 2014 [58%]
- [X] Jan - Tampa
- [X] Feb - map head
- [X] Mar david and goliath
- [X] Apr - fail
- [X] May - fail
- [X] June - american gods
- [X] July - Stuff Matters: Exploring the Marvelous Materials That Shape.. Mark Miodownik
- [ ] Aug
- [ ] Sept
- [ ] Oct
- [ ] Nov
- [ ] Dec

Processing our goals file

Now that we have our file created and have some goals entered we need some way to “scrape” that file.  I’ve created a mini parser called “GoalTracker” that is written in Go. The code is free to use and very easy to get started with ( ).  Simply clone from github.  Next install the Go programming language ( ).  To compile the code just type “go build goals.go”, this will result in a binary for whatever OS you are using.  Once the binary is created you can issue the following command “goals -dataPath=/my/path/to/my/org-mode-files/ -templatePath=/path/to/the/template/file/included/with/the/code > /var/www/html/goals.html”.  Looking in the code you will see that by default it is looking for a file called “” in your dataPath and a file called “Template” in your templatePath.

The resulting html file looks something like this:


Automating Dashboard Updates

Finally, we can automate the update of our dashboard with a simple git-hook.  This allows you to run the dashboard update code in the background every time you commit your updated org-mode files.  The following code should be placed in your post-receive file

rm -rf /tmp/Organizer
cd /tmp
git clone /storage/GIT-REPO/Organizer.git
/home/zach/src/go/bin/go run /home/zach/Projects/Goals/goals.go -dataPath=/tmp/Organizer/Organizer/ -templatePath=/home/zach/Projects/Goals/Template > /var/www/html/goals.htm



What Is Your Epic Quest?


Anyone who’s spent more that a few minutes with me knows I’m obsessed productivity and metrics. So it’s no surprise that I try to apply the same approach I do to my life as I do to my code. Today I want to share one of my “hacks” for my personal life that came out of basic project planning.

The inspiration for this is heavily influenced by Steve Kamb’s Epic Quest of Awesome (by the way if you are a nerd and interested in fitness, please poke around his site for some awesome workouts.

What I’ve come up with is a very basic system using Emacs org-mode. I have also created a system to interpret the org-mode file and create a dashboard of sorts, that I can easily track my progress on various goals.

The key to this (for me at least) is that I use the same organization file for my “Epic” goals or my yearly goals as I do for my day to day tasks. This forces me to continually (and literally) keep an eye on the bigger picture. I do build in regular time during the week to take that “step back” but I find this helps me keep focused on that bigger picture.

Again, this is nothing grandiose just a little hack I’d like to share that might help to get you on your own Epic Quest. In a future post I will be going over the code and methods you can use to great your own progress dashboard on your Epic Quest of Awesome!

If you have any questions about my particular setup in org-mode or my status board, drop a comment. Thank you.


Go StatusBoard updated


A simple Go frontend to a json database. This is a simple “key store” that allows you to save statues of various services or objects. Updates are automatically timestamped. Contents of database and be dumped to a html file. “Success” and “Fail” status are considered “special” status and will be highlighted with green or red in the html output

New Feature

Added a new command “test” to take place of the cumbersome “if” statements I’ve been using in crontabs. This will allow you to specify a command and then update with a “success” or “failure” message depending on the return code.

Go Get It

Get the source:

See the original post: A Status Board for your Crontab



Giving Something Back

I’ve been a long time user of Free and Open Source Software (FOSS).  By many measures my IT career has been a brief blink of the eye (12 years this summer), but all along the way I’ve been a dedicated user of FOSS software.  I can’t count the number of times I’ve felt a rush of exhilaration when I’ve installed, setup and starting hacking away at real “industrial strength” server software right in front of my face.

It is a rare opportunity for someone to be able to cut their teeth on tools of the same level of sophistication as the “big boys” use.  No trials. No watering down. No bullshit.

In my IT career, thus far, nothing has compared to being able to say “I know this”.  Not because I’ve seen it in a book or watched a video but because I’ve been hands on, I’ve bent the software to my needs and have examined its inner-workings.

Lately, I’ve felt guilty.

The FOSS community is huge.  Think of the scale – office applications, web servers, text editors, programming languages, entire operating systems.  All of this made of millions of individual contributions.  Of all of the software I’ve consumed, I’ve never truly given back.

Today I wanted to announce and share my first tiny contribution to the FOSS world.  Over the past few months I’ve been working on a command-line interface to  It isn’t much and it’s far from perfect, but it scratches an itch I had and it is my first step at sharing with the community at large.

If you find this software helpful or useful please join in the fun and contribute to the project as you see fit – send me feedback, contribute code, fork the code and start your own project.  Even if you don’t find this software particularly useful I’d like to challenge you to share, in your own way, to the FOSS community. command line interface –