iGTD

Michael Buffington: iGTD + Quicksilver + subversion

Merlin — Thu, 28 Jun 2007 07:00:53 -0400

This is the second entry in a multipart series about my recent obsessive love affair with GTD, the iGTD application and Quicksilver.

In the last entry I put the emphasis on getting my tasks written down quickly and out of my focus into a system I could trust. I could choose to spend some time later to review my tasks and do what I like to call "iGTD gardening", where I check up on all my projects and do a bit of weeding of duplicate or irrelevant tasks, and fortify those tasks with whatever information comes to mind as I'm looking at them.

Since I'm now in the habit of pushing new tasks to iGTD and immediately forgetting about them I have the refreshing ability to work on a task without ever thinking about anything else. iGTD then becomes my set of instructions to follow when I need guidance, and if I've tended my task garden well, it's a rich set of instructions with a lot of tedious thinking already finished.

This system works out alarmingly well until you're possessed by SSD (severe stupidity disorder) and delete your iGTD database without even a whiff of lingering vapors. Immediately you'll be consumed by a profound and unshakable dread as you realize your tether has been severed from the mother ship and you begin to drift into outer space, your Tang to be divided up amongst your colleagues (even the ones you loathe).

Luckily for most of us, iGTD makes database backups upon starting up the iGTD app and for a couple of other events, and luckier still, most of us don't suffer from SSD very often.

But I often do, and don't leave anything to chance.

Rather than risk losing my entire brain to an episode of SSD I employ a SMP (scheme of massive paranoia). It might seem quite heavy handed, but I send a backup of my iGTD data to a subversion repository whenever the iGTD database changes. In a nutshell, it means I have a comprehensive history of every save ever done to my iGTD database, and am nearly assured that I'll be able to save myself from myself with only the smallest amount of data loss.

Now I'll be the first to admit that what we're about to look at is a bit Rube-Goldberg-esque, and I'll admit there's a certain joy in that as well.

A few things to know before we move on:

I'm doing this all on Tiger, which means I have both Ruby and sqlite3 installed out of the box.
Your paths to both Ruby and sqlite3 might differ from mine.
This code likely has bugs. I whipped it up in a few hours.

Also, worth noting - I'll be adding to this body of code as I move on with more blog posts about iGTD. What may look a bit like an empty shell now will get some more meat as we go along.

And finally (I promise), all the code I talk about in this series will be downloadable at some point.

Create some Ruby!

Create a file called iGTD.rb in /usr/local/lib/ruby (or /opt/local/lib/ruby if you're using the Macports version of Ruby like me).

Write the following code:

class IGtd

    def self.capture(string)

        i = IGtd.new

        i.push_to_igtd(string)

        puts string

    end

def push_to_igtd(string)    
    `/usr/local/bin/sendtoigtd "#{string}"`  
end


end

That'll start off our iGtd library with something basic. It seems totally superfluous when you think about it, but remember, we'll be adding to this at a later date.

The newest version of iGTD (v. 1.4.5) comes with a command line utility that allows you to pass your task along the same way you push tasks into iGTD through the Quicksilver plugin. The above code simply wraps some Ruby around that command, executing it when we call it, which we'll come back to in a moment.

Now we're going to take advantage of a Quicksilver feature that you might not see documented many places - you can pass text to Ruby scripts saved as action in ~/Library/Application Support/Quicksilver/Actions. Up until recently I assumed you could only have AppleScript actions, but that's not the case.

Let's see some of that Action in action. Create a file called gtd.rb in ~/Library/Application Support/Quicksilver/Actions that looks like this:



!/opt/local/bin/ruby

require 'iGTD'
IGtd.capture ARGV.join(" ")

This script takes whatever commands are passed in, joins them back up as a single string, and hands them to the IGtd.capture method we wrote above. Note that we join the string back up because Ruby splits up command line arguments into an array wherever it sees a space. So we simply reverse that process by adding the spaces back in.

Make sure you make the file executable. chmod ug+x gtd.rb should do the trick.

Once that's saved you should be able to invoke Quicksilver, press period to invoke text mode, hit tab, then type gtd. Your gtd Ruby script should show up in the list (if it doesn't you might need to restart Quicksilver [CTRL-CMD-Q]).

Now, despite the fact that you're using your own Ruby based action instead of using the iGTD Quicksilver plugin, your task will end up in iGTD.

Neat, but we're missing the paranoia. Let's add subversion commits into the mix.

