Skip to Content
Skip to Table of Contents

← Previous Article Next Article →

ATPM 10.10
October 2004




Download ATPM 10.10

Choose a format:

About This Particular Outliner

by Ted Goranson,

Deep Tinderbox

For those new to ATPO, this is a column about outlining. Each column examines some corner of outlining. We don’t do reviews—ATPM reviewers and others do a great job of that elsewhere. Instead, when we look at specific outliners we want to tell you how they work. We hope it will help you understand some of the issues concerned with arranging ideas, and possibly make a product choice.

In this column we attempt to survey Tinderbox, with an overview that includes a special offer for ATPO readers. At the end of the column is our outline tracker, which introduces some new outliners to the corral.

Tinderbox—here’s something of a polarizing application. I’ve gotten lots of mail about it. Much of the mail calls it a paradigm-busting application, sometimes life-altering or uniquely empowering. Other correspondents call it inscrutable, ugly, or too complex to use.

It is at the very least something that its creators have trouble explaining to potential buyers, and indeed many experimenters give up on the demo before they “get it.” I hope this column does the job of introducing Tinderbox with little pain, because though it clearly is not for everyone it may be just what you are looking for.


Tinderbox Icon

One problem is that Tinderbox is partly a tool and partly an environment for creating your own tool. In either case, it can bend pretty far toward your own working style if you lean toward lots of “metadata”—information about your information or notes. It isn’t something you buy and just use; it is something you adapt and invent over time. Some potential users have a lot of trouble with this idea: they like to be presented with a tool that does a very specific or a well-understood thing. Then, they can learn it or not, but they at least know what “it” is.

What we’re going to do here is provide only one of two possible passes over the application. This first pass will look at Tinderbox as an outliner. Tinderbox is not really an outliner at all; it is more of an environment for annotation-rich information architectures. Eastgate probably doesn’t like it to be considered a mere outliner, but it can surely be used as one. Shocker of shockers: in this mode, Tinderbox is the most powerful outliner available by many measures. I believe that you can buy it and use it as an outliner and be supremely happy with it, never having explored its more extraordinary side. At the very least, it is the ideal way to begin using it before adventuring into more unfamiliar territory.

The second pass is just inferred. This would be a survey of Tinderbox as what it really is, a “spatial hypertext” environment, more in the spirit of the mindmappers we looked at in the last column.

You don’t need to know all the stuff we survey to start using Tinderbox productively. But you will want to be exposed to most of it to know what distinguishes this application from others. After all, you want to be educated voters, right? (Speaking of which, if you are an eligible US voter, please register and vote. Consider it payment for ATPO.)

Tinderbox as an Outliner

I think the best way to be introduced to Tinderbox is as a two-pane outliner. Later on, we’ll discuss some of the basic design decisions. For now, what you need to know is the basic design stance: familiar outliners use the header structure as the main citizen of their world, and header manipulation is something of a fetish for traditional outline users.

In this paradigm, a note or comment is something that is attached. In Tinderbox, it is the other way around, a situation that will produce some unfamiliar behavior for experienced outliner users.


The Two-Pane Outliner

The screenshot shows one of Tinderbox’s several views, the one we’ll stick with for a while. It is what Eastgate calls an “explorer” view, with a navigator on the left and a selected note on the right. The navigator in this case is the outline, though that “outline” pop-up on the lower left of the window allows you to shift to a mindmap tree view (called a “chart”) or the hypertext map view.


Explorer Pop-up

In this configuration, it looks much like any other two-pane outliner: Alepin, Caboodle, FO, NewNotePadPro, (Hog Bay) Notebook, NotePod, (Skinkhunt) Notes, Notes, OmniOutliner, PocketNotes, Sh-out!, and Shadow are the primary ones on our tracker list. The screenshot shows Hog Bay Notebook.


Hog Bay Notebook

You can shuffle the order and hierarchy of the outline in several ways. It has all the basics of an outliner. Regular readers will recall that in our second and third ATPO columns, we listed outliner features with the intent of recalling them to examine specific outliners. You might want to refer to those columns for more definition and examples of a particular feature.

So let’s look at how Tinderbox addresses this collection of features.

The ATPO Feature List

Ordinary Nesting, Promote/Demote, Collapsing

We start out with the basics of outlining. This first feature is a freebie because we wouldn’t be discussing it at all if it didn’t support robust outlines. You can create headers (Tinderbox calls them “note titles”) and move them about readily as you would expect. Collapsing and expanding is perhaps not as well supported as in some of our ATPO outliners; for instance, you cannot display only the top three levels of the hierarchy. And for reasons we note below it is not feasible to support header splitting and joining.


There are no named styles. We’ll note why in our complaints section below. No outliner at all does a good job at this in the note field, except Word, which has its own share of problems. Some outliners (such as Circus Ponies’ NoteBook) currently support styles for header levels, which is good, but a lesser good. Tinderbox does neither through a simple specification preference or dialog, except you can customize some header styles in a way we’ll indicate later.

(We note some new outliners in the ATPO tracker below; two do styled headers, another named styles throughout.)

Headers and Non-headers, Views and View Templates

This characteristic is exhibited by all two-pane outliners by definition. It means that the outliner keeps text notes separate from the outline. Many simple outliners are designed as list or task managers and cannot do this. Having these separate is essential to writers and is the equivalent of keeping section headers separate from paragraph text. After all, for writers the main advantage of outlining is to be able to literally see a document’s structure (the relationships of the components-as-headers) and manipulate it.

Tinderbox does this as well as any two-pane outliner and has several organizational views that no other product has, as we will see. On the other hand, outliners that display inline notes, where the notes are placed under the headers as a continuous flow, give special power. Inspiration and Word do this, and the forthcoming OmniOutliner 3 will as well.

This matter of inline notes and styles is an example of how Tinderbox takes a different approach than the familiar. Tinderbox is all about content and enrichment. It assumes that export for presentation or publishing is an option and that you will specify styles at that point. So it has a “Nakakoji” view that displays a note or document according to “style sheets” that you specify. So you could, if you wanted, have an inline, styled view or many views. The novelty of the Nakakoji view is that it can unravel links so they display in different ways. Only text is displayed.


A Nakakoji View

Multilevels, Multilevel Finder Integration, Integrated Multilevels, and Distinct Meta Levels

The title of this section is so long because it combines several similar features having to do with layered outlines, none of which are really supported in Tinderbox.

By multilevels, I mean outlines where the “notes” are themselves outlines where levels can be promoted between a lower outline and a higher. At present, only Circus Ponies’ NoteBook does this and, even then, this feature has its limits. I highly recommend playing with this useful technique.

Finder integration recognizes that the Finder is the 800 pound gorilla of outliners, at least so far as folders serving as headers and documents as notes. An ideal outliner will span different documents and integrate at the top level with the Finder. In previous columns, we’ve noted some such integration in other outliners.

Integration among levels is when you can move elements seamlessly from one level’s outline to the next. Tinderbox supports none of these features, but in fairness, few outliner developers so far seem as excited about them as I am.

Distinct metalevels are when you can have an outline out of the main flow. You might want to do this if your outline is a long document and your “side” outlines are to-do lists about various sections of that document. Tinderbox does support something like this, because its linking strategy can support all sorts of annotation and comment strategies where an annotation can be a full-blown outline. We’ll note that when describing various links.


Several outliners (NoteBook, NoteTaker, and Inspiration among them) support simple folding. That’s a command that takes a note or paragraph and tucks it all under the first line. It is like outline collapsing where children headers are tucked under their parents and useful for the same reason. It helps reveal the structure of huge segments of the document for analysis and reorganization.

Full folding is not supported by any OS X outliner on our ATPO tracking list. This is where any selected block or a complex array of predefined elements can be collapsed. You can in theory create a Tinderbox style sheet that will do this, but the Nakakoji view is read-only. You cannot edit the outline in such a view, so it sort of defeats the purpose.

Other Graphical Layouts

Tinderbox wins a prize of sorts here. You have several built-in views. Aside from the outline and Nakakoji views we’ve seen, you can also produce a “chart” view, which displays the structure in a hierarchical, horizontal tree:


Chart View

