Skip to Content
Skip to Table of Contents

← Previous Article Next Article →

ATPM 9.11
November 2003

Columns

Extras

Reviews

Download ATPM 9.11

Choose a format:

About This Particular Outliner

by Ted Goranson, tgoranson@atpm.com

Outliner Features—Part 2

This month, we finish our survey of outliner features that we began last month. You’ll recall our goal is to list all the major features found in all outliners so that you can write your own definition of outliner needs. After all, this is your particular Macintosh.

Last month, we noted these features:

Now we complete the list of features.

Integrated Multilevels

Regarding multilevel outliners, the very best functionality is when the multiple levels of outline of notes and outline within notes are seamlessly integrated. Promoting a top-level header from the lower outline should move to a low-level header in the upper outline.

Keynote has something like this ability in its “outline” mode. On the left you can see the organization of the entire document, and on the right the organization in outline form of a specific slide or note. You can promote a slide bullet to a slide title. It is as if you were able to take a large complex outline in a note and seamlessly break it into smaller notes by just promoting headers. This is such a tremendously useful capability one wonders why it is not widely implemented.

atpo-keynotea

Keynote, Before Promoting

atpo-keynoteb

Keynote, After Promoting

I wrote an outliner (NisusOutliner, now defunct) that did just this. It had headers that behaved as outlines just as in Word, and it had paragraphs. But the paragraphs could be organized using bullets and sub-bullets as a mini-outline. A bullet could be promoted to body text and then to a next-level header (depending on what level header the text was under) and then on up using the same keystroke (Shift-Tab).

External Links and References

Simple outliners only contain content that is explicitly entered or imported into the document. More advanced outliners can link to external sources. Simple links are usually URL-like text or badges that when clicked open a file or Web page. More advanced implementations import or display the contents of the referenced source.

By far, the most amazing of our applications in this regard is Tinderbox, shown in the screenshot. A note can be fetched, displayed and filtered from a Web page, or a dynamic RSS feed. (Real Simple Syndication is a common Web news and blog publishing standard.) Or the note can find anything that can be AppleScripted because opening a note can trigger a script. Tinderbox also supports the weaker version of link references to files or URLs. Inspiration and NoteBook do this too. Hog Bay Notebook is limited to URLs. Radio can only import other Radio outlines.

atpo-tinderbox

Tinderbox

Internal Links and References

Quite apart from external links, many outliners support internal links as well. A simple implementation uses Web-like hypertext to take you to another place in the outline, or even in another outline reachable by your machine. A more complete implementation doesn’t have the limitations of the Web, and might allow two-way linking, named and typed links, and links among text bocks and headers.

Tinderbox is the champ in this department too. Links can be from or to blocks or text. They can be typed, overlap, and have agents and tags attached. The now defunct Palimpsest had a similar, less capable (no agents) set of links, but they could be two-way.

The example screenshot for this feature is VooDooPad, which is in effect a two-pane outliner without the first pane, and which implements the hierarchy as links. Better is a similar capability in Hog Bay Notebook which supports both this “wiki”-type hyperlink and the traditional hierarchy.

atpo-voodoopadbetter

VooDooPad

Clones

Tree structures are powerful, but inherently inflexible. What happens when you want to put something in more than one place? The Finder’s outliner implements this though “aliases.” Such a capability greatly extends the power of the outlining paradigm. In the outlining world, it is usually called “cloning.” Simple cloning is like the Finder, where any change is reflected in the source; there is only one source and the clone is a pointer to that source. More advanced implementations allow branching, where multiple copies are kept and can be changed independently. An even more advanced notion syncs the changes.

Tinderbox supports cloning in spades. Clones can be simple aliases or copies, and in either case can be filtered or processed by agents. We have tried to spread our screenshots among different applications, so here we show a different example: Leo. Leo supports clones in an elegant, integrated way. DEVONthink supports something like this in what it calls “replicants.”

