About This Particular Outliner
Two New Outliners: Mori and iKnow & Manage
Your ATPO correspondent is embarrassed this month. There is so, so very much going on the outlining world, and all I can manage this month is to introduce you to the two newest entries in our domain.
(I’m still hoping that someone can help me put together the monthly “tracker” feature that advises on updates, changes, and news in the Mac outliner area.)
Even though we’ll be talking about two outliners only, it opens interesting territory. That’s because both of these use a database under the user interface. This is a non-trivial development.
You see, outlining started life in the “document” model of files, where the entire document was in one file, just as if it were a word processing document. In other words, it had one beginning and an end, and all the outlining did was work with the structure of the document, initially just folding it.
Since then, ATPO-type users have demanded clones, links, re-ordering, sorting, and gathering functions. These things get harder and harder when you think of each note as a section in a large document. Still, many outline users work with outlines with the intent of producing a final document for printing. And that means they’ll end up in a document-centered application anyway.
But hey, today “publishing” is as likely to mean publishing for the Web as for print. And at the other end of the process, the note-taking and gathering phase, you’re likely to vacuum up all sorts of things: images, PDFs, Word documents, URLs, Web pages, even RSS feeds.
So some of the outline-savvy applications we’ve been tracking use a database under the hood. That’s true of DEVONthink Pro and StickyBrain. Devon uses a proprietary database, and StickyBrain uses OpenBase, as does Daylite.
If you are new to ATPO, Daylite is one of the outline-savvy task and contact managers we’ve been tracking. Some of the others of these use databases internally too. But here, we’re talking about outlining as the tool you’ll use to collect information, massage and work with that information, and eventually use some of it in a publication of some kind.
The first of our two new outliners is Mori, which comes from the developers of the unfortunately named Hog Bay Notebook. ATPO regulars will recall that outliner fondly. Of all our power outliners, it gave the biggest bang for the buck. It was the cheapest, and yet had clones, links, and AppleScript, the three biggies which no other power outliner seems to have yet accomplished simultaneously. And it had other interface goodies, some unique.
But Hog Bay Software has retired it and replaced it with Mori, a completely new and somewhat different product.
Perhaps no other event so clearly illustrates the vitality of the Mac user base than that such a thing makes sense. We are in the midst of an escalation of power in the domains that outliners touch, and all the innovation is here, on the Mac.
Basically what Hog Bay has done is re-engineer the product to leverage the Core Data functionality introduced with Tiger. It is the first product I know to do so. Core Data is a huge advantage for Mac developers that can start anew. It unifies several cool things including a clean factoring of the interface from the “control” code and the database. It uses an open-source database called SQLite. It’s almost a textbook case study of how proprietary and commercial software can be creatively blended.
This Core Data methodology makes it easy to define boundaries of functionality so that third-party plugins can be written. Hog Bay is banking on this. Old-time Mac users will recall that Adobe had two so-so products in Photoshop and Illustrator that they couldn’t improve fast enough to best the competition. So they opened up a plug-in market. A typical user might spend more on plug-ins than on the basic application. This push effectively killed the competition for Adobe.
NoteTaker has a somewhat different plug-in strategy. It relies on familiarity with Java and plugs in at the header level (which it calls cells) to derive and display cool content. (NoteTaker also has strong AppleScript support.) Mori’s plug-ins, if I understand it properly, can extend the functionality of the application itself. Want a supertwiddle that will wrangle headers in a peculiar way according to your own search and gather requirements? Write a plug-in!
The plug-in architecture is open and based on the increasingly popular Eclipse framework. Installing and managing plug-ins is easy and done the way outliners should, through an outline in the preferences! You’ll see that most of the functionality that is provided already is by plug-in-like modules: blocks.
Mori Plug-in Outline
OK, enough about architecture and possibilities. That’s where the news is and why we’ll want to follow it. But what can you get if you buy it today (at $28)?
Opening Mori gives you a three-paned window. On the left is an adaptation of the library and source list that iTunes brought us. In several other power outliners this exists as a drawer and serves as a sort of Finder view and a way to readily navigate through large outlines, or if you prefer, many outlines.
This pane was a drawer in Hog Bay Notebook and—as I say—others. Changing it to a regular pane is appreciated because you’ll want it open all the time and this way gives us a full toolbar across the whole window.
It also contains “smart folders” that can be set up much like those of iTunes. They aren’t quite the multipurpose “agents” of Tinderbox. With those, you can search by all sorts of attributes and collect clones that even change behavior or content according to your scripts.
These smart folders are like those of iTunes or Tiger’s Finder in that you set one or more criteria and items are collected without hierarchy. In those cases, as here, you can nest smart playlists or folders in regular ones. The hierarchy in Mori is a little different, though. Files can be nested under other files, following its outlining tradition. At present, Mori’s smart folders don’t allow as many criteria as the Finder. But since this is controllable by plug-ins, we can soon expect the ability to create smart folders based on hierarchy or linkage relationships (like Tinderbox’s).
Mori has ordinary clones as well. It calls them aliases, but deleting one preserves the other.
Mori supports links. These are links of the Web kind where a marked text block is highlighted and jumps to a new note.
So far, the search among notes is rather simple.
Mori supports columns, too. These also are rudimentary at present: user-created columns can only contain text. However, the underlying database supports all the usual types (dates, numbers) and I’m told that support for different types and calculated values such as sums are close. At this point, you cannot use user-defined columns as attribute markers that are used by smart folders. In other words, you cannot make a column that has a pop-up between “draft” and “finished” and make a smart folder that collects all the drafts.
Clipping is supported by a Mori service with a few choices, and Quicksilver if you use it. Many writers do, because it leverages the keyboard. The notes in Mori are traditional RTF notes, which can include QuickTime objects. In other words, they aren’t “grabbed” items like Web pages and PDFs like you’d store with DEVONthink.
I’ve been giving talks recently as part of my professional activities. In these, I’ve started mentioning different sorts of ideals for Mac outliners. One in particular is of interest here.
(Maybe we should have an ATPO on these archetypes?)
Anyway, that one type would be a sort of super-Finder that would replace the Finder for many tasks if you were a writer. It would have outline navigation beyond the current Finder, which is the worst thing on my Mac. And it would have built-in gather, navigation, editing, and linking. It would be infinitely extensible and tailorable.
It would be something between this great start at a new power outliner and Path Finder, which has a new version out. At this cost, you should pay attention to Mori as it matures.
One of our basic ATPO values is the ability to add and change structure, and to leverage the graphical display of text. Along those lines is the ability to drag elements around. TAO allows you to drag among different sections of a big outline by splitting the editing pane.
But I find it handier to drag from one window to the other. OmniOutliner has terrific window-to-window dragging, but the windows have to be of different outlines. Tinderbox is great in that it allows as many views of the same outline as you wish. You can drag a structure from one view to another location in the same outline in another view’s window.
Mori allows different views of the same outline as well, so you can do the same thing. (All the views are the same three-pane window where Tinderbox allows different types of simultaneous views.)
Dragging From Different Views
iKnow & Manage Icon
And here’s the other new outliner this period. It too uses SQLite, though it appears to bypass Core Data.
(I expect as Apple builds more and more useful services into the operating system, we’ll see more outliner-savvy applications that exploit them. At this point, we have WebCore, allowing any application to render Web pages; Core Data, a modular, integrated database; Core Image, providing Photoshop-like image manipulation; Spotlight, a system-wide search architecture (whose real impact will be global indexing for metadata); and, of course, the familiar QuickTime, which supports all sorts of media.)
What we have in iKnow (I’ll use the nickname) is a simple outlining front end to a data base.
Imagine an ordinary outliner with a header list on the left and a pane on the right that shows the “note” associated with that outline. You’d be able to manipulate the outline on the left in clever ways and edit the note on the right. Many of our power outliners look like this, though some display the notes below or inline.
But the key concept is that you have an outline of text notes. In some of our ATPO outliners you can associate elements with the basic note: comments, due date, a label, or whatever. Sometimes, you’ll see these associated attributes as columns. But the idea is nearly always that you have at the basis of the note a rich text note or some media object like a PDF, an image, or a displayed Web page.
Suppose you wanted more. Suppose with any header, you wanted two text fields. Suppose you wanted to build your own contact manager, and you wanted fields for numbers, text, dates, and so on. And you wanted these handled in the outline as if they were notes. And suppose you wanted to search on any value in any field using regular expressions.
And suppose that you wanted to merely reference many of your text and image files and Web pages instead of importing them into the database, yet you wanted the search to include those items. iKnow would be something to consider.
Here’s why we are excited about it: what we’re interested in here at ATPO is how the notion of graphic interface and folded text can be leveraged. I suppose iKnow will be competing with StickyBrain and iData2, both of which are also databases. (iData was formerly known as InfoGenie and, before that, as a System 6 desk accessory, QuickDEX. But it doesn’t leverage outlining.)
For contrast, consider the already mentioned DEVONthink. It is a database, but it contains only one sort of element, the “file.” It has means to display and look in those files (whether imported or referenced), but the only thing it understands is words.
As a database, iKnow understands all sorts of things other than words. But first I’ll tell you some bad things about iKnow. The developer is a database geek so he doesn’t appreciate that instead of using terms like “stditem” and “refitem” he could simply use “Item” and “Alias” for the notes that are now data records. And concerning values, an “ItemValue” is really just a value or a subitem if you wish, and a “ValueRef” is an alias of a value or subitem.
The searches can be over all the values in the database, but you cannot do what we have come to expect with familiar “more search” fields. For instance, you cannot say “find me the item with the text ‘boo’ in the comment field, and ‘Ted’ in the Note1 field or if that field doesn’t exist ‘Mary’ in the Note2 field, and in either case only if the record was created less than six days ago.”
And though you can add structure hierarchically, obviously you cannot yet form searches that look for structure. For the external files, you cannot use Spotlight metadata in searches. And you cannot save searches as something like smart folders.
Also, its pretty strict and limited about the kinds of data it will accept. When it says “extended text,” it means styled text only, not the sort of rich text-and-media notes we’ve come to expect. And it handles images well when by themselves, but not PDFs or HTML. You have to reference them externally and open them in their ordinary applications to view them.
But I suppose those things will all come to several of the outliners we track and a few database front ends we don’t.
OK. Let me show you the thing now.
The screenshot shows an example hierarchy on the left using our traditional ATPO nomenclature. In this outline, you cannot create folder-like containers. Everything is a data record. So every “header” on the left has a list of values associated with it, as many notes and other elements as you wish. Again, you can think of each item as a note with typed columns (type meaning date and number and so on) but with many notes if you wish.
Notice the first instance of Item 1b. That’s an alias that is carried over with its children. If you’ve been comparing outliners, you’ll know that concept is rare. Usually only a header can be cloned, not the header and the structure of everything beneath. This is significant.
In this screenshot, we’ve included the toolbar and excluded the info panel. You’ll note that what you see is very much like a three-paned outliner, because in this case we’ve selected in the top a rich text value. Because we have, the contents of that note appear in the simple (very simple) editor below. You may also note that values of other, simpler elements are displayed directly in the top pane.
Here’s another view below. This time we’ve collapsed the tool bar. I don’t like those things usually anyway. And this time I’ve selected an image value. There’s a simple image viewer. We’ve also displayed the info panel as a drawer where you can see the comment field, encryption controls, hierarchy report, and sort order.
Oh, and notice that last value in the value list (“ATPO Extras,” a referenced file)? I added that as an alias. It points to a value in another item at a different level in the hierarchy. So we have two kinds of clones, at the item or header level and at the value level. Cool, huh?
There’s a search view that I won’t show you because it is so far the least impressive thing in iKnow.
Here’s what really turns me on. As with any outliner, you can drag and drop the elements of the outline on the left around, making clones and structure to your heart’s delight. Now watch this. I’m going to grab a value, say our picture of Mary, and move it to another item. You already know I could have created a clone of that value elsewhere, but here I’m actually going to move it:
iKnow Dragging Values to Another Item
See that I dragged it from Item 1b (which itself was a clone) to item 1a? I dropped it there, and there it now lives. This is why I want you to play with this, and if you think this kind of ready reorganization valuable, encourage this developer to go further or others to do something similar.
Since ATPO doesn’t do reviews, I don’t have to go over the import and export capabilities which are fine if you are dealing with well formed files, or if you are content with external references. And there’s a nice item template feature. iKnow is not scriptable. It is $20.
Just before going to press, ATPM sponsor Bare Bones Software announced a new snippet/note manager, Yojimbo. We won’t track it in ATPO because it doesn’t allow any sort of user-induced structure—no subgroups or anything outlinerish. It is a lot like KIT with some easier input paths.
Its use is as a sort of static sock drawer that you toss things into and recover by search, or persistent searches in the form of smart folders. It isn’t intended for you to actually work with the contents by structuring and maturing them. The purported target user is the mother of one of the developers, so unlike other Bare Bones applications it is unscriptable.
We mention it because it is from a respected Mac developer, and all these sudden entries in an already crowded market validate this outliner use pattern. Oh, and like Mori and iKnow it uses SQLite.
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