Or a “Map” view in which each note is displayed as a rectangle. The hierarchy is shown as colored rectangles within parent rectangles. This map view is the core view for advanced Tinderboxers, and we revisit it below. Links are displayed. Boxes can be dragged, opened, hoisted, and linked just as in the outline view.

Also, you can also have something that is a hybrid of Map and Chart called a “treemap,” which combines both the notion of a tree and layered containment.


TreeMap View

All these views, plus individual panes for notes, can be open and live if you wish.

Snipping Input and Drag and Drop

This is the ability to easily input items from other applications (or the Web), usually by “snipping.” There’s no question about this: Tinderbox is designed for people who write stuff rather than snip it from elsewhere. It has no special service for snipping from other applications like DEVONthink, which is intended as a drop box database for varied forms of “borrowed” stuff in all forms. NoteTaker, Circus Ponies’ NoteBook and Hog Bay Notebook have good facilities for grabbing and placing stuff as well. I understand that many Tinderboxers combine their ’boxing with a good snipper/database.

It supports text drag well enough, and dragging a Finder icon of any file to the box creates a link to that file, but it doesn’t “show” in the note. On the other hand, if the material is available as an RSS newsfeed, Tinderbox can fetch and display it as a simple RSS reader.

External Links and References

By this, we mean the ability to handle URLs of various types in a number of ways. There aren’t many outliners that won’t let you put a live URL in a note, and most outliners support links or aliases to files as well. Now that OS X has Web rendering built into the operating system, outliners on our tracking list are starting to allow the display of a Web page right in the note field.

Here’s how Tinderbox handles URLs: Each note has a large number of built-in attributes (and you can add any others you like). You access these from the “FF” pop-up on the upper right of the window. Selecting one displays that attribute in a line at the top of the note. If the attribute is editable, you can change it right in that field.

Some of these are: “URL,” “AutoFetch,” “ViewInBrowser,” “ReadOnly,” and “LastFetched.”


A Note Showing Attributes

If you enter a URL in the URL attribute, the note will consist of the text from that page if AutoFetch is set (“AutoFetch” tells Tinderbox to update the note based on the latest version of the page). “ViewInBrowser” tells Tinderbox to display the note in the system-specified browser. Dragging a URL to an outline or map view creates a note with those defaults (minus AutoFetch), making Tinderbox an extremely powerful bookmark manager.

Agents—which we’ll “outline” in a moment—can update pages automatically and sort them according to a variety of criteria. For example, I could set Tinderbox to monitor some key pages (not sites, Tinderbox won’t follow links from tracked pages) and look for pages that have “Goranson” and “idiot” or “genius” in the same text, make clones of them and put them under the “strokes” or “whacks” headers accordingly for my perusal.

Tinderbox’s handling of RSS feeds is even more advanced, as we’ve already noted. Tinderbox is set up as an authoring/publishing tool, so as with HTML, all the various RSS standards are supported. It publishes RSS feeds and can be used as a simple RSS reader.

Internal Links and References

Judging by the large number of outliners that support linking to external files and Internet resources, this feature must be relatively easy to program. Slightly more difficult are hypertext links that provide hot navigation from marked text blocks to notes elsewhere in the document like the Web. But why stop there? Web-type hyperlinks are pretty limited; there are lots of other types of hyperlinks.

Real hypertext theory existed well before the experiment that stuck us with HTML. Its entirely possible to have different kinds of links, and Tinderbox thankfully supports some of them. This is not the only thing that discriminates it, but it may well be the most mind-bending.

You can have links of different types, as many as you wish, or you can apply a vanilla link. The screenshot shows the type definition dialog, where you also specify color and visibility (useful for the map view).


Link Type Editor

Links can be from notes or text blocks to notes or text blocks. Multiple links can be assigned, even to overlapping text selections. Naturally, you’ll have to think about how to translate all this if you are exporting to a less capable environment like the Web.

Later, you’ll read my grousing about some user interface ugliness, but the functionality is near-orgasmically elegant, with a great example being how links are assigned. You select text if your link is from a text selection, or don’t select text if your origin is the entire note. Hit a key combo (or select the “make link” button at the bottom of the window, or a similar button on the toolbar or of course from the menu bar) and you literally get the beginning of a link, one end of which is attached to the origin, the other end attached to the cursor. You simply drag the loose end to the target. If the target is currently not visible (or doesn’t yet exist), you can “park” the unattached link in one of three parking spaces on the toolbar.


Making a Link

On dropping the link, you get a link specification dialog to determine certain characteristics of the link.


Link Characteristics Dialog

Here’s where you specify the type, and give direction if required about how you’d like the link to behave once translated to the Web. There are tools to easily modify links as well. Two of these are way cool: you can open a “Link Browser” for any note and see a list of all the links associated with that note and modify or delete them.


Link Browser

Or you can see similar information in a more graphical format in the “Roadmap” dialog.


Roadmap Dialog

If the links are specified as “visible,” you can see and follow them in the map (mindmapping-like) mode, something we’ll get to in a moment. In the outliner mode, you can open a pop-up at the bottom of a note to see all the links and follow one if you wish. These kinds of links only can be made within the current Tinderbox document. Naturally, you can follow a hyperlink.


Link Pop-up

Tinderbox’s handling of links by itself puts it above all the alternatives.


I don’t know why clones are so hard to do, but few outliners support them, currently only Tinderbox, Hog Bay Notebook, to some extent DEVONthink and now TAO, which you’ll meet way below. Clones are essential to most advanced outlining simply because trees are handy but not ideal. Sometimes you need something in two or more places.

The Finder addressed this shortcoming eons ago. The late MORE led the way for desktop outliners well before that. We need more clones in outliners! Developers, arise!

Making a clone (which Tinderbox reasonably calls an “alias”) manually is a matter of selecting a note and choosing a menu item or hitting a key combo. The new header appears in italics to designate it as a clone. It can be moved wherever you like. Changes in the clone are reflected in the original, including changes to the title. This is unlike the Aliases in the Finder which can be renamed.

But watch out. When you make a clone of a parent in the Finder or Hog Bay Notebook, it is exactly like the original and includes children. (In fact, in Hog Bay, once a clone is created, the distinction between the original and the clone goes away; both are displayed exactly the same.)

Not so in Tinderbox; the clone is an image of the note only; children are not included. It is one of the consequences of the focus on notes as the beings with souls rather than the header outline itself.

As we’ll see, Tinderbox clones can be created and moved automatically by agents. When you are moving stuff around by agents, it is not feasible to carry the children.

Group Operations, Sort and Search, Mark and Gather

The title of this feature group is influenced by a capability in MORE. In that abandoned outliner, you could “mark” headers manually or by a find operation and then “gather” the results under a header, either by moving them or making clones. It was a much celebrated capability.

Something like this is addressed in our current flock of power outliners. NoteBook and NoteTaker have some attribute marking facilities and auto-gathering that in some ways exceed MORE’s. Hog Bay has an ordinary “gather” command similar to MORE’s and a really novel “Assemble Document” command that goes much farther.

Outliners with columns can use the columns to assign tags. A “gather” in this regime is a “sort.” Tinderbox, of course, does not support columns.

But Tinderbox bests them all because it supports agents. We’ll get to the agents themselves in a moment. Let’s just note here that agents can see all the metadata of a note: all its text, attributes, and links and can do so automatically. It can “find” notes that have certain combinations of characteristics and “gather” them in special agent containers. These containers appear in the outline as headers but are identifiable by having the bar in the icon at the bottom rather than the top.


An Agent Container


Hoist is a simple feature, one that matters more when the notes are inline rather than in two panes. But it is still useful when the outline is large. It simply allows you to zoom into an area of the outline and display it by itself. Tinderbox supports this in the map mode, as well as an interesting little sister in the outline mode: you have nine levels of “zoom” so far as the font size of the outline headers. A handy little touch.


Outline Text Size Pop-up

Standards-Based Export

If Tinderbox hasn’t yet impressed, here’s a killer: XML. Tinderbox’s storage format is XML. Let’s make it clear that we are not talking about exporting XML; the files themselves are XML.

That means that you can open and edit a Tinderbox file in any XML editor (or a text editor if you have the guts). You can perform all sorts of transforms and mappings on the native file, and there are lots of tools, including many open source tools, to help you do this.


Tinderbox Data in EditiX