The screenshot is of Leo on Windows. People do run Leo on Aqua, but this poor columnist was unable to do so in time (the author is enthusiastically helping and we expect to report how to install it on OS X in a later column).

atpo-leo

Leo

Group Operations, Sort and Search, Mark and Gather

Working with outlines is often a matter of locating ideas and restructuring them. The simple operation is to select a single header and move it in some way. But novice outline users quickly outgrow that limitation and want to move many headers. Some outliners allow you to select a header and promote not just it, but it and all its children as well. A much more powerful selection method is the “search” command. For instance: “select all headers containing the word ‘example’ and created or modified in the last 10 days, together with their children.” You can then drag that discontinuous assembly to a new header location and it will create a new branch of all those parts based on certain rules.

Tinderbox is the only outliner that fully supports this, and can gather to a clone. MORE developed it in that powerful context. Tinderbox’s implementation is automated, where MORE’s involved a manual search. No other outliner seems to have anything close. Some outliners can gather by sorting on pretagged characteristics. The screenshot shows one of these: Liner.

atpo-liner

Liner

NoteBook takes a different tack. It automatically gathers by the tags you apply and can do custom “gathers” of multiple tags. These are collected on index pages from whence you can copy and collect on regular pages.

Hoist

A key utility of outlines is that you can see the structure of very large documents, yet zoom in on any one part. “Hoisting” allows you to do something in between. If you select a header in some outliners and hoist that header, what you get is a view of the outline as if only the structure under that one header existed. You could, for example, have a whole book in one outline, but work on outlines of chapters in isolation by hoisting.

OmniOutliner supports this effortlessly as shown in the screenshot. Radio and NoteBook do as well, but only NoteBook has clear visual feedback in the outline that you are hoisted; you will note that the screenshot shows that OmniOutliner’s feedback is in the window title.

atpo-omnioutliner-a

OmniOutliner, Before Hoisting

atpo-omnioutliner-b

OmniOutliner, After Hoisting

Columns

You may have been wondering why in the first column (ATPM 9.09) we took a detour to mention the basic types of structuring methods. It is because although tree structures are natural and powerful, they do have significant limitations. And anybody as creative as your typical ATPM reader will run up against these limits. We’ve already mentioned a couple tricks: links and clones. Here’s another really significant one that takes advantage of the two dimensions of your screen.

Columns are a simple idea; outline headers have a “main” column that behaves like an outline and additional columns to the right that behave like a table, or in some cases like a spreadsheet. More advanced implementations allow columns to have assignable data types (numbers, text, dates, events, and so on) and styles.

atpo-omnioutliner-1

OmniOutliner

Sometimes they can have computed results. Often, they are sortable, which temporarily (or permanently) changes the order of headers, acting as row titles. Clever use of attributes in columns and sort criteria can emulate a search and gather function. InfoDepot, now defunct, seems to have developed this idea, followed by the similarly defunct INcontrol. They had masterful implementations of columns. OmniOutliner is the only OS X outliner that supports this type of column, and its implementation is pretty robust. The screenshot shows OmniOutliner.

Schedule is multi-platform but originated on the Mac. It also has a column feature from its Mac-only days, which is much more mature but not as general purpose.

Views and View Templates

Most outliners allow some control over how the information is displayed, but that control is per document and set once, rather like a word processing document. Some now-defunct Mac outliners (InfoDepot and INcontrol) took more of a FileMaker-like approach to cells as fields. The data existed within the file, and how it displayed could be toggled into many custom layouts. Some data might be hidden in certain presentations.

Alas, no OS X mainline outliner currently has this capability. In a future column, we will describe how to use Keynote as an outliner. If you do, you’ll get this great feature so far as display by shifting themes. But the changes will only cover text display.

You could emulate such a capability in FileMaker, and someone probably has.

