one inch frame

Things I’ve tried, and am not happy with:

Life Balance

Ok, I love LB, but there are some annoyances that really bug me:

• Too hard (and by too hard, I mean way to hard) to input tasks quickly. All the meta-data is required to make LB work properly, but getting a task out of my inbox into LB is a multi-step process. What I want is that the metadata is still required, but I shouldn’t have to put it in up front for the task to start appearing in my todo.
• Proprietary, non-free app. I hate that. No hackability, and it costs $$$. My boss bought it for me, but that’s kinda beside the point. If I want to preach the gtd gospel (or my version of it, anyway), I shouldn’t require a $75 purchase in software — that money would be better spent on Moleskines.
• not scriptable. Yuck. You mean I can’t automate any of this? Not even with Quicksilver? outrageous.
• not suitable for both a brain dump and a NextActions list. That’s mostly because of the first point above, but really is the sum of all the above points. The result is that I need multiple tools to get things out of my inbox and into my trusted system. Hardly ideal.
• weekly reviews are hard and time-consuming (or, perhaps they’re supposed to be). They usually take up all of the 90 minutes per week that I’m devoting to them. That’s attributable mostly to all of the metadata that there is to check, and that it’s scattered throughout several clicks. I hate clicks. Takes time away from what I should be doing in a WR, which is, making sure I’ve got the absolute next action for every project.
• calendar UI really, really bites. I can’t type in a date, or a time, and I can’t pick them from a nice calendar. Man, when I start to think of all the stuff that the Newton got incredibly right… but that’s another show.
• the notes aren’t as front-and-center as they should be. As a result, I’ve got notes scattered throughout LB and MacJournal (which then make it to my wiki, for out-of-office reference. No good. Also, the UI for LB makes notes seem something of an add-on. In my thinking, the notes I make are the most important thing about the task, other than making sure I’m really doing (or planning to do) the very next action. But notes are vital, and should be dealt with as such. Also, since they’re not really used anywhere and can’t be easily exported, why do I write them in Markdown format? Well, one is that I’ve really grown to like the format, but the other reason is that I keep hoping, someday, that I’ll be able to look at both my tasks and my notes in a nice, rendered, html page.
• no plain text. As long as I’ve been at this Unix thing, vim is as much a part of my life as anything. I must use vim. I must use plain text. With the addition of Markdown, now writing in formatted text is just as easy. Why should I use someone else’s idea of a text editor? (and LB isn’t real good at editing text, anyway)
• bad searches. If LB isn’t real good at editing, it absolutely sucks at searching. There’s no search bar to search on the fly, and the search doesn’t go into my notes when it looks at stuff. That’s just wrong, and very close to a deal-breaker. If it used plain text files, I could use vim’s wonderful search tools, along with other tools like grep. But again, that’s another show.

That said, LB gets many more things right than it gets wrong. Any system I write will have LB as its major inspiration.

• Excellent support for contexts (“places”). LB filters out the stuff that I can’t do right now very well. This is key to my own gtd system, which seems to be as much about filtering out noise as it is about actually doing things. Don’t show me home tasks when I’m at work, don’t show me administrative tasks when I’m programming. Context. I love it, and LB does it quite well, maybe perfectly.
• Importance and urgency support. Something missing from canonical GTD stuff is the concept of importance. Just because it can be done now doesn’t mean it should be done now. There has to be a way of deciding which things are important in addition to how urgent they might be. I’ve a habit of not doing tasks, regardless of their urgency, if they’re unimportant (to me)
• Good support for hierarchal tasks. And nice that tasks can be forced to do in order, and tasks that are dependent on higher-up tasks aren’t in my todo list. Why show step #2 if I have to do step #1 first? There’s that filtering out noise thing again.
• Nice model for dealing with hard tasks. I like that hard tasks (tasks with due dates) slowly creep up on you, both by a colorization of the due date in the todo list, and its priority index also creeps up, with a configurable timeline for doing so. That’s really nice; upcoming hard tasks appear before they’re due, and stay at their highest importance (which isn’t to say they’re top on the list, remember this is importance and not urgency) until they’re checked off or moved; they are perfectly happy being overdue. A necessity for me, since I’ve found that, while hard tasks definitely exist, their “hardness” can usually be ignored with impunity.
• Palm syncing. It’s nice that I can do everything in my outline on my TungstenT3 as I can on my Mac. But with the limited Palm screen space, it can be bloody annoying to try to make real changes to my outline or enter notes. Still, points for having the capability.

Remind

I use remind, but it’s not well suited for gtd:

• Importance isn’t considered. Urgency is via a simple (0-9000) priority, but that’s not enough for me. I’ve got to have some sort of importance attached to tasks as well.
• No(t much) metadata. What, no place for notes at all? Outrageous. That’s a deal breaker, my friend.
• Learning curve. It’s hard to get into, Remind syntax is a very rich language (which is not a detriment at all), and it takes a while to get into it. And it’s very hard to do complicated things. Remember, easy things should be easy, and hard things should be possible. I’m far from convinced that remind adheres to that Perl mantra.
• No dependent tasks. Actually, I’m not sure that’s true, as there’s a lot of control over what makes a reminder hit on a day or time. But I don’t understand how it would work for dependent tasks, so it doesn’t exist.
• Poor Palm sync. Well, none, actually, but the resulting reminders text could be put into a memo.

But it does get some things very right:

• Text files. WooHoo! I can use vim, and Quicksilver, to remind me of stuff.
• One-line entries. That makes it kinda usable as a brain dump, as, for the most part, just a one-line description of the task will suffice.
• Good reminders. Well, the program is called remind, right? That’s what I’ve been using it for once I realized it couldn’t do all of gtd for me. Reminders about timesheets, days off, anniversaries, etc., It’s real good at that.
• Powerful. You can set reminders to trigger programs and scripts. That’s cool, but do I really need another cron? No, and neither do you. Still, there may be some good uses for that, if, for example, the thought of using at gives you the heebee-geebees.
• good output options. The thing will create a postscript file, for gawdsakes! And there’s a rem2html script running around, suitable for nice out-of-system viewing.

PyGTD

Written by one guy to combat some of the same problems that I have with Life Balance, It ain’t perfect for me:

• Poor context support. That may be my fault. While PyGTD allows you to pick and choose which lists to use to make up the todo list, I need context support at a task level; a per-list context isn’t enough for me. Perhaps the way I work is wrong; I’ve got tasks that I can do at home interspersed with tasks I cannot. Poor noise filtering.
• No per-list importance ranking. This is the reverse of the above. While tasks can be given an importance, it cannot distinguish between contexts that aren’t as important as its siblings. Deal breaker.
• Not (yet) hackable. It’s a simple Python script, but I don’t know enough Python to be able to customize it for my needs.
• Learning curve. PyGTD’s “status line” is where the metadata magic happens, but it’s cryptic, and I have to constantly refer back to the (sparse) documentation.
• Multi-line input. Not a necessity, but it does make it harder to use Quicksilver to get tasks in.
• Poor Palm sync. For the same reasons as remind, above.

However, the app is quite promising:

• Percent complete. WooHoo! something not even LB does. That’s pretty useful to me, but there are those who say that, under canonical GTD, a task is either done or it’s not. If a task can be partially done, then it should be multiple tasks. Ok, I hear that, but it’s not the way I do things.
• Text files. WooHoo! While the syntax of them is a bit tricky, I can use vim quite easily, and Quicksilver (though it’s considerably less easy) to mess with my lists.
• Metadata not required. Makes it easy to use as a brain dump. Just a hierarchal list of tasks is all that’s absolutely necessary, then I can figure out the metadata later. Combined with a global “braindump.txt” context, makes it pretty easy to get things out of my inboxes and into my trusted system.
• Archiving of old tasks. PyGTD makes a “done.txt” file containing tasks that are completed. Wonderful. They’re not totally gone, but they’re not cluttering up my context lists, either.
• Importance and urgency. The thing I like the most about LB is here in PyGTD. Tasks can be given an importance as well as an urgency. That makes the sorting of the todo list more accurate to the real work. Unfortunately, it appears that tasks are only important to the whole system. Real importance should be relative, like LB: tasks are ranked in importance to their parent task.

Rolling my own

So what would be necessary if I chose to roll my own gtd system? What best features from the above systems would mine have?

• Text files. A must. I have to use the same tool for getting things out of my inboxes and my head. One trusted system to rule them all. That means that input of new tasks needs to be quick and easy. I need to be able to use Quicksilver for those very quick edits, and vim otherwise.
• Importance and urgency. David Allen’s GTD doesn’t have importance, and I think that’s a pretty important (heh heh) piece of the puzzle, at least for me. Importance and urgency is a Steven Covey construct, and any system I devise will take importance into the equation.
• Hierarchal tasks and noise reduction. I don’t want to see step two if I’m stuck on step one.
• Context. I also don’t want to know that I need to fix the bathroom sink if i’m knee-deep in the middle of a coding session. I dont’ want to know that I need to patch one of the Linux boxes at work when I’m at home. And I need to be able to do context on a per task basis.
• Decent calendar support. What I keep coming back to is the wonderfulness of strtotime(), which allows dates like “tomorrow” and “next Monday” as valid. I think the calendar makes a bad UI for date input. It’s damn near perfect for output, but putting dates (and times, which is even harder) into a system via a calendar is pretty crappy. As an aside, that could be made easier if we stopped thinking that a calendar should show a month at a time. How stupid is it to get a drop-down calendar on the last day of the month, where ~30 days that are showing are irrelevant? Please, developers, if you must use a drop-down calendar for date input, default to this week plus three or four, instead of going all the way back to the first of the month. That’s for future date input, of course, which I would imagine makes up the vast majority of date inputs into a computer.
• Ease of weekly reviews. I should be able to look at the whole outline, all my context lists, at once, without regard to importance or urgency. That’d help in making sure my next actions are atomic and true, which would help the review process. Also, I should be able to get relative importance/urgency data out of the system easily, further easing the review. I’m thinking that the review should be a two-step process: A look at the next actions, making sure they’re both atomic (the smallest task that can be recorded and done effectively) and true (the absolute next thing to be done), then an review of their priority (which is a mix of urgency and importance).