At this point I have to assume that you've managed to get your iGTD.sql file located at ~/Library/Application Support/iGTD into a subversion repository, hopefully offsite. I'm gambling on the fact that you have some knowledge of subversion if you have any desire to do this at all.

Because the iGTD.sql file is binary, we want to dump it as raw text to be a bit more efficient with subversion. subversion only keeps track of differences between revisions with ASCII files, but keeps entire copies of binary files (which might not seem like much, but for a file that's in the 60-80k range, 6000 changes can turn into a 500MB subversion repository).

Having the iGTD.sql as an ASCII dump helps increase portability as well. You can rely on simple text editors to see your data with an ASCII dump, and in the worst scenarios, viewing raw SQL statements can be quite comforting if the alternative is viewing nothing at all.

Let's add the following method to our iGTD library (note that when you see a ↵ symbol that what should normally be on a single line is wrapping to fit the page - make sure you fix those lines if you're copying and pasting):

class IGtd
    def self.capture(string)
        i = IGtd.new
        i.push_to_igtd(string)
        i.commit_to_svn
        puts string
    end

def push_to_igtd(string)    
    `/usr/local/bin/sendtoigtd "#{string}"`
end

def commit_to_svn
# tidy up some of the paths
igtd_data_path = "/Users/mike/Library/Application Support/iGTD"
svn_path = "/opt/local/bin"
sqlite_path = "/usr/bin"

# dump the sqlite db to an ascii backup file
`#{sqlite_path}/sqlite3 "#{igtd_data_path}/iGTD.sql" &crarr;
    .dump &gt; "#{igtd_data_path}/iGTD.sql.automatic.bak"`

# commit it to svn
commit_msg = `#{svn_path}/svn ci "#{igtd_data_path}/  &crarr;
  iGTD.sql.automatic.bak" -m "Automatic backup of  &crarr;
  iGTD.sql backup file done: #{Time.now}";`

# if no changes were made, svn won't output anything - it'd &crarr;
be nice to know that we at least tried.

if commit_msg == ""
  commit_msg = "Nothing to commit, therefore no svn commit was done."      
end

# now send the message to growl
`echo "#{commit_msg}" | /usr/local/bin/growlnotify`    
return commit_msg


end
end

Now, whenever you push tasks from Quicksilver to iGTD through our gtd.rb action, subversion will commit the changes. I've added the luxury of being notified by Growl when the commit happens. Pay special attention to the paths in the script and make sure you're pointing to the proper places.

With this in place, not only are my backups effortless, but they're comprehensive. And because my subversion repository is on a remote server, I can reconstruct my task list as long as I have a computer and an internet connection. Given enough time to think about it, I'd probably get paranoid about my subversion server keeling over too. Entertaining those thoughts to their final conclusion would require I hire stone carvers and buy a large granite mountain to chisel my lists, so at this point I'm content with the offsite backup.

This extreme paranoia with an admittedly heavy handed solution helps increase my trust level with iGTD, but it also opens the door to doing other automatic tasks whenever I enter a task through my custom gtd.rb file.

In the next entry in this series I'll show you how you can enter a task in iGTD once and have it travel to both Stikkit and Basecamp with a few additions to the iGTD Ruby library discussed here, and even grab new tasks from Stikkit.

Following that entry will be something I consider quite special - getting tasks into iGTD from your mobile phone through SMS. Assume the bullfighter's stance and repeat after me: ¡muy emocionante!

About the Author

Michael Buffington - A serial entrepreneur and creative technological consultant, Buffington most recently served as the Community Advocate for Values of N, makers of Stikkit and iwantsandy.com. He's now secretly building games for the masses.

”Michael Buffington: iGTD + Quicksilver + subversion” was written by Merlin Mann for 43Folders.com and was originally posted on June 28, 2007. Except as noted, it's ©2010 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

43f Feature: Michael Buffington's "How I use iGTD"

Merlin — Tue, 19 Jun 2007 11:55:59 -0400

Michael Buffington is a pal of mine who's a talented developer and all-around swell fellow. I got to work with him a bit on the Stikkit project and, in some of our offline talks on productivity stuff, I was intrigued to learn about some of his ninja geek skillz.

I asked Michael to write up a series on some of his favorite tricks to get his stuff done, and he kindly obliged. Here's part one.

--Merlin

How I use iGTD

by Michael Buffington

This is the first part in a multipart series about using iGTD with Quicksilver and how it's changed my life, allowed me to grow hair where I never thought it possible, and more importantly, spend more quality time with my children (who are, as you might know, super humans with indescribable special abilities).