This alone is one reason for serious users to consider Tinderbox. XML is essentially the only open standard we have for rich documents. If you want to ensure that your thousands of hours aren’t wasted when the market shifts, you may want to take this into account. I’ve been seriously burned in the past, and I’m sure as heck not going to trust Microsoft or Adobe again. Are you?

If for some reason, your machine explodes in some way and corrupts the file, XML may be the easiest of all so far as being able to repair or recover,

ATPO is a champion of OPML, which is an XML specification for simple outline structure. It was created by Dave Winer to allow sharing of information among Frontier users. It is terrific for tying together suites that deal with “straight,” simple outlines, like merging OmniOutliner’s outlining tools with NovaMind’s mindmapping. But it just doesn’t cut the mustard when things get rich. That’s why NoteBook and NoteTaker have NBML and NTML respectively.

Tinderbox (and hypertext) maven Marc-Antoine Parent has created TinderToolBox, an open source Python facility for translating Tinderbox XML (a useful thing) and also direct manipulation of Tinderbox files (a very big deal). TinderToolBox also allows importing data into Tinderbox files, but this is on the advanced side. He currently exports to LaTeX (via HTML), which is bound to be of interest to many.

No other outliner is open in this way. Forget wanting open access to the source code if we can supplement Tinderbox functionality in this way, and on the TinderToolBox list are some pretty clever and heavy ideas.

On the negative side, saving in Tinderbox would likely be a lot faster if it used a compact proprietary format like the other guys. Some users have remarked on the long save times of large documents.

Tinderbox also exports to HTML. In fact, it does this so well, leveraging note attributes and actions, that many users purchase it purely as a blogging tool. I think Tinderbox may be unique in its approach to blog management: everything is maintained on your desktop and published or updated to the server. I’m completely skipping over this very interesting, strong capability because it isn’t central to outlining per se; but I will note that of blogging tools, the two most capable and flexible seem to be Frontier and Tinderbox, with radically differing approaches.


When we put events on the feature list, we had in mind the ability to track time as a component of task management. Most outliners don’t understand time. Tinderbox does—at least its agents do in a simple sense. You can trigger an agent to perform a task on a given day, or after so many days.

I think you would be hard pressed to choose Tinderbox primarily as an ordinary to-do list or task manager, especially with so many good special purpose outliners out there. But you can use its capabilities to roll your own credible task manager if you’ve committed for other reasons.

Tagging, Keywords, and Indexing

OK, now we can talk about metadata. Metadata is information about your information. In NoteBook, it can be stuff like a text highlight, a keyword or graphic sticker, even “date created.” In OmniOutliner, it could be any value you put in one of the columns. In the old Nisus Writer Classic, it could be a named style or variable.

In Tinderbox, there are two sources of metadata: note attributes and note links (with their own link attribute). Most people stick to the note attributes.

Some note attributes are determined by the system, like who created the note and when. Some are always there but user-editable such as note color, title, and location in the hierarchy. And then you have a third category of any attribute and value you can make up, like “draft status” or “public viewable.”

You can “Get Info” on a note and get a complete report of every attribute. You can edit attributes right there if you wish.


The Get Info Window

We’ve already shown one way to access these and display them as database fields at the top of the note. Any attribute can be displayed this way and edited there. When I said everything is an accessible attribute, I meant it; these displayed attributes are called “key” attributes. Their list is itself an attribute!

For a long time, I wondered why that pop-up menu in the upper right of the window is labelled “FF.” Actually, it is supposed to represent a table. The text content of a note is itself an attribute and you can create another attribute to put other note text in (but you have a small editing window for this).

Attribute management is eased by two tools. One is the poorly named “stamp” tool. A stamp is a collection of attribute values that you can apply to a note in one whack. It is like a style template: you may want to have one stamp for draft stuff, another for ideas, another for ready-to-publish and so on. “Stamping” a note changes attributes wholesale.


The Stamp Editor

A more sophisticated tool is the “prototype.” This is a note, possibly an empty note. Assigning a note to a prototype note (via a special kind of link) makes that note inherit all the prototype’s attribute values. As your document evolves, you can change the prototype and all the linked notes change.

Don’t be fooled into thinking the prototype is a trivial tool just because we mentioned it in association with stamps. The idea here is one common in programming, that of “inheritance.” Attribute inheritance is an extremely deep deal, especially with cascading prototypes, and can form the basis of a capable knowledge representation system. This feature leans itself more towards the artificial intelligence end of the spectrum. Tinderbox may be the first desktop software to expose inheritance as a user leverageable concept outside the software development community.

Agents can see and take action based on these attributes, typically cloning and collecting notes. But an agent can change an attribute value as well. Agents can similarly see links and act according to them, so you can use links to add metadata. For instance, you might link certain notes to a “high priority” note, which exists only to allow that tagging.

You might want to do this because placement in the hierarchy is something of a hybrid between a link and an attribute, and you can exploit the different behavior of each. For instance, you cannot create a new attribute by using an agent, but you can create a new child relationship that can be treated like an attribute.

This here is powerful stuff, which creates a somewhat difficult learning curve.

Metaphors and Header Relationships

An outline is a pretty abstract thing by itself. But it is conducive to metaphors. For instance the Finder uses the “folder” metaphor where a file is “in” a folder. Our last ATPO dealt with mindmappers, many of which use images to create other useful metaphors. Tinderbox is brazenly metaphor-free, austere in this regard—except for the name of course. A tinderbox was an essential technology in days past, before matches. It contained the stuff (tinder) you used to build a fire.

“Header Relationships” is a technique that advanced outliners use to denote more meaning in the parent-child relationship. It is used in many modeling contexts and depends on different symbols being used for parents. Then when an entry is under a parent, it carries that context as well. Tinderbox can do something like this with agents and clones, and separately with links and associated agents to change header styles, but without the graphic symbols. We’ll give an example in a moment that uses header fonts.


You can import graphics. However, users report that documents get slow when they contain too many images. Eastgate says that performance in this regard has improved, but the tool clearly prefers text and pointers. You can create a URL that points to media file on your disk or network, but Tinderbox is eclipsed by some other outliners in the ease with which you can just drag a file to a note and get a linked reference. You can only do that in Tinderbox by linking through the “file” icon at the bottom of the note window, which is a real shame.

We would hope that at some point soon we’ll see support for SVG, the Adobe-created specification for XML vector graphics, and the ability to use or at least reference data in external files directly within the note.

If you need lots of multimedia, or full drag and drop support, another tool is your best bet.

Actions and Action Hierarchies (Internal Scripting)

We’ve already touched on this. Tinderbox adds its marvelous attribute and link assignment capability to an internal scripting language. That language is amazingly rudimentary when seen by itself, more like a notation for setting attributes. It understands “boolean expressions.” That’s where you can ask it find text patterns like where “Goranson” and “jerk” but not “isn’t” are found in the same sentence.

One could hardly guess that this, by itself, would be useful, but it is.


Action Editor

Eastgate seems open to adding any new command that makes sense. Naturally, they have some clear ideas about what makes sense, ideas that may differ from yours. For instance, an agent can collect items as children but not as grandchildren. It’s a design thing. There’s a similar constraint that aliases cannot have children, as we’ve already mentioned.

Logical ways for Tinderbox to grow its internal scripting abilities would be to provide greater scripting control over prototypes (like conditional inheritance) and support “plug-ins” that can use external scripts in any language that conforms to a plug-in architecture. Also, it would be nice to assign multiple attributes to links.


We at ATPO make a big deal about AppleScriptability. OmniOutliner and Hog Bay Notebook do it well, and NoteTaker will soon. AppleScript is the first resort of the Mac power user, though many do so with reluctance (as it is notably less elegant than, say, Tinderbox in its design). After you get past user interface gloss, AppleScript and (its newly arrived cousin) shell scripting are what makes a Mac a Mac.

I just couldn’t believe Tinderbox eschewed it. Tinderbox does support AppleScript in one powerful way: you can drag a script to the icon in the bottom of a note’s window and thereafter that script will be executed when the note is opened. That means that you can have a note’s text open in BBEdit (and perform a scripted text dance) if you wish to have a power editor. (You’ll need QuicKeys or something similar to paste the text back, and you’ll have to avoid links from text blocks.)

