How do you GTD? (Credit: Carvalho)

TL;DR
I’ve implemented most of the GTD organizational system using just Gmail. You can too!

Introduction
For many years, I’ve been a devotee, if not quite an adherent, to the productivity school known as “Getting Things Done“, much more commonly referred to as GTD. GTD is based on a book of the same name, by David Allen, and boils down productivity into maintaining focus by having trusted systems to deal with maintaining your commitments, and handling potential disruptions.

The book itself lays out some specifics of how these systems could be implemented, but it is stressed that the results are what matter, not the implementation.

In general terms, you need the following to do GTD (messages can refer to any type of communication that you receive):

• 1 or more “inboxes“. These can be literal email inboxes, or any centralized way to collect messages.
• A “tickler” system that allows you to “mail” yourself things in the future (i.e. I don’t have to pay this bill until 2 weeks from now, so I don’t want to see it until then). This is where the expression “43 folders” came from.
• A “next action” collection. These are actual actions you can do, phrased as decisively as possible, “wash the floor” vs. “clean the house”.
• A “projects” collection. In GTD, projects are defined as outcomes that require more than one action to complete.
• A “someday/maybe” collection. These are messages or topics that are of interest, but you aren’t at the point where you want to take any action on them.
• A “waiting for” collection. These are topics that have been delegated to someone else to deal with, and until they do, require no action from you.

Implementation challenges
Since I first read GTD about 5 years ago, I’ve struggled to put together a single system that would actually allow me to do it reliably.

Some of the problems I’ve encountered:

• Too many inboxes, so I don’t check them all reliably
• Inboxes and other collections in different media (email vs. paper list, etc.), so transitioning between them is non-trivial
• Separate systems for personal vs. work commitments
• Getting a usable “waiting for” collection
• Interacting with systems at my desk and on the go

Progress
Over the past two years, one of simplest ways I have found to maintain “next actions” is as email drafts. A good percentage of the actions I take involve sending an email, so there’s a natural process for those, and my inbox is very frequently referenced, so as long as I can keep focus on those drafts, I can be pretty confident I’m working on the right thing.

When Google introduced their priority inbox feature, I was excited, because of the potential for making multiple collections of email available up-front. Unfortunately, at the time, it didn’t allow you to choose “drafts” as one of them (more on this later), it only allowed 3 collections with limited customization, and most importantly, my work email was still stuck in Outlook.

A solution
When I started at Arc90, I was pleased to discover they used Gmail for corporate email, and even more pleased to discover that priority inbox had received several enhancements. So I started experimenting, and I’m now pretty pleased with what I’ve been able to accomplish.

Here’s how I have things set up:

• Labels for Done, Waiting For, and Someday
• Contact entries for my email, +done, +someday, named just “DONE” and “SOMEDAY” (WTF am I talking about?)
• Filters for messages sent to these addresses, to label them appropriately and archive them
• Priority Inbox:
• Four inbox sections:
• Unread
• All “Waiting For” (usually kept collapsed)
• All Drafts
• Everything else

Whenever I take on a new commitment, I draft an email, with the subject as the project, and lines in the body describing actions. If the action was to send an email, this draft will become that email. If the action is something else, then when it has been completed, I’ll send it to DONE.

When I receive an email that requires a commitment from me, I’ll draft a response with the commitment (and try to make sure I hit “save” instead of “send”).

When I send a message that requires a response, I will open that message and apply the label “Waiting For”. When that response comes in, the message shows up in “Unread”, and I can process it as appropriate. (This is why Unread has to be above Waiting For).

When I am waiting for something else, I will create a draft, write what I am waiting for, save it, and then label it “Waiting For”. When I have an idea for a project, or otherwise become aware of something that interests me, but is not part of my current work, I will draft and (usually) send an email to SOMEDAY.
When I need to be reminded of something in the future, I create a calendar event for that.

Things that could be improved

• Fewer clicks to create drafts. Right now, it’s “compose”, type, “save”, “back”. If there was a way I could start typing, and just hit “save as draft”, that would be nice.
• Applying labels to drafts. Right now you need to save a draft or send the message, and then re-open it, before you can apply a label.
• A couple of times, I have sit “send” instead of “save”. I think I could use “Undo Send” in labs to deal with this.
• I don’t have a projects collection right now. I will often use a single draft to track a project, and just make sure the first line is the next action.
• Some kind of “send later” functionality would be an easier way to remind myself of things at a specific date.