If you run Adobe FrameMaker, you can have something like this. You can use SGML (the grandaddy of HTML and XML) to structure your document and get an outline of that structure. (We’ll note that type of outline as the very last feature in this list.) And you can use its amazing invisible mode and conditional text, plus its several scripting languages to make your own outliner. But FrameMaker only runs under Classic, may never be improved for the Mac, and the nifty outlining plug-in only works under Windows. Even then, we are talking nearly $1,000.

So since there is no viable candidate for this, we omit a screenshot. But in an upcoming column we will recall some older outliners that can, and that still run under Classic. The screenshots in that column will prompt a flurry of feature requests to your favorite outliner developer, we’re sure.

Standards-Based Export

Many users of outlines do not consider the outliner as a dead end, but as part of a workflow that spans several applications. That means at a certain point the outliner needs to export structured information. There are a few standards that are emerging (like OPML, an outline format in XML) and some product-specific formats like Keynote’s. A good outliner will have an open specification of its output, presumably in XML to allow “playing well with others.”

So far as Web publishing, this task is called “rendering.” UserLand Frontier is probably the king of HTML rendering, largely because that is the main purpose of the product. It is scriptable by its own very powerful language, UserTalk, which also runs on the server side. The outliner is used to edit both scripts and outline content. But Frontier is $900 a year.

At less than a sixth of that price, Tinderbox has the most flexible and capable rendering overall, in part because it allows so many sophisticated internal relationships and links. That, plus its agents, can be used—if planned well—for very sophisticated publishing. Tinderbox’s internal representation is XML, and you can build any sort of XSL stylesheet for export, typically to a Web site. But this, and writing export scripts, is pretty hairy business.

Some outliners have built-in export to popular formats: OmniOutliner to KeyNote (and Word via AppleScript), and Inspiration to Word and AppleWorks. NoteBook and OmniOutliner export to OPML.

atpo-frontier

Frontier

Events

Some outliners are used for to-do lists, calendar editing, or project management. They need to incorporate the notion of events and dates. Sometimes, this includes event dependencies: event A or B must occur before event C does, for instance. Occasionally, an awareness of events is deeply integrated into the fabric of the outliners with alarms, priorities, event displays, and such.

Far and away, the master of this crowd is Schedule. It is an outliner with columns, and some of those columns can represent time periods and be linked according to event dependency rules—like Gantt charts. The screenshot doesn’t do justice to the bewildering modeling and presentation options.

atpo-schedulea

Schedule

atpo-scheduleb

Schedule

Tagging, Keywords, and Indexing

One way of moving outliners closer to databases is by adding columns as already noted. Often those columns can support pop-up lists of user-defined variables. These usually serve as a way of tagging the header, for instance you may note whether a paragraph is in draft or finished—or whether the priority of an item is high or low. But there are more robust, database-like ways of assigning or extracting keywords and developing indices to help you find an entry. Many users deem this important because files often get huge, especially if content is imported from elsewhere.

NoteBook has a relatively simple tagging capability, and a large number of automatically generated, handy indexes on those tags. Hog Bay Notebook uses a strong open source search engine (but can’t tag).

The example screenshot for this feature is of DEVONthink. Other outliners allow you to assign keywords and categories to notes and sometimes text within notes. DEVONthink assumes that most of your notes will be imported, that there will be huge masses of them, and that the organization of these notes will be mostly extracted rather than applied.

atpo-devonthink

DEVONthink

Metaphors

Everything we have described so far is based on a pure sort of interaction between the data and the user. For example, a “pure” outliner like OmniOutliner (other than user interface elements like the toolbar) consists of text, panes, and columns in a very clean presentation. There is nothing there other than the view of the information. Other outliners leverage various metaphors intended to improve the user experience. The most common metaphors are borrowed from the Finder, with some headers being “folders.” Another common metaphor is the notebook metaphor. Tinderbox’s chart view uses a cross between a whiteboard and sticky notes.