Eastgate’s lack of enthusiasm for AppleScript comes from the desire to only introduce complexity where there’s a big payoff—there doesn’t seem to be much that AppleScript is needed for so far as Eastgate can see. If we have the internal scripting language and access to open XML (plus tools like TinderToolBox), there isn’t much left over, it seems to them.

Here’s one example: if Tinderbox supported AppleScript, someone clever could write some collection scripts to enter documents, so that local files were supported like Web pages and RSS feeds. Then Tinderbox would also be a spatial substitute for the Finder, more in the spirit and advanced vision of the original Xerox PARC concept than the OS X Finder, and you couldn’t read an issue of Macworld without tripping over it. But…this could be done by collecting the Mac file information in AppleScript (or by many other means) and folding it into the Tinderbox XML files!

Here’s another example you can’t escape, though: if it were scriptable, you could integrate it in useful ways with a media-friendly freeform database like NoteTaker and/or a special purpose task manager.

There is a long-announced version of Tinderbox for Windows that is forthcoming. Perhaps the reason for no AppleScript is: why build in something for a cross-platform application that is a Mac advantage?

(Here is the only qualm I have about Eastgate’s apparent reluctance to leverage Mac technologies. I sincerely wish them well and if future sales to Windows customers make them stronger, that’s good for us too. But I’ve seen many of my treasured applications—my trusted lovers—make visits to Windows with promises of fidelity that were all broken, every one. All of those now lack even a passing nod to Mac-unique features and some like FrameMaker have abandoned us completely. Eastgate’s dual-platform Storyspace, for instance, still hasn’t fully made the leap to OS X! On the other hand, the recent updates to Tinderbox have been frequent, even while Windows porting is underway.)

Outliner Complaints

Complaining about Tinderbox as an outliner is a bit graceless. It is as if one went to the store for a broom, bought a vacuum cleaner for about the same price, and complained about the noise.

The negative feedback I’ve gotten is in three categories. One of these I’ll dismiss early. At $145 regular price it is among the priciest outliners we track. Some ATPO readers balk at this. My own attitude is that compared to your hardware investment, the difference between $20 and $200 is insignificant in the shadow of unleashing your mind. Tinderbox is a Photoshop-scale application that is underpriced.

A common complaint is about the Tinderbox documentation. This is one that I do concede: the included documentation is inadequate. But I am prepared to cut Eastgate some slack. After all, you can noodle about in most applications and never need to look at the documentation unless you want to do something unusual. In Tinderbox’s case, you can’t really get past the simple outliner use without understanding how the thing is put together, a requirement that “ordinary” applications don’t have.

The documentation doesn’t address this well. It is mostly clear and complete, but there is no index or task-based how-to, so finding what you need is unnecessarily hard. Beyond that, there are problems in explaining core concepts. In fact, it don’t really explain how Tinderbox really works under the hood. Instead it does what ordinary application help does: tell you how to do certain things, or what specific commands or dialogs do.

This is a somewhat petty complaint compared to the problem. Tinderbox is a sophisticated knowledge representation system wrapped in an accessible form. What it really needs are two sets of documents, one that is precise, technically daunting, and complete; and a second that is task-oriented and user friendly. Both need good indexes!

Speaking of indexes, that list of note attributes can get pretty long, too long to manage well with the current user interface. Maybe the next view will be a column view, or TinderToolBox will help us view Tinderbox files in a columned outliner.

I sincerely hope that this modest column helps new users see the underlying machinery—I’ve used my own decomposition and understanding in what I present here.

The Tinderbox Web site used to have a help forum, but that has been replaced by a wiki, which has a ton of great stuff from some expert users. But it is hard to find what you are looking for and all but impossible to know when and where the latest killer new tip is posted. A moderately active independent mailing list exists as well.

I’ll say that direct e-mail support and the mailing list are both impressive, and you’ll be hard pressed to find a more expert, helpful community, tolerant of beginner queries. But I just cannot fathom why Eastgate doesn’t support a frequently updated downloadable Tinderbox document of the help and the best of the user-contributed hints that appear on the wiki.

The final category of complaints is about the user interface. ATPO has generally celebrated certain elements of the Tinderbox interface (like the icon that shows note size and age and the animation of the live link assignment), but others are a bit quirky or disappointing.

I’ll divide these into the ugly, the incomplete, and annoyances from design decisions.

The Ugly: I’ll underscore that the functionality is elegant. But the actual appearance of some elements looks temporary (like the icons in the toolbar or the “active” triangle in the outline view) or seem barebones (as in the rudimentary displays in graphic views).


Icon Ugliness


The “Active” Indicator

The Incomplete: There are a few baseline features that give the impression of unnecessary austerity. For an example, check out the Color Attribute Editor:


Color Attribute Editor

You’ll see from the screenshot that you can edit the color of the note. This is something you will want to play with when you extend your use of Tinderbox to “see” notes when you advance to using the very advantageous map view. To choose a color, you can either select from the list or type in the hexadecimal code for a color. No simple calling of several Apple-supplied color pickers here! Oh how we get spoiled. Notice, however that there are some samples of other shades, three on either side of the selection. Guess what? They don’t work. They are indicators of lighter and darker shades that you can select, but in a different dialog.

The Annoyances: These are fair complaints only if you are comparing Tinderbox to other power outliners, and they revolve around the eminence of notes over the outline hierarchy. In many other outliners, you get to choose how much information you put into the “header” text as opposed to the note. For example, in Hog Bay Notebook and OmniOutliner, you could literally treat some headers as paragraphs and the note field as your comments to yourself.

Not so in Tinderbox. The title of a note is actually an attribute of that note. You cannot edit it directly as a text field, like you might in any other outliner. Instead, you have to open a “Rename…” dialog box:


Rename Note Title Dialog Box

And then you have that little tiny box within which to edit your text, which gives you about 37 characters before it begins to scroll. Once it is changed, you might still be unhappy. That’s because the outline headers don’t wrap, so you if they are longish, you won’t be able to read them in the outline view. The screenshot shows this and another problem: how the anti-aliasing gets messed up when the header is highlighted. (This problem is fixed in version 2.3, which may be available when you read this column.)


Outline Headers Don’t Wrap!

Ordinarily, outliners focus on support for writing and arranging headers with lesser support for notes. For instance, it is common to have named styles for headers but ordinary TextEdit functionality in the notes field. As you’ll see below, the emphasis in Tinderbox is on creating notes, and the headers just go along for the ride. So the extreme focus on header operations in other outliners isn’t matched here; for instance, “split and join” commands don’t exist in Tinderbox.

But as noted in the very beginning, except for direct editing, Tinderbox has all the “rapid fire” entry commands you expect in an outliner: sibling (Return) and child (Shift-Return), plus Command-Return to open the attribute editor for the current note and Tab and Shift-Tab for promote/demote.

The final (but relatively weak) complaint is about the support for styles. This is only a complaint for beginners and is one of the things you would never discover from noodling with the demo or even reading the docs. It seems at first as if there is no support for header styles; that’s where level one headers display one way and level two differently, changing styles when levels change.

And it also appears that Tinderbox notes are pretty darned “flat,” meaning that there are no named styles in the note itself. You are limited in the note field to rudimentary local styling of the type you’d see in HTML: bold, italics, size, font, and color. This ain’t bad and is the best you’ll find in pretty much any outliner. But I’m used to the halcyon days of the old Nisus Writer where I could assign meta attributes to text blocks through named character styles, sort of like some outliners allow you to tag text by highlighting or bookmarking. In Nisus, you could leverage that style-based metadata and write a macro that found, gathered, and/or modified the marked text. (The style didn’t even need to have a visible attribute.) Tinderbox has no named styles whatever.

If Tinderbox is the ultimate in support for metadata, this lack of metadata-by-style assignment is noticeable. Also, regular ATPO readers know that I like to use Quartz’s text shadowing. Hey, you bought a Mac, right? This isn’t supported in Tinderbox, another cost of OS 9 compatibility.

But all that isn’t as bad as it sounds. Header styles are supported in an interesting way, much more cleverly than just assigning a style to a level; it is just hidden. The font, color, and justification of a header is an attribute of a note. That means you can write a simple agent that converts the header to a style based on the note’s outline level attribute. Voila, styled headers like everyone else, sorta.

As it turns out, the changed font only shows in the outline view, with the color and justification showing only in the graphical views. But with a smart selection of fonts, you can get some header styling, as the screenshot shows.


