About This Particular Outliner
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.
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.
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:
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.
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.
Or you can see similar information in a more graphical format in the “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.
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
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.
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.)
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).
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.
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.
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!)
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.
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.
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.
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
- A Progress Report · February 2008
- Some Perspectives on the Worldwide Developers Conference · July 2007
- Writing Environments, Plus Two New Outliners · November 2006
- Examining New Business Models · September 2006
- Outlining Interface Futures · July 2006
- Outlining Workflows and ConceptDraw · May 2006
- Dossier and Outliner Web Interaction · March 2006
- Two New Outliners: Mori and iKnow & Manage · February 2006
- Styles Revisited, Video Features, and a Proposal · December 2005
- Complete Archive