Architecture

(This section is a little more technical than we like to get in ATPO. Some ATPO readers may want to skip a couple paragraphs about the how and go directly to the what. Just look for the “User Interface” header below.)

FORE/1 is based on the notion of cells like NoteTaker and NoteBook. This notion goes beyond the two traditional types of outline header and paragraph text. Like Tinderbox each cell has any number of attributes. Each cell has a position in an outline.

FORE/1 is novel in extending that notion to agents. Each cell has at least one agent that controls the display, but many agents are possible, including agents that move about. Agents can modify the display, change and generate the existence, type, and contents of cells; and arrange cells in the outline structure.

FORE/1 agents are based on functions, coded using the functional language Haskell, which for five years has been maintained as an open source project largely via courtesy of Microsoft Cambridge Lab. This approach—radically different from normal programming practice—allows the agents to be loosely coupled, stateless, and distributed. (This summer, Microsoft will be introducing a .Net version of the FORE/1 agents in F#.)

Execution of functions in this structured context allows the most advanced state-of-the-art concept modeling, said Golubula, but some of these capabilities have been removed from the lab version of the application for open distribution. (The version that allows distributed outlines/outlining, including assistance by remote agents, is called “FORE/n,” pronounced “foreign.”) We’ll mention one or two of these impressive capabilities when we review the features.

Golubula noted additional novel elements of the architecture:

• “FORE/1 is essentially an outliner GUI for Emacs. Leveraging the existing capabilities of Emacs allows us to take advantage of the stable code of thousands of person-years of coding and even more of review. It is the most complex and capable single application in existence,” he said.

  During the three months I have been using it, there was no time when the I needed to “drop back” into Emacs or even be aware that it was running. FORE/1 used the stock Emacs supplied in Panther as a background process, invisibly installing the necessary extensions (which include OSAXen—AppleScript extensions—in Emacs Lisp).

• There are essentially two applications: the outliner itself, which is written wholly in AppleScript; and the agent space, which is written in Haskell. The source code for both is completely visible and editable in the outliner. The user interface is created in FaceSpan using a free runtime component, which Golubula says was a tough call. They could have done it using AppleScript Studio, which is free. That would have allowed anyone to edit the entire application, including interface widgets. But AppleScript Studio is difficult to use, even for small changes.

  AppleScript Studio brings AppleScript to Cocoa, while FaceSpan is more rooted in AppleScript, simply adding interface elements. This way, a novice can more readily tweak anything at all except adding new interface widgets; for that you’ll need to purchase FaceSpan at $150, or more likely send a request to the developers through Golubula.

• The structure of the Haskell functions is based on a novel application of group theory to information, a formalism that allows the history of each cell to be presented internally in terms of a mathematical “shape.” This representation allows unexpected bindings among cells but more importantly allows higher level abstractions to guide writing and associations. Golubula avoided mentioning the lab’s application, but the demo cells contained unstructured and structured text, unstructured and structured media as both input and presentation drivers, and similarly structured (literate) and unstructured code as content and the application.

• FORE/1 was developed and primarily fielded on Mac OS X. That’s because the lab extended the OS X kernel (xnu) to allow cell functions to control the Power architecture (the basis of the G4/G5) at a very fine level for FORE/n. Something like that was always planned when the lab in question helped fund the Mach project on which OS X is based.

  However, Golubula stressed that the IBM/Apple Taligent partnership resulted in code developed for the similar NuKernel that IBM is using to extend the Linux kernel to support similar functionality on IBM’s high-end workstations.

• IBM is interested in adopting the KDE desktop for its next generation Linux enterprise desktop. It is already committed to speeding progress on KWord as a replacement for the popular FrameMaker which Adobe is abandoning. KDE employs a component embedding technology, KParts which is an updating of OpenDoc, a technology jointly created by IBM and Apple. Apple’s forthcoming “Tigress” employs a modified version of Kparts for its interdocument services.

  Because FORE/1 uses KParts, it can embed in KOffice—or any other KDE application—like the KDE Web browser on which Apple’s Safari is based. All of the KDE applications are coming to OS X/Tigress as a cross-platform competitor to Microsoft Office, with FORE/1 as the outliner component directly competing with Microsoft’s Notebook in its Office suite.

  

  FORE/1 Outline Embedded in KWord

The overall architecture is showed in the following slide that Golubula supplied. Only the elements in the darker boxes are provided in this release. The novel visualization modules are having some classified technology removed and will be available later. They employ concept lattices, hyperstereograms, a novel input/manipulation device based on string figures (cat’s cradle), and the soft logic of Thomas Harriot.

User Interface

Detoured readers can rejoin us here; after all, what matters is what you can do and how comfortable you feel. So in this ATPO installment, we’ll review the user interface, which is the very best I’ve seen for an outliner. In future columns—if there is interest, perhaps in the “mind-mapping” column—we’ll look at some of the extraordinary things the agents and graphical visualizers can do.

At first glance, the outliner is fairly ordinary looking. It comes with all the advanced features hidden; in this mode you use it just like you do OmniOutliner.

There are some differences. The text can be translucently shadowed (which makes an amazing difference), the drag indicator is like we described for NoteBook in ATPM 10.02, but like NoteTaker (and unlike NoteBook and OmniOutliner) you can copy cells by Option-dragging.

You’ll note that it uses an ACTA-like triangle convention. A hollow triangle denotes a cell with no child. There are two primary cell attributes: headers (denoted by triangles) and paragraph text (denoted by bullets and multiple bullets). When exported to Word or applications that accept Word format, these have the appropriate named paragraph styles.

The bullet-labeled cells are effectively outlines within outlines. When exported, they become bulleted lists within the document.

Even in this simple mode, FORE/1 rocks. Each cell can be rich text as shown, an HTML/XHTML item (including a table which essentially gives outliner columns), a number/date, a QuickTime element, or a list or pop-up item. With Apple’s KParts (code named “slide”), publish and subscribe returns! Each cell can contain any document, terminal, spreadsheet, or even other outliners!

Each such external item can be embedded in the outline or referenced from another file or URL, using agents we’ll describe later. Or it can be the result of a structured query to a database. In fact, each reference is a kind of direct link of the type normally used in hypertext. Predefined direct links are mirrored clone, directional clone (a change in the parent changes the child, a change in the child breaks the link), reversed clone, and copy. All of these extend to links inside the outline, across outlines, URLs (including mirrored clones via FTP), and to certain file types of other applications.

FORE/1 supports the normal type of hoisting, where you can “lift” a branch so that only it displays. But you can go the other way as well, “Finder dehoist.” That’s right, you can go on beyond zebra and walk on up the Finder outline. And get this: you can promote or drag an outline header to a Finder header. In this case, that part of the outline becomes a new outline file.

You can drag among open outlines or between panes of the split window of the same outline. Bulleted paragraphs are included in this as well. So we have three levels of outline in a single pane: the outline of files in the Finder, the outlined structure of one of those files, and the bulleted outline within that file. Any element in one can move to the other.

There’s a “horizontal hoist” that I will get to in a moment.

Dragging a selection (which can be discontinuous) to the Finder creates a new document with that nested content according to the last-used nesting rules. Dragging from the Finder or any element in another application’s document opens a dialog asking what type of clone or reference you wish.

Almost everyone will use this free outliner in this “simple” mode, where it can serve as a notebook/scrapbook and/or the ultimate writer’s outliner.

The designers were rather obsessive about having every operation controllable by the keyboard and through the outliner window alone. As a result, the menus as delivered do not have all the commands, but that is user-tailorable: the menus can be created and extensively edited like Frontier’s. Keystrokes are equally fluid, including the ability to have context-sensitive keystrokes and to have compound sequences like Control-S, then B. This feature is decidedly un-Mac-like (but quite Unix-like).

There also is the requisite toolbar, but you won’t really need it once you learn a couple of things.

You’ll notice that everything you need is in or on the window. And I mean everything. For instance, look at how the preferences are displayed and set. As an outline! Skip over for a moment how you get to that preference outline (by “horizontal hoist”). You’ll also appreciate that all the controls are optimized for a one-button mouse. More than that, all the developers work on PowerBooks.

The Advanced User Interface

Now it is time to introduce you to the full-blown user interface that you can access by toggling a preference in the “as-delivered” mode. In the screenshots that follow, we’ll briefly touch on how each element works. In doing so, we’ll stick mostly to ordinary black rich text to make the use of the controls clearer, except for the next screenshot. The screenshot shows all the widgets we’ll review. Each widget obviously has a purpose; most convey meaning with some change in color or shape, and most have hover pop-ups in addition to their own contextual menus.

There are three controls on the left: the State Widget, The Outline Flippy, and the Attribute Flippy.

Horizontal Hoist

The outline described so far is the outline of the content and a parallel outline of attributes and agents. But you can shift the view to outlines of editable preferences and even the code for both the outliner in AppleScript and agent environment in Haskell. Be careful with this extreme tailorability. There is no protection from making damaging changes, and I suspect that most users won’t tinker with the code, instead using enhancements from others. But make copies frequently if you are tweaking the code: you literally edit the application within itself and the changes take place immediately after saving.

Button Commands and Status Pop-ups

Notice those three buttons in the upper right that look exactly like the Apple-supplied ones in the upper left? That’s the setup I use instead of the toolbar. It’s a darn sight cleaner even if we do step on a few rules. The button on the far right is the “gestures” button. The graphic displays of the outline—which we’ll cover in a different column—include a view that is manipulatable by certain motions. I like those motions (symmetry operations on concept lattices) and apply them to the outline when in outline view.

I use CocoaSuite, with the start on this button substituting for holding down a modifier key. But most on the team (far more radical than I) have transmuted their PowerBooks with MacNTouch and use cat’s cradle-derived gestures. Prefab gestures for both are included in the download.

Moving left, the nest titlebar button is the “horizontal hoist” shifter. Hitting that shifts among the “regular” outline view, the preferences outline, the pretty good help outline (isn’t it scandalous how few outliners use themselves for their help?), the AppleScript code, and the Haskell code. Option-click this button and you get the Finder hoist, which we’ve called “dehoist”; and “vertical hoist,” which zooms in as far as cells with cells or bullet outlines within triangle outlines—and it zooms out into the Finder outline if you wish.

The remaining button on the far left is the drag shelf. You can drag a collection of cells there (or have an agent place them there) and drag them out at your leisure, even to another document. Its very handy. I have this set so that it is a third “yank stack,” parallel to that fed by cut/paste and “gather and mark” cells; you can move these stacks among themselves of course or set any of them to be the same.

At the very bottom of the window, sharing space with the scroll bar, is a tailorable status area. This is set up in the screenshot as indicating certain features of the cells. Clicking on one indicator gives some quick options that you would otherwise have to open the attribute outline to see or change. The ones in this screenshot are from left to right: whether the selection is a cell or a subcell, its age, its stylename, its clone/reference status, its type (RTF, HTML, etc.), its nested relatives (subcells, children, multiple sources).

Other Stuff

We’ve skipped over some features. FORE/1 can be embedded in Path Finder as the preview editor, which gives a different sort of Finder outline integration. It works well with all the content in a database; I use FileMaker 7. Because FORE/1 uses XML, you can shift your outlines back and forth with Tinderbox without losing anything. Much information from either application’s scheme is inaccessible from the other application. You can publish via OPML (which erases much of the cool information), through Tinderbox (or any layout application that accepts XML, like FrameMaker, KWord, or InDesign), or any of the new KDE-derived Apple “iOffice” (code named “Jeholodens”) applications.

FORE/1 indexes by n-grams (usually two-, three-, and four-letter sequences) in addition to words. The two together with any tagging and modeling that exists have all sorts of advantages in actually guessing at the meaning of words. So when you do searches, you can get results according to the “semantic distance.” A new mailing list and wiki have been set up to advance this technology.

Like Tinderbox and FileMaker, you might consider FORE/1 an open-ended development platform. You may be hesitant because you think you will need to “set it up” in your own way before accessing its power in ways that you can leverage. Recognizing this fear, SAIC is tasked to adjust behaviors so that FORE/1 emulates three of the legacy outliners we surveyed last month. That will provide a ready entry point for the non-power user.

Negatives

The outliner has several weaknesses. Because it is implemented in AppleScript, it is slower than a normal application. I have used it for a few months on my 1 GHz PowerBook with no problems, but I fear that older machines or huge outlines will produce annoying delays. There is no snipping service, as the Cyrobolics Lab used their own AppleScripts for input. Surely someone will add snipping management soon because it will be so easy.

You can display way cool HTML in cells, including tables, layers, and the whole bag. But you cannot edit the HTML in FORE/1, other than changing text. You need to use a separate application for that.

The export to other applications is extremely flexible because the native representation is XML. The schema used is included in the download. All program-to-program and program-to-Web translation is done by XSL translations. This is not something a casual user will create. Two-way translation to Word, KWord, FrameMaker, and InDesign is included, plus two blog templates. But you’ll have to tweak them if you have specific layouts in mind, and this is non-trivial.

And as noted, for the time being you’ll have to export to another application for graphical display and manipulation of relationships and links. Even more basic: printing is pretty hosed up from FORE/1. You’ll have to use a layout application for that too. Named styles will convey though.

You should also be warned that the original developers feel obsessive about certain things. For instance, they believe in multiple windows; if someone insists on adding tabs to their creation, they are likely to sneak into your house at night, eat your food, and paint your furniture ugly colors. And they can do it too, under the current administration. Even though we have been friends for decades, I’m still afraid; there is nothing more dangerous than a spooky outliner who’s been offended.

Department of Corrections, Apologies, and Additions

By now we hope you have discerned that FORE/1 actually stands for 04/01 (April First) and is a hoax. At least the actual existence of the application is—and some of the background we mentioned. I apologize for any damage done to your expectations. Maybe we should make it, or get the Cyrobolics folks to release it.

If there is interest, I’ll describe what the fictional Cyrobolics geniuses have concocted for graphical concept mapping when we survey the products you can actually get that do “mind—mapping.”

This column was originally intended to survey features of Windows outliners that OS X users don’t have. The idea was to prompt enlightened users to spur OS X developers to improve their own particular outliners. But amazingly, after significant effort, we found nothing worth bothering you about. What makes this so annoying is that most Windows outline developers do not have much description on their Web site, nor in the documentation. You actually have to work with each one to discover its capabilities, so it was as much work as last month’s column with no result.

There are some interesting Windows products, but all of them (excepting perhaps Skwyrul Pro) are disturbingly ugly and clunky in their user interface. NoteMap is a simple outliner that has an imperfect round-trip export/import relationship with Word. No one on the Mac supports Word round-trip. This matters because stuff like InDesign and Quark understand Word, and many writers like to work in phases, shifting from their work back and forth from outline to layout views, like you could do in FORE/1.

Lacking anything interesting to say on outliner features from other platforms, I decided to describe an ideal outliner of sorts to goose up the dialog you should be having with all these clever Mac developers—the ones that support your creativity.

• • •

We have a new outliner! Zengobi, Inc recently shipped version 1 of Curio. The feature set of this first version is targeted toward “concept discovery,” but it is intended to grow to general-purpose brainstorming. What makes this notable is that it is a completely new take on outlining, sort of a cross between OneNote for Windows and Apple’s Keynote. This vision has gas, and is worth following.