Styled Headers

Or you can go far beyond, assigning a font to high priority or draft notes, or however you wish to tag your headers with fonts. You cannot adjust the size individually (except by choosing smaller fonts of course) and italics are reserved for aliases. But beyond that, anything goes in terms of showing note attributes through header font style.

Note font, color, and background color are similarly programmable; you can set them up to indicate whatever you like, and change as the note changes. And if like me you really want to satisfy your named character style fetish, there are several macro programs you can use to apply named styles. Or you can use the attached AppleScript function to open your notes in the styled text editor of your choice.

Tinderbox agents could not see named character styles easily, and in any case Microsoft has patents with broad claims on styled text in documents, including metadata search. Bummer. Flat notes are, well, flat. Eastgate obviously knew this and decided to emphasize the arguably more manageable path to metadata—metadata at the note level.

Tinderbox Blox

We’ve said that you have to have a feel for how Tinderbox is put together. That’s true, but it is true of all applications; if you understand the design goals and implementation philosophy behind the product, it becomes easier to know if this product fits within your creative activity.

My own feeling is that you have to judge a product on features of course, but also on the level of philosophical symaptico. And you have to have confidence that the developers will continue to evolve the product.

Tinderbox is a note creator and manager. After the note, the important citizens are attributes and links.

Attributes are what gives it meaningful metadata to allow for note management and are extremely well supported. Links are conceived in a more sophisticated manner than you will find anywhere else, and are a really novel thing. Prototypes and clones are special sorts of links. The outline hierarchy is a type of link that also appears as an attribute. Agents operate on attributes. Everything else is a tool, including the visualization tools.

Tinderbox’s heritage is in hypertext theory. In my experience the cleverest ideas about life and tools are rousted about by this community—it’s been that way for years. Eastgate publishes Storyspace, the clear leader for authoring and publishing hypertext fiction.

Eastgate is also a facilitator in the several communities of fiction theorists and users. They sponsor conferences; they are the leading publisher of hypertext fiction; they know a lot about hypertext, that on-beyond-zero type of hypertext that isn’t constrained by the Web. They even publish an intelligent online periodical about hypertext ideas and tools (and other interesting things). I know of no other software house that is as engaged in the real matter of advancing their user base.

In 1996, at the height of the mad Internet rush, Eastgate introduced Web Squirrel. It was an advanced visual tool for bookmark management which had the map view (supporting “information farms”) and agents more or less like Tinderbox. Web pages In Squirrel were much like notes in Tinderbox. It was cool, but too hard to use in a market that was built on extreme simplicity. Web Squirrel failed. (Interestingly, Web Squirrel was scriptable by AppleScript and Frontier!)

The whole idea was based on work done by Frank Shipman and Cathy Marshall on VIKI.

Because of my research management experience, I firmly believe that only a second generation tool can hit a home run. You have to be able to afford that failure of the first try. I believe it is the only way to really blaze new territory. Eastgate’s second try, Tinderbox, started life under the code name Ceres, the Roman name for the goddess of grain (and also the first named asteroid). Tinderbox today is something between what a grown up Storyspace and Web Squirrel would be (though it has differing design purposes).

The key design notion of Tinderbox is to avoid premature commitment to structure and at the same time provide tools for deep structure. One of those tools is the map view, which we’ve been avoiding until now. The map view is a way of conveying structure by physical arrangement on the screen (including containment of boxes within boxes). The eye can discriminate extremely subtle variations of color, so notes have that as a key attribute.

Compared to the mindmappers of the last column, Tinderbox looks austere, You have rectangles with color and titles (the outline headers) and their arrangement including their nesting in other rectangles. The map view can display any and all links as well, with their names.

The screenshot shows a view of a trivial example outline. We are already in a first level header as you can see from the faint watermark in the back. We named that header “Header First Level.” There are two children under this header, the one you saw in the “styles” example named “Header Second Level,” and the beginning of an outline on my notes on Paul Graham’s Hackers and Painters.

You can see the “colors” of the notes (red and black); here is where the header styles would show font colors. You can see that each of these headers has children as shown in the bottom halves of their boxes.


The Map View

Note that the map has two elements that show on no other view: the “adornment.” This can be a decorative image (here the ATPM logo) but usually is an additional rectangular container or zone that provides for a third type of nesting, adding to prototypes and hierarchy.

Zooming or hoisting is natural in this view. Zooming into a parent—by just clicking—gives you a view with just its children. In the next screenshot, we’ve zoomed into the Graham box, indicated by the “Paul Graham Notes” watermark. This has three children and a couple example links. The two red notes have no children. Also shown is the “locator” list, used so you don’t have to wander through outlines and zoomed maps looking for a specific note. Consider it an alphabetical “list” view.


A Zoomed Map

The map view window commonly becomes a virtual desktop within which you scroll around. Once you get used to it, you will spend as much time in the map as in the outline, I guarantee. That’s because so many subtle indicators are leveraged. One of these of course is position, which you’ll fiddle with quite a bit at first. Alas, you cannot build multiple map views for different purposes. (But you can fake it with clones.)

Here’s a side rant: what brought me to the Mac many years ago wasn’t at all the ease of use, nor the admittedly cool desktop publishing stuff. No, it was because everything was spatial: I could arrange windows however I wished. I was an early Frontier power scripter; you know what I did? I wrote scripts that arranged icons within windows and pasted icons on them according to certain “attributes.”

Spatial arrangement is an extremely powerful aid to thinking and concept assembly. Alas, the Mac has moved away from this with the one-window columnar Finder views and the possibly ill-advised rush of applications to “tabs,” what we used to do with stacked windows. While much of the rest of the world seems to be drifting away from spatial leverage, Tinderbox stands out all the more. To me, it seems more Mac-like than much of the Mac these days.

The Bottom Line

Tinderbox is as powerful an outliner as you will find so long as you don’t need an editable inline view, or large numbers of graphics. As an information management assistant, it exploits techniques you will find in no other non-research software and really can be life-altering. It is easy to use as an outliner but has a daunting learning curve for advanced features—on the order of Photoshop or FileMaker. And it doesn’t quite “fit” modern OS X services.

If you are a regular ATPO reader, you will likely find it engaging, leading you to confront whether to make the investment in “serious” software. It is a Carbon application and runs well on OS 9.

Tinderbox’s architect, Mark Bernstein, has a huge Web presence, including his own blog and the Tinderbox development peekhole. That latter is a great asset to users and says a lot about Eastgate’s relationship to users. (As much as I like and support Mac boutique developers like Bare Bones and Omni Group, their Apple-like policy of just surprising us is a bit patronizing. I appreciate Eastgate’s openness.)

Here’s the real bottom line: what other “outliner” can host a party of users and have them fly all over the country to attend? Eastgate had a “Tinderbox weekend” in Boston this May, is hosting one in San Francisco in October, and has one planned in Europe. Good times, I hear.

Eastgate has set up a special limited offer for ATPO readers. It fits the ATPO demographic, in that it offers what is probably the best paper-based notebook together with Tinderbox and an introductory subscription to their TEKKA publication.

Ted’s TinderGarden Tips

As with all the great applications we discuss, you should try out the demo. But you might consider a few suggestions from your ATPO lifeguard:

  • Join the Tinderbox e-mail list.
  • Read the entire PDF help without the application open. (Really, it’s not long.)
  • Stick with the outline view until you are familiar with the internal machinery. It is too frustrating to learn a new application while you also learn a new manner of information visualization.
  • Before you write any notes, noodle about with the default note and outline font until you are happy. Use a variety of colors for notes and links even though you won’t see them until later. (Realize that the color of the note’s background, text, title background and title text, and the color of the note name text have nothing to do with the note’s color, which is really the color of the note’s “envelope.” In other words, keep all the “insides” the same to start with and vary the “outsides.”) Write simple agents to create header styles based on outline level.
  • Also before you start, download one of the preformatted Web or blog templates and associated style sheet (for exporting). This part of Tinderbox is among the coolest but surely the most frustrating and if you just use the defaults you won’t get mad. But you have to begin with a prefab template.
  • Use prototypes where you can, instead of stamps. Make aliases of them and keep them in a separate outline area for reference. You’ll thank me, even though this is the hard way to do things. Similarly, make an annotation or to-do outline section within the outline for stuff you need to do with links to the notes or areas you need to do them to.
  • Name your links. Make all links from note to note unless you really want an HTML link when published to the Web. I mentioned above that you can use links for metadata assignment; don’t try this. Stick with attributes initially.
  • Keep your notes short. Add and display your own attributes.
  • Make an agent (in addition to the header styles agents) even though you don’t have to, possibly one that collects aliases of “draft” notes. You’ll get addicted.
  • When you do explore the map view, don’t immediately go to a huge virtual desktop. Try the “zooming in” (like hoisting) instead.
  • Have fun. Joy isn’t always “lickable.”

