About This Particular Outliner
Task Management and Outlining, Part 2
This month, we continue our look at outliner support for task management. Previously we sketched some of the relevant history and noted a few ideas around the topic. Task management is one of those few application areas that is individually defined: there are lots of ways of slicing and servicing the problem—and that makes it worth ATPO attention. After all, the idea behind this column is to think about different methods so you can select or design your own.
Some Task Management Systems
This may be the most controversial of ATPO columns. Judging from my mail, people are even more religious about this than writing and information storage, the other two big outliner domains. Some mail seems downright fundamentalist.
So let’s deal with the currently popular scripture right now. David Allen consults on task management for corporations and has written a book, Getting Things Done, that has been mentioned many times in outliner discussions. He also sells an Outlook “add in” that supports his method (Outlook is the Windows equivalent of Entourage in Microsoft’s Office suite).
Allen’s method is concise, fairly simple, and apparently complete. It is the little sister to perhaps a dozen such methods that I know, developed individually by the big consulting firms and originally hosted within Lotus. The latest generation of these methods are now appearing in Enterprise Resource Planning (ERP) and Product Data Management (PDM) frameworks as those frameworks displace older Lotus and similar coordination methods in the big corporations.
Allen’s stuff differentiates itself from these larger systems by connecting more to Microsoft desktop software and a retail marketing strategy.
I do not want to recommend it because our scope here is flexible task management for individuals and small enterprises. Allen’s target is executives in larger enterprises, so he has a focus on delegation and audit-ability: tools to tell the boss what you did. It is also unfriendly to integration with writing projects using the same tool, a peculiar strength of outlining. It lacks an emphasis on continually redefining the problem; this is largely because it presumes tasks come from external sources rather than being synthesized and re-imagined internally.
I presume that most ATPO readers will have a combination of tasks: some may come from outside and be situated in an enterprise, but many Mac users are creative types who set their own goals. It’s not enough to simply capture these, you need to be able to adeptly and introspectively redefine them as you learn and change. Often the larger goal itself changes (when you’re not in a big company). And all this might be mixed in with personal tasks, infrastructure tasks, and non-task reminders (like your girlfriend’s birthday).
Though I’m not recommending Allen’s specific system, you may want to study it to glean the principles you would like to use. My impression of the outliner users that quote GTD is that they have done just that: adapted some of the principles rather than the method itself:
- Keep the lowest level of granularity tasks that you can do in one cycle. Allen believes this to be 20 minutes, but my own experience differs.
- Track everything.
- Set up periodic reminders based on your own level of task recall. Most users interpret this to be daily for fine-grained tasks and monthly for coarse granularity, producing the magic number of 43 ticklers (31 days plus 12 months).
The goals in designing your own system are simplicity, consistency, and integration with tools that work the way you think. Meanwhile, you may want to look at how the Getting Things Done method has been employed with ATPO-mentioned outliners. Discussion on this is usually in blogs so I won’t link directly to them here, but try Google on “Getting Things Done” (or “GTD”) plus Tinderbox, Hog Bay Notebook, OmniOutliner, VoodooPad, Circus Ponies NoteBook, or NoteTaker. You’ll be surprised how many relevant and interesting hits you get.
Matt Vance has summarized the method if you want a simple outline of the official elements. There are lots of other sites with more generic and possibly more useful information. Of them, 43 Folders may be the best.
What’s so special about the outlining paradigm in this space anyway? After all, database facilities are richer and more flexible. But the game is to use the lightest-weight coherent collection of modeling, visualization, and manipulation tools that does the job. It has to be lightweight and easy to use, lest the task of managing tasks overwhelms.
“Modeling” includes capturing the task and related information and dependencies.
“Visualization” is the process of “seeing” and understanding where you stand and what you have to-do.
“Manipulation” is all the stuff you do to perform (possibly with audit-ability), redefine, delegate, discard, and so on.
Perhaps no other application category follows the hacker’s law of complexity as this one: the more power, the higher the learning bump, and the more effort goes into everyday operation. My own approach to software generally is to always start with the most capable (and difficult to learn) application in a class, even if my needs are slight. That gives me room to grow; after all, most of us really don’t know how we would work if constraints that seem permanent and natural are removed.
But this one category (and perhaps passive applications like RSS newsreaders) is different for most people. Most of us seek out task managers because we aren’t as good at managing our time as we’d like. In that case, the theory of minimum effort comes into play: that means most of you won’t want the baggage and trouble of a heavy application.
I need to mention a particular effect with this type of software. My research group was interested at one time in “around-the-world” engineering. In retrospect, it was based on a stupid assumption, but the idea resulted from many enterprises having people all over the globe. What if you ran an engineering project with three teams so that your US-based engineers would work on a problem all day long (8 hours) then pass it to a Japanese team who would give it another 8 hours, and then to a European team, and back to the Americans?
We actually did this on a large scale and got amazing improvements in speed and quality, greater than an order of magnitude by both measures. It turns out that the improvements didn’t come at all from the extra resources applied or any particular method, but from the enforced communication. We forced everyone to model their tasks clearly enough for someone across the globe to understand well enough to pick up the work.
As it turned out, forcing people to think about what they do and why they do it was where the improvements came from; that plus the fact that people liked to wrap up small pieces before going home because finishing the work was easier than communicating what needed to be done. The extra people, as it turned out, were actually a drag. It worked better if the second and third shifts did nothing or were placebo humans.
The point here is that the task managers can help in managing tasks, for sure. But they are probably more useful in forcing you to be explicit about what you are doing and what the consequences of your plan will be.
Simple outliners have only one way of showing relationships, by tucking things under other things. The basic hook of outlining is that it is extremely simple to make relationships, and move around various levels of detail. On this basic notion, different implementors add all sorts of helpful extras which we’ll look at in a moment.
I think the best way to proceed in this column is to start with the simplest implementations and work through to the more capable and/or specialized tools. Therefore, I’ve broken this survey into three parts:
- Task management using ordinary outliners.
- Lightweight dedicated “to-do” list managers (that leverage outlining).
- Full-featured task managers. We are lucky this column was delayed six weeks because in that time, some very interesting new entries in this category have been released.
Ordinary Outliners for Task Management
You know why concrete is the most widely used building material in the industrial world? Because it tolerates abuse by the people pouring it, because it can be so amazingly flexible in how it can be used (ships and bridges, imagine!), and because it is soulless. It takes on the character of what the user chooses it to be. Such also are outliners, and any outliner can be a serviceable task manager.
Even the most primitive outliners—any outliner on the ATPO tracker list—can be used to arrange a to-do list. The beauty of outlining is that you can focus on any detail and use the same view to see the elements of the whole project. Many outliners allow you to use checkboxes as labels so you can check off items as they are completed.
You might wonder why anyone would do such a thing (have checkboxes). Once a task is done, you no longer need to be reminded of it and can delete it. But lots of good research shows that many folks are better off keeping the dross of completed items; you can maintain enthusiasm for attacking small tasks if you can see that they amount to significant progress over time and that progress is shown as checked off items in the larger structure.
There’s quite a science behind this simple notion of breaking tasks into subtasks. Most folks don’t get much into it; after all, the best way to think about things is usually how they occur to you. But if you are interested in diving in, that science is maintained by the Work Breakdown Structure community. Like so much in this area, it was originally developed by the US military but since has become adopted and greatly refined in the civil sector. You can check the Project Management Institute for some details on this—or even the official Department of Defense standard.
That defense standard has been sullied in dozens of ways; for instance, when I was in the defense sector, I saw contractor software that broke subtasks down so that they could be distributed among key congressional districts (to ensure funding, you see). But some elements of this are worth looking at: all the subtasks at a certain level should be of the same size; all the subtasks should be dependent only on siblings; (if you are collaborating) all subtasks need to have the property of being exhaustively definable (though they rarely are) and definitively completable—meaning there is no ambiguity over when it the task is performed. Each task must include the link to another task if one is required; for instance, if a task is to make a part that someone else will use, the task must consist of making the part as well as ensuring that the next guy gets it.
Enough about that. Most ATPO readers already use one or more outliners, including at least one we call a power outliner. If that is true, there’s good reason to integrate your task management needs into one of these. Obviously, the learning time is greatly reduced, but the greater benefit is likely from integration of the tasks (the work) and meta-tasks (the task manager).
By this I mean that if you use an outliner, chances are you use it to do work, probably some of the work that the to-do list tracks. Integrating these is not just a matter of economy; there are many cases where integration is beneficial. For instance, if you are writing a report and that report requires some research or preparation, you can in the same environment have an area that lists the work to be done, contains the notes and resources used in the work, and contains the writing you are doing to write the report. All of these can link to the others in appropriate and useful ways.
Many of the power outliners have features that support task tracking. I’ll mention a few here briefly. I’m sure that enthusiasts of various techniques will chime in with all the stuff I’m not mentioning (and correct me where I goof). These are listed in increasing cost. I’m just touching on special capabilities of interest to task management. We’ve dealt with their full outlining characteristics before. As I say, I’m hoping that the brevity of the overview will be supplemented by readers who are enthusiasts of one product or another.
Hog Bay Notebook ($20)
There’s no question that of the power outliners, Hog Bay provides the most capable outliner at the lowest cost. Among these features is the clone, which allows you to enter a task in two areas: according to the work breakdown and according to the date. These clones aren’t automatic or rule-based like you can get elsewhere so you’ll have to arrange things manually. Alternatively, you can use note-to-note links for much the same functionality.
The screenshot shows the version 3.5 beta which adds columns, but doesn’t yet have the good style support version 3 does.
Hog Bay Notebook
Tao is turning into something quite refined so far as outlining functionality. In terms of task management—as with Hog Bay—it also supports clones and links (and bookmarks and tags).
Circus Ponies NoteBook ($50)
Together with several outliners, NoteBook supports special columns for task management. The screenshot shows due date, keywords (here used to assign people), and priority (the one, two, or three explanation marks). I’ve also shown checkboxes, which as you see have intelligence, like OmniOutliner’s (if some but not all subtasks are checked, the parent’s box has a dash). NoteBook can do sophisticated sorts on all these columns at once, and has a “superfind” that can be used to effectively build a clone outline as a report of tasks however you want them presented (like by day).
OmniOutliner Pro ($70, with a junior version for $40)
If you use OmniOutliner Pro, you can take advantage of its use of task-friendly columns in addition to the many other features. You can sort on these columns so that high priority or immediately pending tasks are collected. The screenshot shows a few of the possible column types, including the duration column that automatically sums the time requirements of subtasks. OmniOutliner doesn’t yet support clones and internal links, but almost any effect you need can be produced via its complete AppleScript support over column values.
AquaMinds NoteTaker ($70)
Superficially, NoteTaker looks like NoteBook, but the support for tasks is different. NoteTaker supports item-to-item links (even among notebooks) which some people use to link tasks and days. NoteTaker isn’t set up for general task management. Instead, it has a nice to-do list function. You create special to-do pages, one for each day you wish. To-do items are listed and prioritized. Items that are not checked as done are carried over to the next day and added to items on that page. You can tag items with keywords (here assignees) and gather by keyword.
Tinderbox has rule-based clones. The rules can evaluate over links (which are typed), text, and the unlimited attributes (which are also typed, but there is no “duration” type). It is the only outliner with this capability so far. (I’m advised that we may soon have this elsewhere.) So it is the most capable in bending to a system which tracks tasks.
The common approach is to capture tasks as with other outliners. But you need not mechanically copy or sort them into to-do lists, assignments, resources, priorities, and so on. All that can be done by automatically creating and sorting clones.
Lightweight Outlining To-Do List Managers
Typical ATPO users are also characterized by their use of several outliners when a targeted application does the job best. There are lots of to-do list managers, many more than we can consider in one sitting, but we’ll only look at the few that also leverage outlining.
NotePod is a simple to-do list manager with a very nice alarm mechanism. Each note has an area for text and a separate area for links. Some ATPO readers use this to link to relevant documents of other, task-heavy outliners associated with the work.
Shadow Plan (probably $23)
ShadowPlan is a mature and widely used to-do list manager centered on the Palm. It also has a popular Windows desktop version. There is a free Mac OS X, beta which is similar to the Windows version. The attributes (visible in a separate pane, unlike the columns used by most others in this section) are: category, tag (same as “mark”), priority, progress, target date, start date, and finish date. Not all of these are accessible in the Mac beta. It has checkboxes and direct links to Palm databases, including the Palm contact database, but of course those don’t work on the desktop.
The whole thing is geared to an enhanced experience on the Palm. You can filter any of these attributes. The native format is XML.
Slacker uses outlining but has poor outline manipulation controls; for instance, you cannot demote a task after it is created. Its columns are untyped categories (which the user defines), due date, and percent completed. A drawer holds an inspector that displays and sets the values of each column. The screenshot uses categories to assign tasks to people. Alarms (several handy types) can be set for upcoming tasks, and tied to the various icons.
Process is new and a sweet piece of work. I wouldn’t recommend it over many others for general outlining, but it has a succinct optimized design for task management. As an outliner, it supports labels and columns. It does not have named styles, scripting, internal links, or clones. Keyboard control of outline functions is scanty. You can see it as a two-pane outliner with columns for task support and a task property inspector in a drawer.
There are two things that make this application stand out. The first is that in addition to OPML and OmniOutliner import and export, you can export to your iPod. The second: as with any two-pane outliner, you have a notes pane where you can enter text and drag images. But with Process, you can choose instead to display certain files by reference. It’s a good idea. With an ordinary power outliner, you can enter a link to a file which when clicked opens the file in its own application. Or with some you can display the contents of a file or Web page.
In this case, you can display them (but only one) in context with the task. It is a clever and potentially useful idea. However, only certain files can be viewed, those that can be “previewed” in the Finder: RTF, images, Web pages and PDFs. That leaves out Word. Keynote, OmniGraffle and so on, a host of stuff that you might actually use.
But it is cool if you can stick to images, PDFs, URLs, and RTFs in your projects. If the text file is RTF, you can edit it directly in the note field. The screenshot shows an associated Web page.
This isn’t a Mac application at all; instead, it is a browser-based application. It behaves much like the others in this group except the information is stored on a server, and of course the interface isn’t Aqua. The $30 version is the “personal” edition; there are free and enterprise editions as well. It is implemented in open source PHP and can be installed on pretty much any machine and operating system, possibly that obsolete Mac you put Yellow Dog Linux on.
What we’re surveying here is the version called Tasks, the little brother of Tasks Pro, the professional version that handles enterprise collaboration. Tasks is for Web-based personal task management. Alarms in this case are e-mail messages, and progress can be routed to a task blog. You can link to files on your machine, and links to URLs are natural of course.
It doesn’t support categories or attributes, so the sorts are less varied than others in this category. I’m willing to guess that most ATPO readers haven’t tried this. You owe it to yourself to check it out; this business of Web outlining and a relationship with the blogosphere may take some time to sink in, but I’m willing to bet task management is the wedge that makes it happen.
The screenshots don’t really do it justice because the magic is in the blogging interface (with b2, Blogger, DruPal, Moveable Type, or WordPress). We’re going to come back to Tasks and TasksPro in an upcoming column that takes a deeper look at the Frontier/WebOutliner space.
Life Balance ($65 without Palm, $80 with)
The final “lightweight” task manager adds something unique to the mix. The unavoidable fact is that most of us with to-do lists use them to help us manage paying work. If they are set up properly, they make that work run more smoothly but at a cost. Work tasks will now have order while the rest of your personal life goes to hell.
Also, when you have a list that puts a couple items at the top, you work those items only. If you are not careful in how you structure things (and who is?), you’ll always be spending big chunks of time on tasks that might better have been done a little at a time over months. Life Balance (which has a Palm version) addresses these problems.
The Life Balance window is clear in its design. You enter tasks and subtasks in the left under “outline” view. The inspector on the right (and the calendar below) are used to assign attributes. You have some expected attributes: due date, lead time, amount of effort, and note. And you have some rather unexpected ones too: whether subtasks should be done in order, how much lead time is needed, importance of the subtask to its parent, and the notion of “place.” You define places, which can have subplaces! Places are where tasks are performed and could include home, shops, office, subcontractors, and so on. Places themselves have details, like when they are open, so that a task doesn’t appear on your sorted to-do list if the place (say a shop or the office) is closed.
The to-do list panel is more sophisticated than a usual sort. You set a preference determining how strongly the application “encourages” you to balance your tasks. That balance is factored into the to-do list sort algorithm. A pie chart report lets you know how balanced you have been.
• • •
Next month, we’ll finish up with “Full Featured Task Managers.”
The ATPO Tracker
The outlining world has been active.
AquaMinds has released a long-awaited update to its notebook application. A previous column looked at NoteTaker and its sibling Circus Ponies NoteBook. At that time, NoteTaker didn’t particularly break from the pack of heavy-duty outliners, though it offered many features. You may recall I noted it leans more toward a freeform database than a traditional outliner.
Since then, NoteTaker’s AppleScript support has matured. This is one of ATPO’s most valued commitments because it is one way for power users to expand the reach of the application. Now with this release, they’ve added something that no other power outliner has yet: a plug-in API.
You’ll recall that NoteTaker doesn’t differentiate between headers and notes like most of the other guys: the application just has one kind of citizen, which can be used either way. Previously, the content of these “entries” was limited to what AquaMinds supported: text, the normal lineup of Mac multimedia, Web pages (via WebKit), spoken notes, and freehand sketches (created elsewhere). With this plug-in architecture, third parties can write Java applets (possibly for sale) that allow creation of anything, and the result will appear as an entry. Entries can be static (like a freehand sketch) or computed, drawing information from elsewhere in the notebook or in accessible files.
Included with the new release are four example plug-ins: a freehand drawing tool, a map creation tool that visually displays the structure of a notebook or part of one, a tool that queries a database and reports the result as an entry, and a demo calculator that operates on children entries.
So far, the tools seem rudimentary—we couldn’t download them for evaluation—but the potential is clear: we now have our first outliner-defined open platform for content. One can easily imagine immediately useful things like tables that have content collected from notebooks and applet linkages to full-blown applications like OmniGraffle, FileMaker, and Keynote.
Also, with this upgrade Notetaker addresses a few user interface problems (drag and spring-loaded stuff) whose omission bothered us. And the XLST export mechanism is now mature. (We’ll do a column on XLST export.)
The Omni Group has finally released OmniOutliner Pro 3, which many of us have seen through a lengthy public beta period. As with OmniGraffle, they’ve chosen to split the product into a “pro” and non-pro version for $70 and $40 respectively.
They’ve added a few features that improve the outlining experience: folded editing (where only the first line of a note is displayed); inline display where notes appear under their headers instead of one at a time in a separate pane (which remains an option); a clipping service like many of their competitors; a “section” drawer that allows quick navigation; and voice notes. These are notable. Clones and internal links will come eventually, they promise.
But that’s not the earth-shattering news. They’ve greatly improved their AppleScript support to the point that it saturates just about the whole application. And they’ve added an XSLT transformation capability; that pretty much means that if your target is an XML format or has similar structure, your OmniOutliner can get there. In effect, this means that OmniOutliner Pro, combined with the already extraordinary column support, is the other open platform in the outlining world.
But what gets my toes curled is all of this in the context of their new support for styles. ATPO likes structure. Outlining is one way of structuring; columns provide others and styles—especially named styles—yet another. Links and clones would be others. OmniOutliner now support styles associated with outline levels, like the old MORE did eons ago and OmniOutliner 2 did, but in a more controlled way. And it has named styles, and partial styles like “bold and redden this,” that can be applied wherever you like. Styles can be collected in recallable templates. Great. Scripts and XSLT operators can see the styles.
All this is wrapped in the Omni Group’s usual attention to user interface design. I think these guys are the leaders in Mac user interface expertise: their applications just feel more Mac-like than Apple’s. In this case, there’s all sorts of new user feedback: outline manipulation is, after all, a tactile experience. Like your first dip into Aqua, some of the indicators may seem garish at first, but the impression passes.
An upcoming ATPO will feature OmniOutliner Pro and others (like Tao) in an examination of styles and workflow. We showed a screenshot of the OmniOutliner Pro in the task manager discussion above.
SubEthaEdit impressed us all when it appeared. It combined a capable text editor with Apple’s Rendezvous to allow collaborative development of documents. It surely seemed whizz-bang. But many collaborative situations involve lots of collaborative documents and different types of documents, as well as documents associated with managing the collaborations. Near-time Flow moved to address this problem using similar technologies with more structure.
It isn’t an outliner yet, but it did appear on the ATPO radar in its first incarnation because it supported folding—and in an unrelated area—indented lists. It might cooperate with many of your favorite outliners because it accepts OPML as input, but only as RSS feeds. ATPO keeps an eye on it because it is manifest destiny that it develop outliner capabilities some time, and meanwhile, it is so frippin’ ambitious.
The original user interface made sense but was clumsy in operation. At one point they added blogging, both as a source and result, and ATPO remarked that all of a sudden a whole new set of possibilities appeared: true, edited collaborative blogs.
Now there is a new version that refines the user interface, so it both makes sense and works. But you’ll need to view the included video tutorials to find your way around it. We won’t show a screenshot because the explanation of it would be too long.
We’ve remarked before about outlining becoming a pert of advanced text editors for coders, like with jEdit. Recently, MacroMates released version 1 of a new text editor aimed to compete squarely with BBEdit.
There are lots of editing features to compare between the two, but that’s beside the point here. TextMate is a Cocoa application that partially integrates with the Finder. You can start a project and add notes that literally become documents in the Finder, but which are manipulable in a drawer just like an outliner. TextMate “folders” do not appear in the Finder. This is a step toward the “Finder Integration” I’ve been touting for some time. If you want lightweight outlining but need a heavier editor than even the power outliners provide, check this out.
TextMate also supports folding of outlines within the document. It is not quite full outlining, but it is handy as heck and goes pretty far toward outlines within the outline.
Many of the ATPO outliners are Cocoa applications: Circus Ponies NoteBook; Curio; Deep Notes; DEVONthink; Hog Bay; MyMIND; NoteTaker; OmniOutliner; SH-Out; Tao; VooDooPad. Any of these can employ TextExtras and other services which extend the editor. TextExtras is free and includes an outliner indentation management tool.
The venerable Inspiration has a free update to 7.6, which adds Palm synchronization plus interactive whiteboard and tablet integration.
• • •
In the queue for future ATPO columns are: a comparison of TAO and OmniOutliner Pro 3 as an excuse to explore the role of styles in outlining; an exploration of workflows (primarily outliners to publishing applications and formats) as an excuse to explore XML and XLST; and some introduction to AppleScripting outliners, including non-scriptable outliners. Stay tuned and send help.
Also in This Series
- A Progress Report · February 2008
- Some Perspectives on the Worldwide Developers Conference · July 2007
- Writing Environments, Plus Two New Outliners · November 2006
- Examining New Business Models · September 2006
- Outlining Interface Futures · July 2006
- Outlining Workflows and ConceptDraw · May 2006
- Dossier and Outliner Web Interaction · March 2006
- Two New Outliners: Mori and iKnow & Manage · February 2006
- Styles Revisited, Video Features, and a Proposal · December 2005
- Complete Archive