About This Particular Outliner
Task Management and Outlining
You are not reading the column originally created for this space. Oh, it was really very good in its way. The idea was to “survey” task managers that use outlining. I worked really hard on it and produced a rather comprehensive, thorough, and even entertaining tour through many products. Then I came back to it after a week for tweaking, as is my custom. I was really distressed after reading it.
What I had produced was a comparative review, of the type you might read in one of the slick dead paper journals—only this was better: more in depth than you get with those guys. But after I read it, I trashed it completely because it wasn’t ATPO material.
For those new to ATPO, this is a column that supposes outliners are the vanguard of a new breed of desktop applications, a breed in which there is no king—no winner by having the most features. In this new generation, different philosophical approaches to organizing information are pursued by different developers.
Savvy users understand that their own ways of thinking, creating, and organizing aren’t the same as everyone else’s (or shouldn’t be). So a great many approaches will find similarly many different products, and those in turn will support the imagination and work of different types of users. No one will kill the others; no monopoly will emerge. Diversity of cleverness will reign.
Nowhere will this be more apparent than in writing tools, organizing tools, task management tools, and different combinations of the three. “Outlining” isn’t definitive; it just happens to be a handy way of clumping tools that are at the cusp of this new generation.
Just as the nature of the applications will change so must “application journalism.” It is not enough to write about FreeHand and Illustrator as if they were two different products. They aren’t; they just have different user interfaces. What matters is the underlying philosophy of the product. Those two have precisely the same underlying philosophy.
A good journalist will report on the different underlying approaches that are being explored in this new breed of applications. She will indicate new directions and philosophies that could be explored. This person will be read by users who want to control their own creative environments and find (or create) just the right tools. This journalist may even help users express such philosophies in a way that the developer community can respond with experiments.
That, dear readers is what I hope ATPO to be. As a result, the column you will read here and next month is much less thorough and even more unpolished. But I do hope it is ATPO material, the kind you can use to help discover some things about how you work and might want to in the future.
Task Management History
The history of task management goes back as far as civilization, I suppose. But the history of modern task engineering is much simpler, especially if you focus on certain ideas. It is a little hard to swallow, but the industrial revolution doesn’t go that far back, and the rise of large modern enterprises is even less old.
It has only been 150 years or so that portable timekeeping devices were available to the average person. In fact, the watch was the paradigm-buster of its age.
Early management of enterprises wasn’t very methodical at all: decisions were allocated down the line using the French-invented “bureau” until there were so few tasks that they didn’t have to be managed. So instead of managing tasks, you managed the task managers.
That changed with the Panama Canal, which was the first large operation to use the task management invention of an American mechanical engineer. The so-called Gantt chart captured the notion of task dependencies: you’ve got to bang out the dings in your fender before you paint it. If there is a delay in one task, it ripples through the system to a greater or lesser extent. Some dependencies allow for lots of slack, so they can be delayed and possibly done more cheaply.
Use of the Gantt chart by American canalists was the single element that differentiated them from the spectacular failure of the French on that same project.
A Typical Gantt Chart
Gantt charts were about the extent of task management tools until World War II. Previous wars had been fought by mobilizing industry and turning them into extensions of the military. And that’s how the Europeans were managing their war. But when the US entered it, industrial chiefs convinced the White House to take another tack: turn the military into an extension of industry, consolidating the whole enterprise under one leader. This huge enterprise (the largest to that time and by many measures ever) would be managed by “scientific” means.
Where the Europeans needed many layers of experts, the Americans would develop management technologies. In any case, the Americans didn’t have a cadre of trained middle level defense industrial base managers anyway, so they had to invent.
The head of General Motors—the world’s largest corporation at the time—was made General in charge. He set up shop in Dayton Ohio, near where the Wright brothers had developed the controllable airplane, another intriguing and similar story in the engineering of phenomenon. Wright Field became both the center for managing the manufacturing of war material and the place where “management science” was to be invented.
What these folks accomplished was nothing short of amazing in terms of the stuff they built: not just weapons like hundreds of thousands of airplanes, but also thousands of airfields and training centers, even hundreds of cities to support this and all the physical infrastructure (roads, sewers, schools, and the like) to go with it. Aluminum plants, even railroads for ore. All managed by task management “software,” newly invented by the “manufacturing methods” group.
Thus was spawned modern management science: yes (except for accounting bumpf) most of the stuff that forms the basis of the MBAs earned by all those well-paid folks. If this sounds America-centric to our non-North American readers, sorry but there it is. Until 14 years ago, except for one school in London, no European university even offered a degree in modern management science.
Anyway, in the late 60s as computers came on the scene, that same Manufacturing Methods group extended their “task modeling” methods to the first formal process modeling methodology (IDEF). This is notable in forming the basis for all subsequent process and activity models, including the branch now used for modeling software processes and algorithms. It’s a much bigger piece of computer history than anything Microsoft has ever done.
(I’ve written a comprehensive history on this which, alas, remains classified. In a monumental move, the Deaparment of Defense dismantled the successor to the Dayton modeling group and its counterpart in Washington. More, it forbid any further work along these lines as a matter of political dogma. Consequently, all the interesting work on such modeling is now being done in Europe under the sponsorship of the “Six Framework Programme”, which takes such research very seriously as a matter of competitiveness.)
What we’ve mentioned is task management in the context of enterprises, but desktop task management for individual and small groups is derived from the very same insights and tools.
Basic Components of Task Management
Anyway, what was it that came out of all this? Task management has the following possible components:
- Descriptions, usually in text form.
- Dependencies of the type that Gantt charts address.
- Constraints. Usually, intertask dependencies are captured in the larger category of constraints, those external values that determine whether and how a task occurs.
- Resources: the stuff that a task uses or that a task needs. Usually, the “owner” of a task is considered a human resource. But the owner can be a different attribute in some breakdowns.
- Metrics are what it means to have completed a task. It could be a simple “done,” or something more linked to the result, like “$500 resulted from that task.”
- Time. Time is not so simple a matter in this world. Some times are absolute: taxes must be sent on such and such a day. Some times are relative: some plants need to be transplanted so many days after starting. Some time is discrete and broken into days or minutes or whatever. Some time is infinitely continuous. And all that’s before you get into different representations of time.
- Decompositions, which generally means the subtasks that, when all are completed, mean the parent task is.
Using some of these, you may have any number of computed attributes, the most common of which is “priority.” Naturally, if a task will produce lots of bucks, or be a bottleneck, or must be done soon, or uses a resource that is going away, then it has a high priority. There can be many such computed attributes, but priority (or balanced priorities) seems to be the one of concern to most desktop users.
A second-order attribute is something that concerns the representation of the task. You might want to know whether your task manager has an imperfect record of what needs to be done. For instance, you might have a task to send a thank you to “that guy who changed your tire,” but you don’t know his name. So there is an implied task to find out his name. Included are unknowns that may not be known (or “evaluated”) until the task is done.
I guess that’s a sufficient set of basics for desktop task management. Remember that the tasks could be intermingled with what the tasks are about. For instance, I might have a to-do list of things to do on my novel integrated into the outline of the novel itself.
Outlining for Task Model Representation
I’ve spend scads of time with process models, from the simple ones like IDEF (which are easy to grasp) to extremely complex ones. Most of them favor some sort of graphical layout, often boxes and circles with arrows. I think astute ATPO readers will agree that outlining is a superior paradigm as a user interface for most of the attributes listed above. I think it is. I’m sure it is for task managers where the user is purely a human.
Tasks and subtasks as children are a no-brainer. As long as the task is to be performed by a human, a text description is best, don’t you think? The others are a matter of design.
The designs we’ll see are different takes on what we need to do and how. So the purpose of task managers varies according to these different approaches. They can help analyze, structure, and improve your work merely by “putting it down.” That’s because they force you to analyze things according to the paradigm used.
They can be used to remind of or even trigger tasks. The best ones should be able to help track whatever metrics are involved. If the work involves other desktop applications, you might hope that it integrates in some useful way.
In next month’s column, we’ll see how our Mac OS X outline designers handle these challenges.
For those new to ATPO, a couple of columns ago we introduced the outliner tracker to keep readers up to date on updates and new product releases in the outliner world. In prior columns, I’ve noted that the Mac world seems to be the platform for outliners, but I never imaged things would accelerate so quickly.
Because I’m now on an every-other-month schedule, the tracker has accumulated a huge number of items. If there is interest, I’ll try to have an ATPO tracker every month even though the “feature” segment of ATPO will likely continue to be every other month.
Hog Bay Notebook is on everyone’s list of power outliners to consider. It has more than a couple features no one else has, including one I particularly champion: some support for outlines within the note text. Now released is the public beta of version 3.5, which was long in the works. It’s gone from a two-pane to a three-pane view. Initially it seems a little redundant, but after some use, the wisdom of the thing makes sense. Check it out.
Hog Bay’s New Three-Pane Layout
In the screenshot, I’ve chosen to emphasize one new feature, support for columns. OmniOutliner has long been the power outliner that held this special ability over its competition, though the donationware MyMind has them too! Now with columns added to the existing clones, links, and search, Hog Bay advances itself on the list of “must evaluate.” I’ll likely dig into it in more depth in a future column. What’s interesting with our crop of power outliners is not so much the feature competition, but the entirely different, consistent, and wonderful philosophies behind them.
Here’s a new cross-platform application, notable because it has an appealing approach to arrangement. It leverages some preset categories, which is a bit unsettling if you are used to an unlimited capability in this regard. LonelyNotes has two category templates, one for fiction and one for other (which is unadvisedly called “non-fiction”).
The fiction template is the most interesting. The annotative categories here are “plots,” “factors,” and “flags.” Factors are whatever you choose, but the intent is clearly to include characters, places, and the like—anything whose name actually appears in the story. You build a project of a number of notes. (It uses the metaphor of note cards.)
To the primary notes of the project (presumably a book), you assign entries from these categories. For instance, for a particular section of text that mentions the bumbling gardener Ted, you might assign a secondary note (my term here) that describes Ted, mentioning that he will later be revealed as a CIA fixer. That secondary note would be in the “factors” category and would be shown with all factors when the factor button is pressed. It’s a sort of matrixed annotation.
Categories have characteristic colors, which appear on the primary note-cards that they annotate. It’s a kind of link from the primary outline (of the book) to secondary outlines a writer needs to keep in the background. (Here, the secondary notes are “flat”; the factors and such don’t have hierarchy. Only the book itself does.) The “flag” category is used as a sort of “to do” list capability. You might flag notes as “needs major rework.”
The “non-fiction” template does similar things, emphasizing sources and references.
You can build something very like this capability with several of the power outliners on the ATPO list. But if all you need is this, the fact that it is prebuilt in this way allows for some user interface optimization with colors and space. Unfortunately, that user interface optimization is un-Mac-like, and in any case needs some heavy work. Miss LonelyNotes is a cross-platform Java application, which means you’ll experience the odd interface quirk and redraw problem.
This curious application has been mentioned a few times in the online ATPO comments. It is an outliner of large “cards” or canvases that each can contain many objects such as text and multimedia fields, even freehand sketches. The outlining of canvases is like Keynote’s outliner in this regard. The canvases are more flexible but lack the on-card outlining of Keynote.
Well, now that has been partly fixed. A new version supports what Curio calls “lists.” But these are outlines in a very real sense. You can promote and demote, drag items around, and even drag items—any item—into the outline and have it become a header.
Curio’s New Outline-in-the-Outline
You cannot collapse them, however, and unlike Keynote, there is no relationship between the “outline” in the canvas and the outline of canvases. Still, this gives this already intriguing application something else to explore. There’s just nothing at all like it.
The screenshot shows a few interesting features. The last item “See here” is being dragged elsewhere in the hierarchy using familiar outlining feedback. The blue graphic is the Curio icon, simply dragged from the Finder into the list to form a graphic header. Entry 2c shows that all headers are independent text (or graphic) boxes and can have their perimeter shapes and fills specified. Behind the list, I wrote “scribble” using the stylus you can see in the toolbar.
The donationware MyMind has some pretty incredible features; every ATPO reader should have a copy since you can use it for free. It is the only outliner other than OmniOutliner (and now Hog Bay) to have columns. But unlike OmniOutliner, it supports images and has a mindmap view. That mindmap view is crude compared to NovaMind, for instance, but does some tricks with columns and area maps that NovaMind cannot (nor can any other program, as far as I know). And the map view is non-trivial; check out the screenshot of the multi-pane “inspector.”
The MyMind Map
Another cool feature is the ability to link notes that share a common column attribute. Tinderbox can do this, but no other program can.
Now, with a new version, it can do another thing no other program can: export the map view to scalable vector graphics (SVG). SVG is the XML format for vector graphics invented and promoted by Adobe, and now in the hands of the standards folks. This is a strong capability if you are exporting to the Web or playing with integration of other XML-savvy applications.
Unfortunately, the developer, Sebastian Krauss, was hit by a car and seriously injured. Some painful and prolonged rehabilitation is reportedly in store. I’m hoping that the outlining community sends him support and best wishes. We need guys like this.
In an earlier column, we reported that Frontier was to be released as open source software. That’s now happened, and you can get your copy. I suspect the availability of the source code is less important than the availability of the application for free. (Previously, it would have cost an incredible $900 per year.)
That’s because the tailorability of Frontier was always in extending it through scripts in its native UserTalk language. What you get in the free download is the Frontier of about nine years ago, because little work of interest has been done since. You get a simple outliner. Plus you get a built-in scripting environment that is way more capable and logical than AppleScript.
Unfortunately, the Mac has moved under UserTalk’s feet since Frontier was a real Mac application, and some of the scripting interfaces with the system are broken. I think every ATPO reader should at least play with this a bit. There’s a lot of history and potential power here, and it might not take much of a critical mass to build the ultimately extensible and scriptable “ordinary” outliner.
I’ve given this simple little application short shrift in the past. It is a lean and mean little two-pane “skinnable” outliner. The recent update allows you to import text files so that every line becomes a new note.
The premier OS X mindmapper, NovaMind, has an update that publishes its mindmaps to HTML. It already supported a huge number of publishing and export formats, including image formats like JPEG and so on, structural formats like OPML, and exchange formats with other mindmappers. But this HTML deal is different because you actually generate a whole Web site. Two modes are supported: one gives a view much like the appearance and behavior of the mindmap when viewed in the application. The other gives a more ordinary type of output, as if it were generated from the outline.
The screenwriting module is already greatly improved, though I’m not qualified to judge it.
Man, at this rate of improvement in all these products we’ll soon be making a real dent in the universe. Makes the big guys at Microsoft and Adobe seem lazy, doesn’t it?
The other notable OS X mindmapper is cleaner and much cheaper. I had a lot of trouble with it a few updates back, but the recent updates have fixed all my problems. The new version adds a few layout niceties, nothing major.
Near-Time Flow is another of those completely unique visions under the ATPO umbrella. We’ve mentioned it before. It emphasizes its powerful collaboration tools, but individual users might find it interesting as well—especially now that the recent version supports blog publishing.
Have I mentioned this one before? Well, put it on the list. It is a free Java outliner, except all the outlining is done in tree charts. It’s a bit rough but worth scoping out if you are being thorough. The screenshot shows the basic idea: just clicking on an empty spot on the canvas creates a new note. The location of the click determines the hierarchy. The shot doesn’t show the most developed aspect of the thing, which is that ability to attach, link, or reference just about anything.
All in all, it is pretty thin soup if you are used to some of the other stuff in the ATPO shed.
Our last column noted that Tao was to be released when the column appeared. Well, it did, and in the two months since has had about 13 updates. No foolin’, often three a week!
You’ll recall that it is going after the MORE crowd, meaning those that want a keystroke for every conceivable insertion point and movement of headers. But it has some other pretty cool stuff beyond MORE: better stylesheets, modern Quartz rendering (for instance, Panther shadowing), great key commands, cloning, hoisting, and support for images.
It has no columns or scripting, but a growing set of editing niceties, like a split editor. One of the latter updates adds zooming. I expect to do a comparison of this and OmniOutliner 3 when the latter appears—not so much a feature comparison but a contrast of philosophies. Let’s hope that before then the busy developer answers one of my e-mails.
For quite a while now, Devon Technologies has been talking about the next release of their applications, which will more fully exploit their technology which seems to involve semantic inferencing. Most important to ATPO is DEVONthink Pro, probably the most capable information manager for “found” items. No word on that yet, but they have released the next version of their junior edition: DEVONnote.
DEVONnote is the outliner without support for search or multimedia and huge numbers of entries. (The scalability of DEVONthink is a primary feature.) This release of DEVONnote adds wikilinks. I find DEVONnote to finally be a serviceable outliner. Here’s a screenshot.
As an outliner, it supports labels and crosslinks, more or less the basics. You’d only want to consider it (and its big sisters) for two reasons: the wide variety of formats it imports and the still superior “auto” classification of entries. But now, wikilinks too.
It was bound to happen. In all my lists of outliners, I omitted one. And this was one that got high marks in an ATPM article.
Actually, I remember having this one on my machine in the past, but my account of it got lost in the grand confusion with scores of other programs.
It is a Cocoa snippets database with an outline view, and it supports OS X services. Snipping (or dragging) into Xnippets puts items at the bottom of the outline. To place it in the outline hierarchy, you’ll have to manually drag it to where you want. This is less handy than the NoteBook/NoteTaker approach where you can select among predetermined target locations in the outline.
But Xnippets has a service that allows you to retrieve snippets via the Services menu. This makes it the first outline-savvy multi-clipboard; think of it that way when you check it out. When you do check it out, look for the very nice animation of the disclosure triangle when an item is dragged to its folder. I really like this touch. It has some other fine touches like this, though it is missing some power features.
ATPO somewhat arbitrarily draws a line with outliners; if you don’t use the outliner paradigm in your application, we don’t discuss it. I admit it is a limiting boundary, and feel a little bad that it prohibits us from including some really interesting approaches in our discussions of structure. One of these is Zoe, a radical revisioning of mail stores. Another is Boswell. I’d like to break the rule briefly and mention Boswell because it takes such a different approach.
Boswell, first released in 2000, has just been updated to version 4. While some quaint reminders of the past remain (like the really hokey icons), the new release looks more modern. Gone are some of the unnecessarily non-standard notions like “zap,” “clues,” “cockpit,” and “browser.”
Superficially, Boswell is very much like many of our ATPO stalwarts. It collects and stores stuff, indexes by user-definable attributes, and presents results in more refined structures. At this simple level, the collection mechanisms are less handy than other ATPO entries as services, contextual menus, and system-wide hotkey clipping are not supported. What it stores is just text, which makes it seem rather simple in comparison to others. And the resulting notebooks proudly eschew hierarchical structure, which the ATPO reader is likely to think unduly limiting.
And it has one characteristic that I suppose turns most users off: once you put something in Boswell’s archive section, it is there forever and cannot be changed. At least this would turn off users whose goal is to collect stuff and incrementally refine both the content and structure until you have some new creation. But wait, this is worth a little time.
There’s method in this. As with all the things we consider, it pays to study how it works. Archived notes go into a big storage pool. If this pool never changes—except for adding new things at the end—then all sorts of speed and file stability advantages accrue. The attributes (or metadata if you prefer) of notes are assigned in a variety of ways, as tags, headers, and keywords in comments. An important attribute of notes is what “notebook” they are stored in. More about notebooks in a moment.
Boswell’s Main Window
The list of attributes is maintained separately, so searching and filtering is much faster than in other applications we mention. Belonging to (meaning being sorted into) a notebook essentially means a search and gather operation has been performed among everything in the library.
Boswell Autofilter Dialog
The developer has a recently issued patent on indexed attributes. It describes the advantages of a separate list of search attributes over an unchangeable note store.
While most entries never can change, the contents are not completely static: one notebook is the journal, where any archived note can be copied and modified. So you might be writing a history textbook in the journal and have various notebooks of source material and prior versions of chapters. Or you might be a lawyer using the journal to build a case, with the notebooks containing unalterable testimony. As my own experiment, I am working with it to take a huge number of e-mails (which of course will never change) on an esoteric subject and draw from those to write an overview that makes sense.
Though Boswell doggedly refuses to display any hierarchy, notebooks can contain notebooks to any depth, and notes can be in any number of notebooks. There are handy tools (once you get the design of the thing) for filtering and assigning to notebooks. So while it doesn’t look like an outliner, it surely is one that uses what we’ve called clones.
Boswell is a Carbon application, developed with the long defunct MacApp framework (which incidentally was also used by the killer application Photoshop). Though it comes with reasonable HTML help, that help is not accessible through the standard Help menu. It doesn’t antialias text, so it will look clumsy next to everything else on your desktop. There are few preferences to set, primarily to set the display font. The system spellchecker is not supported, nor is it scriptable.
ATPO encourages all readers to think seriously about how they work and why. Goofing around with Boswell’s demo might be a worthwhile exercise in confronting why you do things the way you do.
The new version is different in a few ways, seemingly small but profound in use. The collapsible “inspector” palettes are still there, but much improved. They now behave like OmniGraffle’s in how they separate and dock. There is a new approach to setting and editing styles by structure that is unlike anything I have seen. It has a learning curve, eased because it just makes sense.
Here are the major new features: an inline view for notes. This is a great boon to many writers. It follows the conventions set by Inspiration in having a note icon in the same area as the disclosure triangle. But the note icon behaves more sensibly than Inspiration’s. It now supports multimedia and folded editing (where the note collapses under its first line). There’s a clipping service, batch search, bookmarks, XLST plug-in architecture, and audio recording.
Greatly appreciated by me were the vastly improved style and printing controls. AppleScript support is expanded and improved. There are lots of other less notable things and many interface tweaks, including an in-text label marker strategy (for URLs and such) that seems a bit too fluffy.
Links and clones have been bypassed this round. Ouch!
It is still in beta and has a few glitches; I do not know the release date.
ATPO will have a lot to say about this in due time.
If you dabble in the Windows outlining world, you no doubt know Treepad. It’s not bad and has both Linux and freeware versions. Now there is an open source project to clone it in Java, Jreepad.
Jreepad provides an OS X version. Thanks go to anyone who works on open source outliners like this. But this just isn’t ready yet for any useful work. It has feature limitations, user interface problems, and sometimes just doesn’t work. Keep it in mind though. Some of these open source things become outstanding items and this could take off if it really has Treepad as a model.
• • •
The amount of ATPO feedback e-mail has significantly tapered off recently. If there is sufficient interest, we’ll continue writing columns that use applications as examples of different philosophies. Suggestions for future columns include looking at snippet managers, styles in outliners, and writers’ workflows. A recent comment on our February column (!) raised the issue of OPML and it got me thinking that we could do better, much better, if we tapped the ATPO reader expertise. Are you game?
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