Mark Bernstein (Architect of Tinderbox) Comments

A lot of software tries to help us do things that are easy but boring. Tinderbox sets out to help tackle one of the most challenging tasks we face: gathering, organizing, understanding, and sharing information. Tinderbox is a tool for learning—for discovering structures we don’t (yet) understand.

Over the years, I’ve worked with lots of brilliant, creative people—scientists, engineers, writers, and artists. If you look at their laboratories or their offices or their studios, you’ll find complex and clever strategies for managing input and capturing ideas. Much of this is done today with scraps of paper and piles of photocopies. It often looks messy, but it’s actually very efficient; the key problem, of course, is that you can’t file things away until you understand what they mean and how they fit with the other things you’re thinking about.

Meanwhile, our powerful, personal computers are often little more than typesetters and file drawers. Right now, computers make ideas look good, but they don’t give us much traction for organizing and relating them.

Tinderbox can be very simple to use—as an outliner, as a whiteboard, and a collection of note-cards. And, a lot of the time, that’s exactly how I use it myself. But Tinderbox also gives you ways of tying ideas together—links, agents, templates—that give you lots of expressive power when you need it. It’s not just about making lists or diagrams; it’s about really understanding your ideas, and Tinderbox offers a rich toolkit for working with ideas to get them down and get things done.

Where will Tinderbox go next? One active area of research—both within Eastgate and in the hypertext research community—is finding ways to make our maps even more expressive. The interplay between Tinderbox and the Web, and the way Tinderbox can work as a presentation-and-working tool in meetings, offer plenty of food for thought. We’re looking at ways to get more leverage from Web services like Google and Amazon and from RSS feeds.

Not all of these ideas will work—that’s why it’s research—but I think it’s important research to undertake. Working with ideas is hard, but it’s terribly important work, and it’s vital that we get better at doing it.

The ATPO Tracker

Now we turn from Tinderbox to report important events elsewhere in the outliner world.


Folks, we have a new outliner. Mellel is a word processor that is worth checking out. It has four things to commend it: it is built from the ground up for OS X; it is inexpensive ($29!); it has superb support for non-Roman languages; and, most importantly to me, it has a great paradigm for named styles.

I can’t overstate how useful named styles can be for metadata management (though I’ve been trying!), and Mellel has the best implementation on the Mac, one that combines with variables and supports OpenType. Now that’s leveraged to provide an outline pane for documents.


Mellel’s Outliner

In that outliner pane, you can add, rearrange, rename promote/demote, and delete headers and have the subservient paragraph text (with tables and images) follow suit in the “document” window. Finally, we have an alternative to the clunky outliner in Word, to which Mellel pretty seamlessly imports and exports.

The outline cannot span multiple Mellel documents yet. Too bad, but a minor complaint considering the achievement. Oh, and RedleX advises that they are migrating to a native XML storage format. There’s another one!

If you buy it, tell ’em ATPO sent ya.


The two-pane outliner formerly known in public betas as FO is now available as TAO. It enters the power outliner class, currently occupied by Hog Bay, NoteBook, NoteTaker, OmniOutliner, and Tinderbox. Its power features are: unlimited undo, header styles, really cool stylesheets, multiple file search, OPML export (but apparently not import!), links, and clones together with numerous but more common OS X niceties. I haven’t seen the final release—it is supposed to appear concurrent with this column—but betas have potentially irritating palette design and behavior. Some users compare it to MORE, which they intend as the highest compliment.

Its clones are like Hog Bay’s: you can delete the original and the clone survives. You can display note attributes in the lower window border. Clones, links, and styles alone make TAO worth checking out if you have not already.




Here is a clever tack on task management and outlining. Usually these things are based on a single outline where each header is a task. Everything flows from that notion. ActionItems is different, a consolidated database of outlines based on templates (people, projects, groups, etc.) and a daily journal which is an outline, entries in which can be “action items” and to which people and projects can be linked. Outlines appear all over the place as notes and also as tasks. In other words, it supports the outline of outlines features, but in a matrixed way.

This is pretty novel, check it out.



To have so many new outliners and each with a completely new take on things is really exciting. The Mac is the place to be for these sorts of things right now. I think the next ATPO might review task, project, and to-do list managers that use outlining. What do you think?


I’m often on the inside know about these things, but this one took me by surprise. Process is another new task and to-do list manager. It has predefined, unchangeable columns for priority, etc. These are not the user-definable columns of the venerable OmniOutliner and the donationware MyMind.

It also supports tasks, alarms and calendar items well. It has a competent exploitation of Aqua conventions that looks great. If it can, it will display the linked file or Web page in a pane below the outline as shown in the screenshot, which I think is unique to this application.



It comes with a seven-day demo, which is far too short for serious evaluation. It exports to OmniOutliner, iPod, and OPML, but has no apparent syncing with a handheld. Task items can have short comments and links to URLs and files.

Your evaluation will likely be on user interface and ease of use plus the utility of the “source” display. The help is rudimentary. We’ll add it to the ATPO tracker list.


MindFortress is another one that came out of the blue, at least for me. Perhaps it recently added an outline capability. It is a structured repository for your information. Each “note” is a card with predefined data fields, for instance serial number, Web page, and so on.

You can select the “general” template to make notes. The idea here is that it is a consolidated, ordered, encrypted storage system. You can create your own templates and the whole thing is AppleScriptable. No export currently exists, so whatever you put in there stays, at least for now.




MindMap Pyramid released version 1.2 that addressed one of the major limitations we noted last column. You can now export (but not import) via OPML to an outliner. They also seem to have fixed the connection glitches I noted.


NovaMind has been bumped to version 2.2, adding exchange with the Windows Mind Manager application and providing additional adornments.


The venerable writer’s outliner and mindmapper, Inspiration has introduced a syncable version for the Palm.

Roll Your Own

Bare Bones has released BBEdit 8, which adds a “tabs” drawer. Entries in that drawer cannot be hierarchical. But check out Tactile Interrogator which is (get this!) a cross-platform Finder replacement. It is unlike anything you have seen, very visual. It is somewhat in the spirit of Tinderbox’s Map view, especially regarding color tagging. You can create a Finder hierarchy with BBEdit documents and come up with something like a bare bones (sorry) outliner.


Tactile Interrogator

Such a hybrid will have terrific text editing and such, true Finder integration, and certain OS X windowing and search services. Pricey, but geeky cool.

ADM (Windows)

I get lots of welcome mail, some from Windows users championing this outliner or that. I dutifully check them out. Some are very good, but so far I have found nothing on any operating system that you cannot get better on Mac OS X. (That excludes some of the legacy outliners from systems 7 and 8).

Now, ADM 3 has been released on Windows, and a few readers with extensive Windows backgrounds (but scant Mac exposure) believe it to be uniquely powerful. As with many Windows outliners, its site has no useful information. I am soliciting help from an inclined reader to help me explore and report on this (or any other) if it proves to be interesting to ATPO readers.

• • •

If you are a developer and wish to have us survey your outliner, please contact us. Readers: let us know your interest in specific uses, categories, or applications for future columns.

Also in This Series

Reader Comments (26)

michael mckee · October 1, 2004 - 18:31 EST #1
Thanks for the great article.

I've been using Tinderbox for a couple of years now. I am alternately impressed and annoyed by it. As you say, it is very powerful but I always feel that I am just not quite grasping its full range or potential. That is totally frustrating.

You compare it to Filemaker and Photoshop in its complexity and capability. The only reason why I am proficient with either of those programs is because I've spent lots of time pouring through third party manuals and how-tos. I typically need to have training presented multiple times and mulitple ways before I get it. I'm not getting Tinderbox.