Conclusion
If this is your first exposure to GTD, hopefully this has provoked some interest, and provided something of an example for how a GTD system can be implemented. It takes some getting used to, and there’s a bit more to it then I have described here, but nothing that should cause conflict with this system. If there’s interest, I might write a couple more posts covering in-depth set up, and some other GTD aspects.

Thanks for reading!

Alec Munro is a QA Engineer at Arc90, where he uses GTD to manage his days of tests plans, infrastructure development, and meetings. He’s been using GTD for the past 5 or so years, and just recently began to use Gmail as his primary GTD tool. Alec lives in Halifax, Nova Scotia.

I had a text file that I wanted to explicitly track versions of — I use Time Machine for incremental backup, which is great, but doesn’t always give me precise enough control of the snapshots, and I don’t always have the snapshots available. Once I read Aristotle’s essay, it only took me a few minutes to download and install Mercurial, and then I started tracking my file with three simple commands: hg init; hg add *; hg commit -m "initial". Quick, easy, and effective. From that point on, my folder was also a repository, and I could track specific revisions of my files by simply typing hg commit -m "update" at any point.

What I think is the killer realization here is that it is now super easy to make any folder into a repository, and instantly start tracking versions of its contents. I’ve used Subversion to make local repositories, and track local files in the past — and it really is many more steps, and much more work. It’s also messier, because the repository and the working copy must be separate entities — you have to think about where the repository should live, as opposed to the actual stuff, the working copy. With a DVSC, no such dichotomy exists. The repository and the actual stuff are one and the same. You can move them, zip them, email them — as long as the metadata directory is preserved (for example, .hg or .git), the folder remains a repository.

I’m thankful to Aristotle for helping me get past the initial barrier to entry, and start actually using a DVCS. I’m looking forward to learning more about them, and using them even more going forward.

(Bonus tip: on OS X, some applications save their data using a special type of file called a “package”, which is actually a directory with a special flag. One example is OmniGraffle, which I use frequently. Because these “files” are actually directories, they can be easily made into self-versioning files with their own self-contained repositories. Just navigate to the directory and run the commands above! From that point on, the file will be a repository and can track its own versions. Pretty useful!)

(I can’t explain exactly why I decided to try Mercurial first, before Git or Bazaar. I’ve read many comparisons of them, and something about those comparisons just made me want to try it. I’m not sure exactly how, but I had built up the impression that Mercurial was somehow simpler, cleaner, more elegant, and more approachable than Git or Bazaar. I don’t know if that’s actually true, but the impression was enough that that’s where I started.)

(Aristotle’s mention of “mental overhead” as a decisive factor in using one system over another is something I’ve been thinking about lately as well, although I’ve used the more unwieldy “cognitive overhead.”)

This turns out to be particularly useful if you have large sets of data in which the names can be dynamically mapped to the param names. It’s suddenly a concise and simple matter to dynamically make large sproc calls.This procedure is simply called by passing in the name of the sproc that you want to examine. The sproc code is commented with an explanation of each return field.

This is compatible with Sql Server 2005 and 2008.

Example call:

EXEC    spStoredProcParamLookup @ipSprocName = 'spTestSproc'

 /************************************************************************************
 Software License Agreement (BSD License)
 Copyright (c) 2008, Arc90 Inc.
 All rights reserved.
 Redistribution and use of this software in source and binary forms, with or
 without modification, are permitted provided that the following conditions
 are met:
 - Redistributions of source code must retain the above copyright notice,
 this list of conditions and the following disclaimer.
 - Redistributions in binary form must reproduce the above copyright notice,
 this list of conditions and the following disclaimer in the documentation
 and/or other materials provided with the distribution.
 - Neither the name of Arc90 Inc. nor the names of its contributors may be
 used to endorse or promote products derived from this software without
 specific prior written permission of Arc90 Inc.
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 ***********************************************************************************/
 set ANSI_NULLS ON
 set QUOTED_IDENTIFIER ON
 GO
 CREATE PROCEDURE spStoredProcParamLookup
 -- The name of the sproc for which the params are being found
 @ipSprocName    VARCHAR(100)
 AS
 -- ======================================================
 -- Make sure there is a valid value for the sproc name
 -- ======================================================
 -- Check for blank or null
 IF @ipSprocName IS NULL OR @ipSprocName = ''
 BEGIN
 RAISERROR ('There must be a valid (non-empty and non-null) value for the param @ipSprocName',10,1)
 END
 -- Trim off extra spaces when user is typing information
 SELECT    @ipSprocName = LTRIM(RTRIM(@ipSprocName))
 -- ======================================================
 -- Get the data
 -- ======================================================
 SELECT		-- Name of the parameter. Is unique within the object. (includes preceding @)
 -- Datatype: sysname
 sp.name AS ParamName,
 -- ID of the parameter. Is unique within the object.
 -- Datatype: int
 sp.parameter_id AS ParamID,
 -- Maximum length of the parameter, in bytes.
 -- Value = -1 when the column data type is varchar(max), nvarchar(max), varbinary(max), or xml.
 -- Datatype: smallint
 sp.max_length AS MaxLength,
 -- A restatement of the original sproc name (same as value of @ipSprocName)
 -- This is just a convenience
 -- Datatype: sysname
 so.name AS ProcName,
 -- A string denoting the name of the datatype of the param (ie. Varchar)
 -- Datatype: sysname
 st.name AS DataTypeName,
 -- An int denoting the datatype of the param.  Sql Server assigns each datatype a unique int id.
 -- The full list of these types can be found in the table systypes.
 -- Datatype: tinyint
 st.type AS DataTypeID,
 -- Precision of the parameter if numeric-based; otherwise, 0.
 -- Datatype: tinyint
 sp.precision AS ParamPrecision,
 -- This denotes whether or not this is an output param
 -- 1 = an output param / 0 = input param
 -- Datatype: bit
 sp.is_output AS IsOutput,
 -- This denotes where or not there is a default value set for this param.
 -- 1 = Parameter has default value / 0 = does not
 -- This implicitly tells whether or not the param is required. A param with a
 -- default value specified is not required.
 -- Datatype: bit
 sp.has_default_value AS HasDefaultValue
 FROM		sys.objects so
 INNER JOIN	sys.parameters sp ON (so.object_id = sp.object_id)
 INNER JOIN	sys.syscolumns sc ON so.object_id = sc.id
 INNER JOIN	sys.systypes st ON st.xusertype = sc.xusertype
 WHERE		sc.colid = sp.parameter_id
 AND			so.name = @ipSprocName
 ORDER BY	sp.parameter_id
 GO
 

Since HttpException exposes a GetHttpCode() method and WebException does not, the HTTP status code from the underlying service was being discarded by this library, which made it impossible for me to automate error handling by status code. The right way to solve this problem is to fix the library to throw HttpExceptions to preserve status codes. But the right now way was to use regular expressions to see when these exception messages contained a three-digit number starting with 4 or 5 (e.g. 401, 404, 500) and wrap it in my own HttpException so that the caller further up the chain can process it automatically.

Note that an exception message like 404 is not a valid credit card number would get erroneously treated as a 404 File Not Found exception. However, in this case where I know the library and the service involved I think it’s safe to do. But I’m still going to fix the offending code ASAP!

    // C#
try
{
// call the library that might throw the exception
// that ought to be an HttpException
}
catch(System.Web.HttpException) // it's already an HttpException, so throw it as-is
{
throw;
}
catch(Exception ex) // any other exception
{
// If the exception message contains a 3-digit number starting
// with 4 or 5, assume it's the correct HTTP status code.
// NOTE! Know your library to know if that's a safe assumption!
Regex httpErrorRegex = new Regex("((4|5)\\d{2})(?!\\d)");
if(httpErrorRegex.IsMatch(ex.Message))
{
int httpStatusCode = int.Parse(httpErrorRegex.Match(ex.Message)
.Captures[0].Value);
throw new HttpException(httpStatusCode, ex.Message, ex);
}
// No 3-digit HTTP error code found in the message, so default to a 500 error
throw new HttpException(500, ex.Message, ex);
}

If you save the bookmarklet to your browser’s toolbar you simply click once, enter the ticket number, and you’re in your ticket.

For my half of our application ecosystem I researched .NET’s Base64 encoding/decoding support, got curious about character set encoding, and set out to write a universal encoder to make it simple, easy, and guaranteed safe to insert any kind of binary or text data into an XML document.

But first, a quick nano-refresher: Character encoding specifies how a string of bytes should be mapped to specific text characters. In the simplest case, ASCII, one byte maps to one of 256 possible characters. 65=A, 66=B, …. 90=Z, etc. In Unicode, two (or even four) bytes map to thousands or even (theoretically) billions of characters. So when my program reads four bytes from a text file, I need to know if it represents four 1-byte characters, two 2-byte characters, or one 4-byte character. It’s actually even more complicated than that, but the basic problem is making sure I don’t accidentally turn a 400-byte ASCII text file into 200 Japanese characters. Or vice versa. Or garbage.