I'm a recent and somewhat enthusiastic convert to GTD. I have had the good fortune of starting to manage my digital life with GTD the same day Merlin first mentioned a great application for OS X called iGTD.

I have to admit though that I'm not a very hard core GTD follower yet. The most important parts of GTD for me are getting my tasks out of my head the moment they pop into existence, and putting them into some sort of system I can trust. iGTD allows me to do exactly that in a very intuitive way, but if I'm having a good day I only ever bring iGTD into focus when I'm not sure what's next on my list.

“I've emphasized this before already, but for me the most important part of GTD is writing tasks that you can follow as if you're a robot...”

For task capturing, I use Quicksilver, and I have to say it's a slice of heaven. Without a doubt my life has improved quite measurably both because of GTD, and the iGTD plugin for Quicksilver.

So at the most basic level, here's how I use iGTD to reinforce what I think is the most important behavior for leading a GTD lifestyle:

I invoke Quicksilver. I hit the period (".") key to switch to text entry mode. Some people have different settings, so the the important part here is invoking text entry.

I begin typing out my task with some simple markup that iGTD understands. For this blog entry, I once wrote:

@blog write a blog entry about how I use iGTD to capture tasks [43f]

I then hit tab and type iGTD so I can send the text I entered to iGTD. I hit enter, and I know that my task has been captured. I even set iGTD so that it doesn't pop up once I've captured a task, I simply trust that it's there.

Here's a quick screencast of the process in action - it's worth noting that the screencast is all of a few seconds long, and the actual task capturing part is incredibly quick.

Click To Play

I've emphasized this before already, but for me the most important part of GTD is writing tasks that you can follow as if you're a robot (avoiding writing ambiguous sounding tasks in favor of writing very "actionable" tasks) and getting those tasks capture the moment you think of them.

So I'll be writing code, thinking about how to do something like simulate multiple inheritance in Ruby when unannounced the thought "I should call the local game place to see if my reality might someday be shared with a Nintendo Wii of my very own" takes center stage. If I weren't adhering to GTD practices, I'd ignore that thought and move on, but it'd nag me. It'd keep nagging me, and my focus would suffer.

With Quicksilver and iGTD I get the task out of head and into a place I trust, and because it took mere seconds to record I'm right back in flow, realizing that if I'm wanting to do multiple inheritance in Ruby I've probably designed something incorrectly in the first place.

I become more efficient at what I do, and have less "free radical" thoughts fighting for attention in my head, which makes me a far more patient, confident and relaxed person. That in turn makes play time with the kids sublime.

In the next entry in this series, I'll write about a particularly horrifying experience I had with iGTD, and what I did to solve the problem.

About the Author

”43f Feature: Michael Buffington's "How I use iGTD"” was written by Merlin Mann for 43Folders.com and was originally posted on June 19, 2007. Except as noted, it's ©2010 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"

iGTD: Strong OS X app with powerful Quicksilver integration

Merlin — Sun, 08 Apr 2007 10:40:22 -0400

iGTD & Quicksilver

As I mentioned on MacBreak Weekly the other day, I'm very impressed with what I've seen so far in iGTD, a new "Getting Things Done" application for OS X.

It feels like a solid, powerful, and practical tool for managing action, and I'm pleased to say it's steered clear of a lot of the GTD-ish visual theatricality that, in my opinion, has made some of the apps out there more pretty and fun to use than they are useful in the context of a mature, streamlined system.

I mention iGTD here because, in playing with it yesterday, I turned up this excellent page about iGTD's Quicksilver integration.

Pretty mind-blowing (albeit geeky) stuff, since the detailed syntax allows you to enter tasks via QS from anyplace, while still identifying project name, context, priority, date due -- and even allowing you to add a note.

(BTW, that image will make more sense after you read the whole page)

I encourage you to have a look at iGTD if you get a chance and take it for a spin. It's evolving very quickly, with new updates available seemingly every time I open the app.

Like any GTD tool, it won't be perfect for everyone, but in my own testing over a couple days, I've found it to be one of the clear leaders in what's quickly becoming a very crowded field.

”iGTD: Strong OS X app with powerful Quicksilver integration” was written by Merlin Mann for 43Folders.com and was originally posted on April 08, 2007. Except as noted, it's ©2010 Merlin Mann and licensed for reuse under CC BY-NC-ND 3.0. "Why a footer?"