What I would love to see is an extended tutorial, something like "Learn Tinderbox in 24 Hours". The forums discussions are not methodical or thorough enough and aren't a substitute for a good training manual or two.
jon buscall · October 2, 2004 - 05:27 EST #2
I think it's actually difficult to produce an adequate training manual for Tinderbox because it's such an incredibly diverse application. The program is so adaptable that it resists definition or classification. This makes "training manuals" problematic. I think you have to throw yourself into the application and live with it over a long time. I've been a big champion of Tinderbox for a couple of years and I learn something new about it regularly. Instead of turning to a manual and looking passively for ideas, expecting Eastgate to tel me what to do with the program, I simply try and do everything in Tinderbox. It usually works! By this I mean that it works as:
a light database
a word processor
a note taker
an outliner
a visual thinking / planning tool
a great presentation app,
a clipping prog, etc

I used to work as an academic, teaching lit, and I used to Tinderbox to track everything I did and as a teaching and presentation tool. It gave me an edge and helped keep me find new approaches to pedagogy and learning. Now I work as a journalist, I track article pitches, commissions, research, articles, contacts, and write full time in Tinderbox. Again, it's adapted perfectly to my work because I've embraced the metaphor of Tinderbox.

At no point have I expected Eastgate to tell me what to do with the application. I've simply adapted it to the kind of work I do. I think that's the way you have to approach Tinderbox. You jump on board, keep using it, thinking (and thinking in public thru blogging is a great way of learning more about Tinderbox) and reacting. At times the program IS difficult. The user interface is initially very low-fi, but using Tinderbox has led me to clear the clutter away from a lot of applications I use. It's not superficially snazzy: it doesn't look like a super "sexy" application. But like a tough novel, once you scratch below the surface there's incredible depth. It's a robust, powerhorse.

I could go on about how to use Tinderbox but I'd be talking about how I use it. You have to discover what it can do for you. And like learning to play a musical instrument, it's hard work. But, boy, the rewards are great.

In short, I couldn't do what I do so effectively without the daily support and working environment Tinderbox provides.
Jolyon Patten · October 2, 2004 - 05:58 EST #3
I echo Michael's comments almost to the letter. I have persevered with TBox, alternating between rage and joy. For example, I had to present a paper on an arcane legal topic the other week and decided to use TB to research and pull my ideas together. However, it all got so messy that I quickly moved to DEVONThink to store the research data and then Word to put it all together, with Keynote rounding it off. This seemed a great pity to me as I really had wanted to use TB in a live and very mission critical situation (nothing like presenting to a knowledgeable audience to reinforce that old adage about adrenalin being brown!).

I also think that much about its interface is ugly and off-putting (sory, Mark) but it would have a lot more take-up with probably very little extra work from Eastgate.

(Ted, redundant to say it, I know, but do keep up the excellent work).
Jolyon Patten · October 3, 2004 - 09:25 EST #4
A sort of PS to my earlier post:

1. Jon B's post is also correct - it just goes to show that (a) I am a bit dense and (b) I haven't really persevered enough ;-)

2. Meant to say "interface is /a little/ ugly". It's just not 'Mac-shiny' which I am quite prepared to concede is probably superficial...

Richard Chamberlain · October 4, 2004 - 08:57 EST #5
Personally I think it's a bit of a cop out to say that it is difficult to produce a decent manual for Tinderbox. It is of course possible to produce a decent manual for anything, I expect even rocket scientists need decent manuals. Eastgate obviously need to spend some time in this area. Personally I think a definitive (and up to date!) reference manual, and then another document containing numerous user examples would be great. The Tinderbox wiki doesn't really work for me. It is often difficult to follow how conversations have developed, and a considerable amount of time it is hit by spam.

As for the interface it does needs some work and it's not entirely superficial. Take a look at the toolbar - ask a new user to guess what function each of the buttons perform. Why can't we have a colour picker instead of a drop down filled with names? Compare the outline view with any recent outliner for OS X, it still looks like an OS 9 application.

In my opinion Tinderbox is a great concept, but a not quite great implementation.

Cody Bryan III · October 4, 2004 - 11:54 EST #6
I just attended the Tinderbox weekend in San Francisco, and learned a great deal about the program. I too am frustrated because I don't fully understand the full uses of the program. But, I think I've learned enough to continue to store my information in it, and then to be able to pull that information out in a form that I can use.

Mark Berntein, Elin Sjursen and Doug Miller gave great presentations. It was a great deal of fun for me, and a wonderful learning experience. Special thanks to all of the other participants who helped me over the weekend; Alwin, Ursula, Bill, Mark, Doug, and Elin.

I'm sure that others will use Tinderbox in many different ways than I do. But, that is what is great about the program as far as I'm concerned. Special thanks to Doug Miller for showing me how to get out of the hierarchical method, and into a new method of extracting information.
Lee Phillips · October 4, 2004 - 14:47 EST #7
At last, an overview of Tinderbox that goes beyond the superficial. Thank you for your hard work in relating this program to other outliners and mind-mappers and those programs to each other.

I noticed two places where a comment or correction might be helpful to readers:

(1) You describe the notation for agent queries and actions as a "scripting language". I don't think most people would consider this a reasonable use of that term, as a scripting language is just a kind of programming language, but you can't do any programming with this notation: no variables, no control flow, etc. However, the latest version (2.3.x) expands the notation to include some of what is allowed in HTML export templates, which are more general (they have if-then-else controls, for instance) so this is getting more powerful. But to say that Tinderbox actually has an "internal scripting language" is misleading. (Conversely, you suggest that Tinderbox has no AppleScript support, but this is not true either: the support is just very sparse.)

(2) Your discussion illustrated by the screenshot of the color attribute editor is confused: in this dialog you are not editing the color of a note at all, but the list of color names available to the current Tinderbox document and their associated color definitions. The row of color swatches displayed are not supposed to "work", if by that you mean that you want to click on them to select them. They show how the selected color looks when Tinderbox's modifiers are applied to it: light, dark, darker, etc. You edit the color of a note by calling up the Rename window (select the note and hit Enter) and using the pull-down menus there, or using the color menu on the main menu bar. You are confused between the attributes of a particular note and those defined for the system or document in general.

kiyong · October 5, 2004 - 03:21 EST #8
yes! please review task manager outliners! i use omni outliner and i think it's great with its columns.

i tried the demo of tinderbox and it was just too frustrating. i wanted to use it for writing fiction, and i could see how it could be great to have agents for characters and scenes, but it was too hard to learn. is there any other software that can find and sort like tinderbox?
Andy · October 8, 2004 - 23:28 EST #9
Anyone know of plans by the developer or third parties to write some comprehensive and user-friendly documentation for Tinderbox? I know you're supposed to experiment with it, but I'm one of the people who gave up pretty quickly after playing around with the demo. I'd be willing to put some time in, but I need a little more guidance. As other people have commented, it seems to be geared toward programmer types.

It's a shame, because like Ted says, paying $145 is not that big a deal if it's a powerful program that you're going to use.
Stephen R. Diamond · October 10, 2004 - 13:52 EST #10
Outlining is a way of minimizing the distractions inherent in text processing when setting out and manipulating the structure of text. This gives rise to two standards of quality: elegance in eliminating distractions and power in manipulating text. Although these factors will have importance for all users, users seem to diverge in their emphasis. The surprise in comparing outliners on Windows and the Mac is that the Macintosh outliners are more powerful than what's available on Windows, while there are Windows outliners more nimble and elegant than anything the Mac has.

If Tinderbox is the best example of a Macintosh power outliner, BrainStorm is the best example of a super-elegant Windows approach. In answer to Ted's challenge, BrainStorm has the following ergonomic features that appear absent from any outliner on the Macintosh.

Eliminates all headers but a parent and its children, for focused work on the order and coherence.

Preserves the order of the user's selection of headers in mark and gather operations. (Not currently supported on the Macintosh, but the pre-OS X outliner MindWrite had it.)
John Stephan · October 11, 2004 - 13:59 EST #11
Thanks for this excellent and thorough article. Generally, I think that simple tools are far superior to complex tools, but I remain fascinated with Tinderbox because I think that it's potential is mind-boggling. Please do review task managers etc. next. I have found that the line between the tools to manage _what to do_ and the stuff to do these things _with_ is blurry at times. It'll be interesting to see a survey of such tools and compare where each draws that line. I mean no _one_ tool could effectively manage everything, right?
Kevin Sheridan · October 12, 2004 - 16:05 EST #12
A small correction to your review: You state that NoteTaker will "soon" be AppleScriptable when in fact it is currently scriptable and extensively so.