NoteBook and NoteTaker take this notebook metaphor to extremes, complete with lined pages that turn, tabbed sections, contents, indexes, and spiral “bindings.” Others use the Post-It metaphor. The value to a user is a matter of personal preference, remembering that the whole Mac experience is predicated on the value of user interface metaphor. We’ll did deeper into this is a future column, I promise. Additionally, we’ll compare NoteTaker and NoteBook; the similarities are fairly superficial.

atpo-notetaker

NoteTaker

Multimedia

Some outliners can only deal with text. Many can deal with graphics as a “leaf” (a note) or in the contents of a note that includes text and multimedia. Most that support graphics also support sound and movies. But these applications vary widely on significant details: can items be dynamically imported or referenced; can they be tagged, indexed, sorted, and linked like text blocks; and can they exported with some control like layout.

Hog Bay NoteBook, Skinkhunt Notes, NoteBook, and NoteTaker handle media within the outline proper. Word can insert graphic media, but not display it in the outline view. DEVONthink has the ability to display PDFs like graphics but extract the text for indexing.

The screenshot shows a quirky outliner with superb multimedia support, Portfolio. We’ve chosen to show a text document to emphasize that it could be brought into service as a rudimentary two-pane outliner. Its primary purpose is as a database for media with an emphasis on tagging, keywords, search, and display. But look at the window on the left. That is an outline of “categories” (keywords). These folders are virtual folders that you can make up to suit yourself as headers. It forms a clone-friendly parallel outline to the Finder outline which is indicated underneath. This an example of the “Distinct Meta Levels” feature we noted last month.

atpo-portfolio

Portfolio

Actions and Action Hierarchies (Internal Scripting)

Some outliners are designed so that every operation that occurs must be performed by the user. But others have a variety of automatic operations, the most common of which is word/phrase recognition for indexing, tagging, and some layout. An example of layout may be the automatic identification of an address and formatting the note as an address book entry. But there are cooler, fancier, and more useful actions that can be applied. And it is so much better if the actions are scriptable by the user. An example script: “Take all the notes having to do with things I said I would do, and make a clone and put under a header ‘Things-To-Do’ according to priority, and when one of those things to do was ‘finish this note,’ color those headers red and place all contributing notes as children.”

Of outliners, Tinderbox has the strongest capabilities of this type. Radio is in a sense scriptable as well but lacks the triggers of Tinderbox, as the filtering is presumed to be done at a server by Frontier. Leo has an interesting scripting language that is embedded in notes. IdeaKnot is the most peculiar: it is an outliner in the same odd sense that VooDooPad is, except a step more radical: its entries can also be scripts that (using a glossary-like rewriting) direct from one “knot” (collection of notes) to another in a dynamic hierarchy.

Novel outliners will be the subject of a future column, including unexpected use of some programs as outliners. The screenshot shows Mailsmith, for example, which can be seen as a typical three-pane outliner with the notes pane having an e-mail message usually attached. You can actually use it as a pretty competent outliner. Why would you want to do such a thing? Because in addition to having access to the best search and editing engines on the Mac and a clipping service, you can attach scripts to mailboxes that can call AppleScripts. These can pass notes around in remarkable ways. It’s not as handy or easy as with Tinderbox, but in some ways it can be more powerful because through AppleScript you can do almost anything.

atpo-mailsmith

Mailsmith

Scripting

We’ve already noted the ability to script the output, and to write internal actions that collect and manage notes. Here we look at the application as a whole. Is the application itself scriptable? If it is, then you might be able to do those internal things. But you are also more likely to be able to integrate the application into a workflow that involves several applications. And of all application types, you are most likely to want to do this with outliners.

The most scriptable application—by far—of the straight outliners we consider, is OmniOutliner. You can readily write AppleScripts, and there are lots of user-contributed scripts that do all sorts of neat things including custom integration with other applications (Word, iPod, Palm, and so on). Radio is also supremely scriptable; in fact, the predecessor of Radio (Frontier) started life as the first Mac scripting environment and grew into AppleScript compliance when Apple introduced it. Schedule and Word are AppleScriptable as well.

