About This Particular Outliner
Writing Environments, Plus Two New Outliners
What a Writing Environment Is
This ATPO, we go back to our roots in one way, and stray in another.
To judge from the links to past columns, the most popular ones are those that listed the types of things that an outliner might do. Then we gave examples from existing outliners. The idea was that outline uses vary all over the place, and outliner users are often highly individual in how they work. So rather than talk about whether one product was better than another, it would be better to note what the various capabilities were and let readers decide which might suit them, and then follow the chain to a product.
Or bug the heck out of a developer to add a certain capability.
We’ll do that now with writing environments, or at least begin to. Here’s the method I plan. This column we’ll just note the types of things I suppose should be on a list of capabilities to consider. You might call them features. We’ll list them this time, with another list of the products we’ll draw from for our examples. Then you’ll have some time to set me right, correct, and add things. Next column, we’ll redo the list, show examples, and give some discussion.
OK? It’ll be like the old ATPO days.
Where we are deviating from the ATPO model is that many of the applications we’ll look at don’t use outlining. You know, usually I’m pretty strict about what we discuss here and at drawing the line around outliners. But I’ve had many requests to address writing, and it makes such sense to. Many ATPO users are in the outliner community because they use their outliners in workflows that produce some written output. I admit I am one of those. And it just doesn’t make sense to talk about writing without starting with the actual writing process and seeing where it takes us.
The applications I propose to draw from are:
Glass Writer $20
Jer’s Novel Writer in beta
NovaMind Screenwriter $199 ($99 without screenwriting)
Scrivener in beta
SuperNotecard $29 ($34 with screenwriting)
Microsoft Word $239
If you have others that we should consider, let me know. And of course we will also draw when appropriate from the ATPO power outliner list, which currently has these (leaving off the journaling ones):
Curio Pro $129 (versions at $79, $39)
DEVONthink Pro $80 (versions at $40, $20)
OmniOutliner Pro $70 (standard version at $40)
…and one of the two we add below. As with the process we followed when looking at outliners, if you know of a product on Windows or Linux that has features that are not available on OS X, please let me know and we’ll include them.
The Capabilities List
Here are the various notions, features, and capabilities that have been suggested to me. Treat these like the outliner features: things that you might want, each one being something that someone intelligent absolutely must have.
More Than TextEdit
Whatever surrounds and supports the pane you actually do your writing in, that pane needs to support the most capable editor you can find. That means all sorts of little things that add up to big things. Since the least feature-rich you’ll encounter is likely to be the system’s built-in text editor—the same as used in TextEdit—we’ll use that as a baseline. It’s good enough for notes, but you might want better. I think there might be a long list of possibilities under this, including folding and conditional text—also, stuff such as split editors and multiple clipboards.
You might expect that your writing environment will take clever advantage of everything Apple supplies, so far as system services and user interface goodies. Essentially, that means your environment needs to have been designed as a Mac-only application with Cocoa in mind.
No matter how well the tool is designed, you might want just that one capability that would suit only you, or round out a peculiar workflow. That means you might need extensive tailorability, flexibility, extensibility. It may mean AppleScriptability, or a plug-in architecture. It might also mean programmable triggers such as glossaries and shortcuts.
Full Screen, Different Views
One of ATPO’s reasons to be excited about outlining is because it allows you to shift focus from the entire document or its structure to focus on a single element on which you are working. This collection of features concerns the focus. It might be an outliner hoist, a full-screen writing mode, or some sort of other effect. It also covers the ability to switch from WYSIWYG styles to styles and layouts more suitable for viewing, editing, writing.
This collection of features is the opposite end: various means to see the whole document or some substantial part of it or its structure and the ability to relate the parts you are working on to that structure. Outlines of various types are common, but graphical layouts are common, too. This collection of features not only allows you to see and comprehend the structure, but also to enrich and modify it. So links and clones come into play in this bag.
Now this one may not be optional. You need to have some way to annotate what you are working on. That might be by labels or tags, by column content, by notes, annotations, or by marginalia. Things you might be interested in noting are the progress, things to consider, or work to be done. Or you might note sources—all sorts of things. Some of these would be live only during the writing process, while others might live on as footnotes, endnotes, and sidenotes. I consider filtering to be associated with this, and smart folders.
Styles (With an Emphasis on Structural Elements: Tags)
We’ve done some columns on styles. There’s an awful lot to style management beyond setting text appearance for printing. It’s all about adding structure to the document, all the way down to the character level. Much of this structure may relate to support for authoring.
Integration With Snippets and External References
This collection of features includes the ability to reference stuff not in the document and to collect stuff from all over to include in some phase of the life of the thing. It’s non-trivial. We should include here tools to find and filter the things once collected or linked. Also of interest may be tools to massage or transform them as needed.
Export and Layout
Finally, an author generally needs to publish in some way. So composition and layout tools for whatever modes needed are important, or means to link to special-purpose tools for this. Let’s include here all the variables and tables, indexes and such, that a good layout program would include. Alternatively, for Web, blog, hypertext, help, or whatever non-print mode, you need mode-specific publishing support. We’d include here version control and integration with content management systems. And we’re not just talking text documents here; there’s the whole array of media types and delivery.
Leaving the zone of writing environments now, we look at a new application that qualifies for the ATPO power outliner list, EagleFiler. First, some disclosure. EagleFiler’s developer is Michael Tsai who is C-Command Software and the developer of SpamSieve, a very highly regarded spam filter. Michael is also the publisher of this fine periodical. ATPM is an all-volunteer effort, but if I got paid, I suppose Michael would be my boss. But I don’t, and he ain’t. Still, its a relationship I should mention.
I think there will be a lot of attention given to this application, with reviews far more useful to you than this brief mention in ATPO. I’ll generally outline what it is and then just focus on a few elements of interest.
In terms of market, it competes in some way with Yojimbo and DEVONthink. Both of those are repository-type applications with special attention given to ease of getting things in. Generally, once an item is in one of these applications it is intended to be relatively static. That differentiates this class of outliner from more writer-oriented and note-taking applications where the user is expected to create and evolve material within the thing.
Yojimbo is designed to be so simple that the developer’s mother can see all the way through it. It has no way to build structure and relate items, so it isn’t interested in outlines. DEVONthink is at the other end of a spectrum. It supports nesting, cloning, and links. It has a useful “semantic grouping” assistant that finds internal structure based on matching words and phrases, allowing DEVONthink users to edit and create material. A recent version just added a “full screen” editing mode.
DEVONthink’s Full Screen Mode
Many of our ATPO power outliners can be used as a repository or clipping manager, but right now these two apps (Yojimbo and DEVONthink) dominate. EagleFiler will probably introduce new users to this domain because it uses the (by now) very familiar three-paned interface and because it handles mail extremely elegantly. It’ll probably also steal many users from Yojimbo because it is scriptable and leverages hierarchies, both of which Yojimbo (a bit inexplicably, I think) has eschewed.
The EagleFiler Layout (Showing Mail)
EagleFiler is missing stuff we celebrate here at ATPO, stuff such as links and clones. It has some prebuilt smart folders and columns, but you cannot yet roll your own. I expect users to ask for these things, and for C-Command to respond. Knowing Michael’s background and his experience with SpamSieve, I would expect some very capable semantic grouping to be added in the future. And I suppose it will be different than what DEVONthink offers, which is still leagues better than Apple’s Spotlight.
So much for the overall picture. There are three things about EagleFiler that ATPO readers will be interested in.
The first is in the way it integrates with the environment. In early ATPO columns we traced the history of outlining and along the way we mentioned Dave Winer’s creation of Frontier. Frontier was the first scripting environment for the Mac, appearing well before AppleScript! Dave is a difficult man, but I surely must give him credit for seeing the intimate relationship between scripting and outlining.
“Scripting” in this context means more than controlling a single application. It’s all that wonderful promise we hoped for more than a decade ago when the concept first appeared—that applications could be tied together in intimate ways, almost synthesizing new applications. Many of us really believed that promise, and looked forward to the day when every user’s “applications” were unique to their own imaginations and needs.
I remember my own joy upon installing an application that had no user interface and was just there to be integrated into other applications by scripting. It was a computation engine that had specific strengths for engineering calculations and also (incongruously) assembly of color sets, using rules about what works visually. I was so excited that I travelled to meet the guys doing it. Alas, with my old brain, I cannot fully recall all the names. I think it was in 1993, the product was Sum Total, and the company was Concurrent Engineering Tools.
But the idea faded, and AppleScript went through a period of virtual abandonment at Apple, to be used mostly by publishers with complex workflows with Adobe and Quark products. AppleScript and other scripting languages the Mac now supports are coming back strongly, and we are in a new era. I think there is a space, a huge one “in between” applications, where outlining and repositories can really shine as part of an integrated workflow. EagleFiler has stepped into this space boldly. Good for it, good for us.
To understand what I mean, you’ll have to look at the way it collects things. In ordinary apps, you have to initiate an action, by keyboard or mouse and all the innovation is in making that easier somehow. Tsai’s thinking about scripts allows you to automatically harvest stuff. It isn’t a subtle difference.
And there’s another thing. The Finder is an outliner, at least so far as files are concerned. EagleFiler, like many of the newer outliners, uses the built-in Tiger database facility, the so-called Core Data, but in a clever way. When you put things in a database, well they are in a sort of black box. DEVONthink’s (and Mori’s) user interface emulates a Finder view, and you can drag things out of the database into the Finder, but you are in one or the other. Yojimbo is the same.
Look what EagleFiler has done. Files are actually stored in the file system. If you trash EagleFiler, they will still be there in standard form, just as they would normally be. Core Data is used to store and manage all the metadata that EagleFiler associates with a file, which, needless to say, is scads more than the Finder does. It’s about as open a method as you can imagine. You can navigate to files in the Finder, or Path Finder. Or locate them in the EagleFiler interface and “Reveal in Finder” or Path Finder. If you move them around in the Finder, however, you may mess things up in EagleFiler, just as it is with iTunes.
Because of the cool way EagleFinder integrates with the Finder, you may find it very useful to experiment with a writing environment that is based on EagleFinder, Path Finder, and your favorite power editor, such as BBEdit or Aquamacs.
The final thing to mention is something that really makes me smile as the ATPO gardener. In an earlier column on user interface futures, I described a technique that we are using on something we are developing here. There’s no reason that all the things in an outline need to exist in the same universe. Some of our power outliners already mix different things in their outlines. I’m thinking of how we accept so-called “smart folders” in our hierarchy. It’s often made a bit easier by using an icon that looks like a folder, but smart folders are different beasts than folders. They are saved searches, usually dynamically updated searches.
Mori with Nested Smart Folders
Suppose we added yet more item types to the hierarchy, and we made them active, and we allowed them to have drags to assign or change behavior. I claim to have invented this and have explored all sorts of different behavior. It’s nice to see EagleFiler use it in a simple, elegant way. One sort of metadata that EagleFiler manages is the notion of a “tag.” The user can create these and they appear in a Tags folder. If you drag a file in EagleFiler to one of the tags (which exists in the same source list as other folders) the file gets assigned that tag. Tags are user-defined and have an icon or badge associated with them. It’s a clever UI for assigning metadata, and is generalizable to any outliner.
Dragging a Note to Assign a Tag
EagleFiler is $40.
In our survey of legacy outliners, we mentioned Acta. It was an amazing piece of work in part because it still worked well under Classic after all these years. Acta was where those flippy triangles were introduced to outlining, and it was one of the very first outliners that would be recognized as such today. David Dunham has kindly made Acta a free download for many years now.
But now Apple is abandoning support for Classic, so David has re-imagined Acta in Cocoa for OS X, and the result is Opal, available for $32. Acta and Opal are “pure” outliners in the sense that there are only topics, what ATPO usually calls headers. That means there are no notes or comments, like you are used to seeing with most ATPO outliners. No links or clones either, and no named or level-specific styles.
Opal Styles and Images
Entries are fully stylable, though. Drag and drop is well supported. You can intersperse graphics (but you apparently can’t play media files). Links to external files and URLs are supported. You’ll find moderately good keyboard and scripting facilities. It opens and saves OPML, but without note or column info, obviously. It has folding, hoist, and “filter,” which is a sort of search facility.
Tao in a way is its closest competitor, mirroring the more than a decade-old competition between MORE and Acta. (They are about the same price.) If you choose to use Tao without notes and columns and metadata (and palettes, oh those palettes!), you will find that Tao has the traditional outlining commands that Opal lacks, things such as combining and splitting topics.
Tao’s Simple View
But there’s a joy in using something that is clean, apt, fast, and focused on pure outlines. And there’s a special celebration that at least one of our legacy outliners, one of our oldest, has survived to be reborn in Cocoa.
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