Mar 29
A couple of weeks ago, I discussed My Super-Duper Personalized Productivity Desktop Background, made possibly by Samurize (see my intro to Sam here).
Today, let me introduce you to my stack. For those of you in the computer science field, yes, I mean that kind of stack. For those of you in the business world, I mean my LIFO system. For those of you who still don’t know what I’m talking about, it’s Last In First Out.
Why a Stack?
There are many ways of looking at lists. Some people make a To Do list, and work their way through it, top to bottom. (That would be a queue, or FIFO ;)). Some people write things on sticky notes, one per note, and do whatever grabs them first. Some people (say, the Getting Things Done crowd) write things on lists, but segregate, organize, manipulate, etc. those lists, e.g., divide your next actions by physical context. Even when looking at a context list, you can still sort through the items, deciding what NA you have the time and energy for.
I want to tell you about a simple tool that I’ve found indispensable lately. I’m not talking about next actions, but something at an even more lower-level, if such a thing is possible. Let’s say that I’m writing a report. I’m going to be working on it solidly for a few hours, and if little things come up, I’m not going to actually create a next action. Instead, I’m just going to scribble it down and fix it later. The little things that I’m talking about are things like “Fix format of heading x”, “Double check spelling of Author x’s last name”, “center picture on page 5″, etc. etc. These are things that I can just collect on a scrap of paper. Things that I don’t want to forget, and I’m going to do in this session, but I don’t want to do *right now* because I’m actually in the middle of my writing flow. We all know what that flow feels like, eh? You don’t want to mess with it by changing mental gears and fixing something.
When writing a report, a stack is not necessary - kind of silly actually. Just collect these notes in a list, or on stickies or whatever, and get them done, in whatever order at the end.
So, Again, Why a Stack?
Now, let’s switch gears. Instead of writing a report, where it’s very important for me to get all the stuff out of my head onto paper, with as few interruptions as possible, I’m now actually going to do some programming. Other processes can fit into this mindset - modelling software, designing anything, physically building, car mechanics, whatever.
The key to the kind of workflow that I’m talking about here is that while you’re working away, something comes up that directly impinges on your work, and *has* to be done before you can do anything else. I find this most often in programming. For example, let’s say I’m coding the implementation of one particular part of the program. It calls on something from somewhere else. Sometimes I can guess exactly what the call will look like, sometimes I want to head to that other place and make that code work first. Sometimes it’s more drastic, especially when debugging. I code something, it doesn’t work. I try to find the error. Trying to fix that error leads me to another part of the code, where I need to fix something else, which leads me somewhere else, etc. etc. It’s a little like walking through a maze. Actually, it’s exactly like that, except I want to be able to come back to exactly where I am to finish things off.
Because I can only keep so many things in my head, I found that I needed a way of keeping track of what I was working on, and every detour I was making, just so that I could find my way back to the starting point again. Enter the stack.
The Stack
All the stack is, is a list where new things get written at the top. I’ve got it set up as a text file. When it looks like I’m going to get diverted from what I’m currently working on, I write a line saying where I am and what my goal is. Then I write a line (above that one) that tells me what I need to fix. When I get there, and find somewhere new to go, I add another line (at the top). When I get to the end of the line, I can work my way back to my starting point by looking at the top of the list, making sure that item is well and truly done, and deleting it. Look at the next item, etc.
Pretty Stack
Of course, I can’t just use a simple text file. I have to automate it. And display it. And massage it. So here’s what I have in my little stack system:
- stack.txt - just a plain text file. I’ve put a line in it “=====Bottom=====” so that I’ll know when I hit the bottom and have nothing left to backtrack to.
- push.pl - a little Perl script to insert some text at the beginning of the file. There’s got to be an easier way to do this, but my script does the following:
- get today’s date and time
- open my stack.txt and read everything into an array
- open my stack.txt again, this time for writing
- write the date/time, plus whatever text I’ve passed in - this becomes the first line, i.e., the one that I’m going to deal with next
- write everything else back to the file
a SlickRun command for push. So all I have to do is trigger my SlickRun and enter something like “push Testing - this is where I am”.
pop.pl - another little Perl script to grab the first line from the file. It does this by:
- open the stack.txt file and read everything into an array
- grab the first line
- delete the first line
- open the stack.txt file again, for writing
- write the rest of the lines to the stack
a SlickRun command for pop. This is a more challenging command; it uses the @MULTI@ command to do two things for me:
- first, it runs the pop SlickRun command for me, which calls the pop.pl script, which removes the first line
- then, it runs the peek SlickRun command (described below)
peek.ahk - an AutoHotkey script, and this is my favourite. All this little gem does is remind me what I’m supposed to do next. I find this useful because when I’m working, I don’t see my desktop. Sometimes I just want a reminder of what’s on the top of the stack. This script reads the first line from the stack.txt and file and gives it back to me in a popup box - so I can get an in-my-face reminder of what I need to be working on right now, without having to break my train of thought and open the file.
a SlickRun command for peek. It just calls on the peek.ahk script.
Screenshots
Here are a couple of images of what this all looks like. First, here’s me putting something onto the stack:
And here’s what the stack could look like after I’ve started down the long winding path:
Note: there’s not really any reason it has to be displayed on my desktop; but I like to keep it there as a reminder, for when I stop programming for the day. Then, I can look at the whole stack and get a picture of where I am.
And here’s what a peek operation looks like:
When I pop something from the stack, the first line is deleted, and then a pop is done; that’s to tell me what I have to work on next, since I’m finished the current thing I’m on.
Because I leave one line in the stack to signify the bottom, when I’ve run out things to pop of the stack, the last message box shows me:
Now I know that I’m back to where I started and I can continue with my primary task.
Conclusion
In writing this up, I feel that it sounds much more complicated than it really is. The take-away point is that sometimes when you’re working, you’re in a flow that lets you make note of new things to do, and then ignore them until later. But sometimes, you have to fix something else before you can finish what you’re working on. In the latter case, the concept of a stack or FIFO list can help you track where you’re going, and more importantly, how to get back to where you were when you first got diverted.
It’s this concept that’s important, not the tools you use to handle it. This is one of the reasons I’m telling you about my system, but not uploading the files (although interested parties can receive them if they wish). You can accomplish the exact same effect with a piece of paper - it’s just the order in which you write things down and cross things off that’s important.