Fortunately, .NET has robust support for character encoding, so all I have to do is load the correct encoding class and ask it to take care of this for me. If I know I will only ever need to deal with Unicode, that class is Encoding.Unicode, but for maximum flexibility I can call Encoding.GetEncoding(encodingName) and get any encoding by name. Like so:

public string GetStringFromFile(string myFilename, string encodingName)
{
byte[] fileBytes = System.IO.File.ReadAllBytes(myFilename);
System.Text.Encoding myEncoding = System.Text.Encoding.GetEncoding(encodingName);
return myEncoding.GetString(fileBytes);
}

After I’m done modifying that string I can easily convert it back into a byte array and save it, preserving the original character encoding:

public void SaveStringToFile(string myFilename, string encodingName, string myString)
{
System.Text.Encoding myEncoding = System.Text.Encoding.GetEncoding(encodingName);
byte[] fileBytes = myEncoding.GetBytes(myString);
System.IO.File.WriteAllBytes(myFilename, fileBytes);
}

But now let’s get back to my actual business problem, storing a PDF or other binary data in my XML document. Because the bytes I encounter are not supposed to represent character data, attempting to map them to characters may result in nonsense. For example, whether I decode the byte sequence 00 00 00 00 as ASCII, Unicode, or UTF-32, I get either one, two, or four null characters that will screw up string processing. Note that use of CDATA sections doesn’t help. Only being very lucky about which byte sequences I encounter would avert disaster, and I don’t like writing lucky code.

Enter Base64, which is designed for exactly this purpose: encoding arbitrary binary data into a string guaranteed to consist of only “safe” ASCII characters and decoding that string back to bytes with 100% fidelity later. Microsoft places Base64 functionality under the System.Convert class, not System.Text.Encoding because it’s more of a conversion and translation process, not a direct byte-to-character encoding like those described above.

To read a file into a Base64 string:

public string GetBase64StringFromFile(string myFilename)
{
byte[] fileBytes = System.IO.File.ReadAllBytes(myFilename);
return Convert.ToBase64String(fileBytes, Base64FormattingOptions.InsertLineBreaks);
}

And to decode it and save it back to the filesystem:

public void SaveBase64StringToFile(string myFilename, string myString)
{
byte[] fileBytes = Convert.FromBase64String(myString);
System.IO.File.WriteAllBytes(myFilename, fileBytes);
}

I combined both “real” character encodings and Base64 encoding in my XmlFileEncoder class (attached) to provide unified access to both encodings when working with XML documents. If you know you’re dealing with Unicode, simply call XmlFileEncoder.InsertFileIntoXmlDocument with the encoding UTF-16 and the file will safely be inserted as text. If you don’t always know the file format, or you are dealing with binary files, simply call the same method with the encoding Base64. In either case, a new node will be added to contain your file data and the encoding attribute will record the encoding method so XmlFileEncoder.ExtractFileFromXmlDocument will use the correct character/Base64 decoding automatically.

The demo WinForms app starts up displaying an XML document with some UTF-16 data already encoded into it. Use the controls along the bottom to experiment with inserting differently encoded files (provided, or use your own) using different application character encodings. Some files will clearly look wrong in the XML when you select the wrong encoding. Others may look correct, or almost correct, but when you press the SaveEncodedFile to File button it will report Copy accuracy FAILED when it verifies against the source file. However, the files encoded and decoded using Base64 will always copy accurately. The only downside is that Base64 encoded data is always 1/3 bigger and much less human readable than the source.

You can find the source code here: XmlEncodingDemo.zip

Have a happy, healthy, and correctly encoded 2009!

[Event(name='complete', type='flash.events.Event')]

Since I wasn’t seeing the event in the code hints list I looked at some inner Flex framework components like Button or TextInput to see what I was doing wrong. Everything matched but then I realized the only difference was that they used double quotes. Aha! Once I switched the above metadata example to the following, everything worked out:

[Event(name="complete", type="flash.events.Event")]

The complete event showed up in the code hints list when trying to add an event listener for my custom component. This isn’t a complaint on Flex Builder, as I normally use double quotes–so I blame this on laziness and copying and pasting the metadata line but to others be careful and note to see the event (or any other metadata type e.g. styles) show up in the code hints list always use double quotes!