The newest NoteTaker scripts allow blogging directly from a NoteTaker entry using either Ecto2 or MarsEdit. This site explains the ins and outs of doing so:
Ted Goranson (ATPM Staff) · October 12, 2004 - 23:17 EST #13

It wasn't clear. What I said was that some outliners do AppleScript well, and NoteTaker does not yet... meaning it does it but it isn't yet sufficiently mature to endorse.

Best, Ted
John Belew · October 13, 2004 - 06:35 EST #14
I'm auditioning outliners for use with organizing my doctoral research. I also would like to use the visual tools and links to help me approach concepts in new ways.

Are there any of the visual-style outliners like Inspiration that have internal links built into them?

VooDoo Pad has the internal linking that is just what I'm looking for (HogBay also),but they seem to be mainly oriented to blocks of text. It seems that Inspiration only creates links to external documents and sites (though I could link to other Inspiration documents). If Inspiration had internal hyperlinks so that each time a word appeared that I wanted to have linked, it would show me that in whatever form the word appears.

(Excuse my inexact use of software lingo, I'm not a programmer, etc.)

Also, I was doing a similar search about a year ago, and I downloaded a trial for a nice outliner that had sort of a PowerPoint look to it, but it was more fluid and had more visually creative tools. (It also had a great tutorial similar to Inspiration's.) Now I can't find any trace of this program.

Any ideas would be helpful - thanks for the great series.

--John Belew
Matt Cawood · October 15, 2004 - 20:38 EST #15

You might have been looking at Curio - It's a superbly written piece of creative thinking software that is almost the complete reverse of Tinderbox, in that it uses "lickability" as way of stimulating the creative juices. V2 has just been released, and includes an interesting but clunky outlining feature.

I've been dithering between the two, but am coming down hard on the side of Tinderbox after it clicked on the third or fourth go. It's taken me 18 months since switching from Windows to realise that TBX can replace, and in many cases better, Tom Davis's Zoot, which is the only thing I pine for from my Windows days. I'm hoping, with others, that TBX's UI will improve, though. Brains + Beauty is an unbeatable combination. Were they both present in TBX, it mightn't have taken me 18 months to discover TBX's inherent loveliness.

John Belew · October 16, 2004 - 07:01 EST #16

Thanks for the tip, Curio is exactly the program I was searching for from last year. I was surprised that it wasn't included in ATPM's list.

And now Tinderbox looks like the main candidate for my needs. It looks like it's got deep flexibility for internal links which is what I'm looking for.

Thanks again,

Ted Goranson (ATPM Staff) · October 16, 2004 - 11:27 EST #17

You must have missed the column just prior to this onet. Curio was presented at some length in that piece. An upgraded version has ben released which, as Matt mentions, has indented lists. Its a small step toward outlines of outlines, but handy.

For a future column, I'm doing some heavy experimentation in combining outliners in creative ways. Curio is friendly to such experimentation.

Best, Ted
Matt Cawood · October 17, 2004 - 19:40 EST #18
If it was possible to get a pup out of crossing Curio and TBX, I think it would be somewhere near my idea of software nirvana.

Stephen R. Diamond · October 18, 2004 - 02:01 EST #19
Ted, you caution us against choosing outliners based on isolated features as opposed to design philosophy, but sometimes a single feature expresses a design philosophy. At other times a single feature may so severely limit the use of a product that design philosophy is no longer at issue.

ADM has a feature--or the absence of one--that left uncorrected would remove it from contention. Its undo of text is limited, and there is no undo for hierarchy. End of story? Perhaps.

I cannot even imagine finding use for a product where:

... the outline headers don't wrap, so you if they are longish, you won't be able to read them in the outline view. The screenshot shows this and another problem: how the anti-aliasing gets messed up when the header is highlighted.
Minton D. · October 19, 2004 - 20:02 EST #20
I'm still looking for my ultimate free-form database, one in which I can enter in notes as they come to me and stamp them with metadata. The drawbacks of using TBox for this have been mentioned in the review: namely, the impossibly long list of attributes connected to each note. I realize that TBox has prototypes for the easy stamping of notes, but being free-form means I need to combine various keywords at will and without fore-thought. I also need something that auto-titles for me by just excerpting the first line of my note (such as Notational Velocity); this is an invaluable aid to productivity as most often the first line is enough to provide an adequate context. Given these requirements, I'm afraid to say that I sold my powerbook and have been using Personal Knowbase on a pc. Circus Ponies Notebook comes close, but I'm still pretty disappointed by how few Mac applications there are that allow user-defined metadata. I'm hoping to jump back into OS X when Tiger is released - meta-data will be at the finder level and I hope I can use the finder as my next power-outliner.
Ted Goranson (ATPM Staff) · October 20, 2004 - 07:15 EST #21
Curious ATPO readers can peruse screenshots of Personal Knowbase at this location. It hasn't been mentioned in any previous columns because it doesn't leverage outlining.

Note that what Minton is calling metadata are really just keywords associated with a note and not any other attribute (like for instance "children of", or "linked to" or "created after" or "containing 2 or more mispellings"). In my book, key words are the least powerful if most common of metadata types.

Best, Ted
Jules Mimeault · October 23, 2004 - 10:40 EST #22
To Minton D. and Ted Goranson,

It seems to me that not having formally many kinds of metada, NoteBook offers a powerful way to provide user-defined metadata functionality through multiple keywords. In fact, one needs only implement an organized set of two-parts keywords: a label part and a content part. For example keywords starting by "TN:" for Type of Note, or by "KW:" for normal content keywords or "PJ:" for Project, and so on.
And NoteBook provides any way some metadata that needs special format for sorting, like "Date created" and "Date Modified".
Hope this can be useful to anyone.
John Saminetti · November 17, 2004 - 16:48 EST #23
I would be very interested to see your thoughts on outlining task managers, since you've done an amazingly comprehensive treatment of the general category.

I've used OmniOutliner, Bonsai, and ListPro - using ListPro now but I can recommend any of them.

I have discovered that any of these are good enough to do basic or moderate project management! What I forego are some of the advanced bits of projman softwares such as resources and auto-schedules but I retain some dependency function with linked tasks. What I gain is simple: ease of use and less headaches! It's easier to use, easy to share, easy to teach, and easy to isolate and focus on the relevant subset with quick sorting and filtering by column.

I think that "power" and "depth" are less important to task outliners than to the traditional writing/idea type outliners. In place of those values I nominate "simplicity" and "usability".
Todd Flaming · December 9, 2004 - 22:44 EST #24
I found an excellent outliner for Windows -- ActionOutline. It is a two-pane outliner that is simple: outline left, text right, no clutter. And it shows only the text that is underneath the outline point. Great for writing long documents. But I cannot find a Mac equivalent. Any thoughts?
Ted Goranson (ATPM Staff) · December 10, 2004 - 10:40 EST #25

Welcome to the Mac. ActionOutline is pretty ordinary as outliners go. There are quite a few two page outliners on the Mac that could be considered equivalent or better. I suggest you browse through old ATPO columns and try a few demos.

Mac outlining is a different world: there isn't a "winner," instead many options for a good fit. Good luck.
Andy Howell · April 7, 2005 - 10:27 EST #26
Tinderbox is very powerful, not quite like anything else and frustrating to use! You can use this app as a simple outliner, or use one of the public exchange programs. Nut to get the bets out of it you will need to learn how the attributes and scripting works. I am going through this at the moment because I can't find any other blog solution which is flexible to do what I want; I've realized that I will just have to learn Tinderbox thoroughly.

These days I tend to use other profucts for veyr simple outliners, for example OmiOutliner is my first choice for helping me write reports, articles, etc.

Tinderbox scores when you realise that you are going to be holding a lot of data and for that reason I usually use it for managing large, on-going projects.

It is also good - in graphic mode - for those times when you want to brainstorm - or when you are having trouble thinking!

Add A Comment

 E-mail me new comments on this article