JEdit is scriptable via the Java in which it is written, Leo similarly in Python, Emacs in Lisp, and Vim by any Unix scripting language (Perl, Python, Ruby, and its own language), but you’d have to be a pretty sophisticated user to do so. As with Radio, you’d be writing the scripts in the editor you are scripting, which is a very elegant notion.

NoteTaker and Hog Bay Notebook have rudimentary AppleScript support, but in both cases it is immature and currently not much use. But both products have aggressive developers committed to scriptability so this is likely to become useful soon.

If you take the plunge with us in a later column and explore Mailsmith as one of your outliners, you’ll be pleased to know that it (and to a lesser extent Eudora) is friendlier to AppleScript (both externally and internally as noted above) than just about any application of any kind.

The screenshot shows an OmniOutliner outline behind two Script Debugger windows showing an example script and an object model of a document—which also happens to be (a tree view of) an outline.

atpo-omnioutliner-2

OmniOutliner and Script Debugger

Header Relationships

Thanks for sticking with us through that rather long list. Our final feature is pretty cool. Ordinary outlines capture a rather simple relationship: something is at a level under, over, or the same as something else. By named and typed links, Tinderbox allows us to relate two notes according to an arbitrary relationship independent of the outline. But what if the outline structure itself captured several types of relationships?

IdeaGraph is an early work in progress that attempts just that. The kinds of relationships it has in mind are derived from the standard developed by the Semantic Web folks (RDF, the Resource Description Framework). The idea is that in the near future, we are going to want to structure documents so that the structure reflects their internal semantics. Right now, you can import a Web page into an outliner, but all you get is a collection of words. In the future, you should also be able to import (or create from scratch and display) the actual meaning of the site by semantics encoded in, or referenced by, that RDF.

The screenshot depicts this. The window on the right is like a cross between Tinderbox’s and Inspiration’s graphical views. Each note has a box. Each box can be linked to another by various relationships. But those relationships can be captured in an expanded notion of a tree structure. The left shows an outline that has this structure coded in symbols that in a regular Mac outliner would be triangles.

atpo-ideagraph

Onward

Thanks for sticking with us for the rather lengthy survey of features. It must be frustrating to see so many applications mentioned in a way that is too brief to be useful. But never fear, in months ahead we will dive into just about every one of them. With the basic foundation of features as a basis, we are now ready to explore various use patterns and application comparisons. Stick with us as we go on an adventure, and send us feedback on where you’d like to go. For instance, should we look at little known outliners and use of unexpected applications (like Mailsmith) as outliners? Or would you rather see more traditional comparative reviews?

Department of Corrections, Apologies, and Additions

Our survey is so ambitious that I expect to make lots of mistakes and omissions. Two omissions from last month’s list of legacy outliners were both amazing applications, possibly written by some of the same people. Arrange, by Common Knowledge was a pretty advanced outliner along the lines of today’s Tinderbox. FullWrite Pro was an equally advanced word processor with an outline mode that even now compares well to Word’s. We’ll dig into both of these when we do a column on all of the fine legacy Mac outliners.

In the meantime, we have a big scoop: FullWrite Pro was free at one time, but ceased working well somewhere around Mac OS 8. Whatever was broken is now fixed in Classic. It works well and is worth a poke. More news: although the defunct developers (Akimbo) were giving it away, their site disappeared. But you can now (drum roll) download and use it for free from Dave Trautman—just as with MORE and Acta. You heard it here first, folks.

We may soon have a similar announcement on free availability for another way-cool legacy outliner. Watch this space.

Some more outliners to add to the list of last month’s column:

We’ll be sure to include these in the feature summaries and reviews.

Any other omissions?

Also in This Series

500 Internal Server Error

Internal Server Error

The server encountered an internal error or misconfiguration and was unable to complete your request.

Please contact the server administrator at admin@atpm.com to inform them of the time this error occurred, and the actions you performed just before this error.

More information about this error may be available in the server error log.