package com.arc90.example;
import java.util.logging.Logger;
public class LoggingExample1
{
public static void main(String[] args)
{
Logger logger = Logger.getLogger(LoggingExample1.class.getName());
String user = "dougb";
int logins = 17;
int purchases = 2;
logger.info("User " + user + " has logged in " + logins +
" times and made " + purchases + " purchases.");
}
}

Fortunately, the Java Logging API gives you the ability to parameterize your statements (similar to JDBC prepared statements) so that you can turn the above into something like this:

package com.arc90.example;
import java.util.logging.Level;
import java.util.logging.Logger;
public class LoggingExample2
{
public static void main(String[] args)
{
Logger logger = Logger.getLogger(LoggingExample2.class.getName());
String user = "dougb";
int logins = 17;
int purchases = 2;
// Single parameter
logger.log(Level.INFO, "User {0} successfully logged in.", user);
// Multiple parameters
logger.log(Level.INFO, "User {0} has logged in {1} times and made {2} purchases.",
new Object[] {user, logins, purchases});
}
}

You’ll need to use the logger.log(…) method rather than the more convenient logger.fine(…), logger.info(…) (etc.) methods, but in the end it makes for much cleaner code.

Unable to Connect to ssl://( your host name):443.
Error #175113224: Unable to find the socket transport "ssl" -
did you forget to enable it when you configured PHP?

The problem lies in your version of OpenSSL and certain configuration parameters.

HTTPS relies on SSL to transport your data securely and PHP usually uses the OpenSSL implementation of SSL. Problems occur when your versions of OpenSSL are out of sync with each other.

The best option is to always keep ALL of your software 100% up-to-date at all times–but sometimes you are not able to do a full software update for one reason or another.

This is how to ensure OpenSSL works for you:

There are 4 required files for openSSL: libeay32.dll, ssleay32.dll, php_openssl.dll, and openssl.cnf.

libeay32.dll and ssleay32.dll are usually already installed in multiple places, but are usually in different versions. The safest thing to do is rename all the current files and copy in a known version. Make sure you have the most current version by installing the most current version from this site: Shining Light Productions

It is probably best to do a search for these files to see all the locations, but they usually live in the following places on a 64-Bit server:

C:\Program Files (x86)\PHP
C:\Program Files (x86)\Apache Group\Apache2\bin
C:\Windows\SysWOW64

Go to all of these places and rename the files libeay32-old.dll and ssleay32-old.dll, respectively, then copy libeay32.dll and ssleay32.dll to those locations.

If it doesn’t already exist, copy php_openssl.dll to:

C:\Program Files (x86)\PHP\ext 

If you do not have php_openssl.dll, one place to find it is here.

If it doesn’t already exist, copy openssl.cnf to:

C:\Program Files (x86)\PHP\extra\openssl

Create directories if they do not already exist. If you do not have openssl.cnf, you can download PHP’s default cnf file here.

Add the following line to php.ini:

extension=php_openssl.dll

Make sure the following line is uncommented in httpd.conf:

LoadModule ssl_module modules/mod_ssl.so

Restart Apache.

You’re done!

The Apache httpd server will automatically ignore the double slashes, and treat the URL as if the double slash was a single slash. This is helpful; the server is giving the user what they want, even though they technically didn’t ask for it correctly.

Reslet’s Router class, however, isn’t so forgiving. If you accidentally include a double-slash in the URL of a request, a Restlet application will probably return a 404 Not Found status code.

Thankfully, Restlet’s request handling process is so flexible, we can easily add a Filter which will cause the application to ignore double slashes, just like httpd.

If your application uses a subclass of Restlet’s Application class, then it is overriding the default getRoot() method to provide your own request handling Restlets.

A standard getRoot() might look something like this:

@Override
public Restlet getRoot()
{
Router router = new Router();
// Attach all the routes
router.attach("path", ResourceClass.class);
return router;
}

In order to remove double slashes from request URLs before they reach the router, we can create an anonymous Filter class and return it as
the root of the application:

@Override
public Restlet getRoot()
{
Filter doubleSlashFilter = new Filter() {
@Override
protected int beforeHandle(Request request, Response response) {
Reference ref = request.getResourceRef();
String originalPath = ref.getPath();
if (originalPath.contains("//"))
{
String newPath = originalPath.replaceAll("//", "/");
ref.setPath(newPath);
}
return Filter.CONTINUE;
}
};
Router router = new Router();
// Attach all the routes
router.attach("path", ResourceClass.class);
doubleSlashFilter.setNext(router);
return doubleSlashFilter;
}

And that’s it! The application will now ignore double slashes, and will successfully serve requests that accidentally include them.